// Copyright 2013 The Flutter Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#define RAPIDJSON_HAS_STDSTRING 1

#include "flutter/shell/common/shell.h"

#include <memory>

#include <sstream>

#include <utility>

#include <vector>

#include "flutter/assets/directory_asset_bundle.h"

#include "flutter/common/constants.h"

#include "flutter/common/graphics/persistent_cache.h"

#include "flutter/fml/base32.h"

#include "flutter/fml/file.h"

#include "flutter/fml/icu_util.h"

#include "flutter/fml/log_settings.h"

#include "flutter/fml/logging.h"

#include "flutter/fml/make_copyable.h"

#include "flutter/fml/message_loop.h"

#include "flutter/fml/paths.h"

#include "flutter/fml/trace_event.h"

#include "flutter/runtime/dart_vm.h"

#include "flutter/shell/common/base64.h"

#include "flutter/shell/common/engine.h"

#include "flutter/shell/common/skia_event_tracer_impl.h"

#include "flutter/shell/common/switches.h"

#include "flutter/shell/common/vsync_waiter.h"

#include "rapidjson/stringbuffer.h"

#include "rapidjson/writer.h"

#include "third_party/dart/runtime/include/dart_tools_api.h"

#include "third_party/skia/include/codec/SkBmpDecoder.h"

#include "third_party/skia/include/codec/SkCodec.h"

#include "third_party/skia/include/codec/SkGifDecoder.h"

#include "third_party/skia/include/codec/SkIcoDecoder.h"

#include "third_party/skia/include/codec/SkJpegDecoder.h"

#include "third_party/skia/include/codec/SkPngDecoder.h"

#include "third_party/skia/include/codec/SkWbmpDecoder.h"

#include "third_party/skia/include/codec/SkWebpDecoder.h"

#include "third_party/skia/include/core/SkGraphics.h"

#include "third_party/tonic/common/log.h"

namespace flutter {

constexpr char kSkiaChannel[] = "flutter/skia";

constexpr char kSystemChannel[] = "flutter/system";

constexpr char kTypeKey[] = "type";

constexpr char kFontChange[] = "fontsChange";

namespace {

std::unique_ptr<Engine> CreateEngine(

Engine::Delegate& delegate,

const PointerDataDispatcherMaker& dispatcher_maker,

DartVM& vm,

const fml::RefPtr<const DartSnapshot>& isolate_snapshot,

const TaskRunners& task_runners,

const PlatformData& platform_data,

const Settings& settings,

std::unique_ptr<Animator> animator,

const fml::WeakPtr<IOManager>& io_manager,

const fml::RefPtr<SkiaUnrefQueue>& unref_queue,

const fml::TaskRunnerAffineWeakPtr<SnapshotDelegate>& snapshot_delegate,

const std::shared_ptr<VolatilePathTracker>& volatile_path_tracker,

const std::shared_ptr<fml::SyncSwitch>& gpu_disabled_switch) {

return std::make_unique<Engine>(delegate, //

dispatcher_maker, //

vm, //

isolate_snapshot, //

task_runners, //

platform_data, //

settings, //

std::move(animator), //

io_manager, //

unref_queue, //

snapshot_delegate, //

volatile_path_tracker, //

gpu_disabled_switch);

}

void RegisterCodecsWithSkia() {

// These are in the order they will be attempted to be decoded from.

// If we have data to back it up, we can order these by "frequency used in

// the wild" for a very small performance bump, but for now we mirror the

// order Skia had them in.

SkCodecs::Register(SkPngDecoder::Decoder());

SkCodecs::Register(SkJpegDecoder::Decoder());

SkCodecs::Register(SkWebpDecoder::Decoder());

SkCodecs::Register(SkGifDecoder::Decoder());

SkCodecs::Register(SkBmpDecoder::Decoder());

SkCodecs::Register(SkWbmpDecoder::Decoder());

SkCodecs::Register(SkIcoDecoder::Decoder());

}

// Though there can be multiple shells, some settings apply to all components in

// the process. These have to be set up before the shell or any of its

// sub-components can be initialized. In a perfect world, this would be empty.

// TODO(chinmaygarde): The unfortunate side effect of this call is that settings

// that cause shell initialization failures will still lead to some of their

// settings being applied.

void PerformInitializationTasks(Settings& settings) {

{

fml::LogSettings log_settings;

log_settings.min_log_level =

settings.verbose_logging ? fml::kLogInfo : fml::kLogError;

fml::SetLogSettings(log_settings);

}

static std::once_flag gShellSettingsInitialization = {};

std::call_once(gShellSettingsInitialization, [&settings] {

tonic::SetLogHandler(

[](const char* message) { FML_LOG(ERROR) << message; });

if (settings.trace_skia) {

InitSkiaEventTracer(settings.trace_skia, settings.trace_skia_allowlist);

}

if (!settings.trace_allowlist.empty()) {

fml::tracing::TraceSetAllowlist(settings.trace_allowlist);

}

if (!settings.skia_deterministic_rendering_on_cpu) {

SkGraphics::Init();

} else {

FML_DLOG(INFO) << "Skia deterministic rendering is enabled.";

}

RegisterCodecsWithSkia();

if (settings.icu_initialization_required) {

if (!settings.icu_data_path.empty()) {

fml::icu::InitializeICU(settings.icu_data_path);

} else if (settings.icu_mapper) {

fml::icu::InitializeICUFromMapping(settings.icu_mapper());

} else {

FML_DLOG(WARNING) << "Skipping ICU initialization in the shell.";

}

}

});

PersistentCache::SetCacheSkSL(settings.cache_sksl);

}

} // namespace

std::pair<DartVMRef, fml::RefPtr<const DartSnapshot>>

Shell::InferVmInitDataFromSettings(Settings& settings) {

// Always use the `vm_snapshot` and `isolate_snapshot` provided by the

// settings to launch the VM. If the VM is already running, the snapshot

// arguments are ignored.

auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);

auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);

auto vm = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);

// If the settings did not specify an `isolate_snapshot`, fall back to the

// one the VM was launched with.

if (!isolate_snapshot) {

isolate_snapshot = vm->GetVMData()->GetIsolateSnapshot();

}

return {std::move(vm), isolate_snapshot};

}

std::unique_ptr<Shell> Shell::Create(

const PlatformData& platform_data,

const TaskRunners& task_runners,

Settings settings,

const Shell::CreateCallback<PlatformView>& on_create_platform_view,

const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,

bool is_gpu_disabled) {

// This must come first as it initializes tracing.

PerformInitializationTasks(settings);

TRACE_EVENT0("flutter", "Shell::Create");

auto [vm, isolate_snapshot] = InferVmInitDataFromSettings(settings);

auto resource_cache_limit_calculator =

std::make_shared<ResourceCacheLimitCalculator>(

settings.resource_cache_max_bytes_threshold);

return CreateWithSnapshot(platform_data, //

task_runners, //

/*parent_thread_merger=*/nullptr, //

/*parent_io_manager=*/nullptr, //

resource_cache_limit_calculator, //

settings, //

std::move(vm), //

std::move(isolate_snapshot), //

on_create_platform_view, //

on_create_rasterizer, //

CreateEngine, is_gpu_disabled);

}

std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(

DartVMRef vm,

fml::RefPtr<fml::RasterThreadMerger> parent_merger,

std::shared_ptr<ShellIOManager> parent_io_manager,

const std::shared_ptr<ResourceCacheLimitCalculator>&

resource_cache_limit_calculator,

const TaskRunners& task_runners,

const PlatformData& platform_data,

const Settings& settings,

fml::RefPtr<const DartSnapshot> isolate_snapshot,

const Shell::CreateCallback<PlatformView>& on_create_platform_view,

const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,

const Shell::EngineCreateCallback& on_create_engine,

bool is_gpu_disabled) {

if (!task_runners.IsValid()) {

FML_LOG(ERROR) << "Task runners to run the shell were invalid.";

return nullptr;

}

auto shell = std::unique_ptr<Shell>(

new Shell(std::move(vm), task_runners, std::move(parent_merger),

resource_cache_limit_calculator, settings,

std::make_shared<VolatilePathTracker>(

task_runners.GetUITaskRunner(),

!settings.skia_deterministic_rendering_on_cpu),

is_gpu_disabled));

// Create the platform view on the platform thread (this thread).

auto platform_view = on_create_platform_view(*shell.get());

if (!platform_view || !platform_view->GetWeakPtr()) {

return nullptr;

}

// Create the rasterizer on the raster thread.

std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;

auto rasterizer_future = rasterizer_promise.get_future();

std::promise<fml::TaskRunnerAffineWeakPtr<SnapshotDelegate>>

snapshot_delegate_promise;

auto snapshot_delegate_future = snapshot_delegate_promise.get_future();

fml::TaskRunner::RunNowOrPostTask(

task_runners.GetRasterTaskRunner(),

[&rasterizer_promise, //

&snapshot_delegate_promise,

on_create_rasterizer, //

shell = shell.get(), //

impeller_context = platform_view->GetImpellerContext() //

]() {

TRACE_EVENT0("flutter", "ShellSetupGPUSubsystem");

std::unique_ptr<Rasterizer> rasterizer(on_create_rasterizer(*shell));

rasterizer->SetImpellerContext(impeller_context);

snapshot_delegate_promise.set_value(rasterizer->GetSnapshotDelegate());

rasterizer_promise.set_value(std::move(rasterizer));

});

// Ask the platform view for the vsync waiter. This will be used by the engine

// to create the animator.

auto vsync_waiter = platform_view->CreateVSyncWaiter();

if (!vsync_waiter) {

return nullptr;

}

// Create the IO manager on the IO thread. The IO manager must be initialized

// first because it has state that the other subsystems depend on. It must

// first be booted and the necessary references obtained to initialize the

// other subsystems.

std::promise<std::shared_ptr<ShellIOManager>> io_manager_promise;

auto io_manager_future = io_manager_promise.get_future();

std::promise<fml::WeakPtr<ShellIOManager>> weak_io_manager_promise;

auto weak_io_manager_future = weak_io_manager_promise.get_future();

std::promise<fml::RefPtr<SkiaUnrefQueue>> unref_queue_promise;

auto unref_queue_future = unref_queue_promise.get_future();

auto io_task_runner = shell->GetTaskRunners().GetIOTaskRunner();

// The platform_view will be stored into shell's platform_view_ in

// shell->Setup(std::move(platform_view), ...) at the end.

PlatformView* platform_view_ptr = platform_view.get();

fml::TaskRunner::RunNowOrPostTask(

io_task_runner,

[&io_manager_promise, //

&weak_io_manager_promise, //

&parent_io_manager, //

&unref_queue_promise, //

platform_view_ptr, //

io_task_runner, //

is_backgrounded_sync_switch = shell->GetIsGpuDisabledSyncSwitch() //

]() {

TRACE_EVENT0("flutter", "ShellSetupIOSubsystem");

std::shared_ptr<ShellIOManager> io_manager;

if (parent_io_manager) {

io_manager = parent_io_manager;

} else {

io_manager = std::make_shared<ShellIOManager>(

platform_view_ptr->CreateResourceContext(), // resource context

is_backgrounded_sync_switch, // sync switch

io_task_runner, // unref queue task runner

platform_view_ptr->GetImpellerContext() // impeller context

);

}

weak_io_manager_promise.set_value(io_manager->GetWeakPtr());

unref_queue_promise.set_value(io_manager->GetSkiaUnrefQueue());

io_manager_promise.set_value(io_manager);

});

// Send dispatcher_maker to the engine constructor because shell won't have

// platform_view set until Shell::Setup is called later.

auto dispatcher_maker = platform_view->GetDispatcherMaker();

// Create the engine on the UI thread.

std::promise<std::unique_ptr<Engine>> engine_promise;

auto engine_future = engine_promise.get_future();

fml::TaskRunner::RunNowOrPostTask(

shell->GetTaskRunners().GetUITaskRunner(),

fml::MakeCopyable([&engine_promise, //

shell = shell.get(), //

&dispatcher_maker, //

&platform_data, //

isolate_snapshot = std::move(isolate_snapshot), //

vsync_waiter = std::move(vsync_waiter), //

&weak_io_manager_future, //

&snapshot_delegate_future, //

&unref_queue_future, //

&on_create_engine]() mutable {

TRACE_EVENT0("flutter", "ShellSetupUISubsystem");

const auto& task_runners = shell->GetTaskRunners();

// The animator is owned by the UI thread but it gets its vsync pulses

// from the platform.

auto animator = std::make_unique<Animator>(*shell, task_runners,

std::move(vsync_waiter));

engine_promise.set_value(

on_create_engine(*shell, //

dispatcher_maker, //

*shell->GetDartVM(), //

std::move(isolate_snapshot), //

task_runners, //

platform_data, //

shell->GetSettings(), //

std::move(animator), //

weak_io_manager_future.get(), //

unref_queue_future.get(), //

snapshot_delegate_future.get(), //

shell->volatile_path_tracker_,

shell->is_gpu_disabled_sync_switch_));

}));

if (!shell->Setup(std::move(platform_view), //

engine_future.get(), //

rasterizer_future.get(), //

io_manager_future.get()) //

) {

return nullptr;

}

return shell;

}

std::unique_ptr<Shell> Shell::CreateWithSnapshot(

const PlatformData& platform_data,

const TaskRunners& task_runners,

const fml::RefPtr<fml::RasterThreadMerger>& parent_thread_merger,

const std::shared_ptr<ShellIOManager>& parent_io_manager,

const std::shared_ptr<ResourceCacheLimitCalculator>&

resource_cache_limit_calculator,

Settings settings,

DartVMRef vm,

fml::RefPtr<const DartSnapshot> isolate_snapshot,

const Shell::CreateCallback<PlatformView>& on_create_platform_view,

const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,

const Shell::EngineCreateCallback& on_create_engine,

bool is_gpu_disabled) {

// This must come first as it initializes tracing.

PerformInitializationTasks(settings);

TRACE_EVENT0("flutter", "Shell::CreateWithSnapshot");

const bool callbacks_valid =

on_create_platform_view && on_create_rasterizer && on_create_engine;

if (!task_runners.IsValid() || !callbacks_valid) {

return nullptr;

}

fml::AutoResetWaitableEvent latch;

std::unique_ptr<Shell> shell;

auto platform_task_runner = task_runners.GetPlatformTaskRunner();

fml::TaskRunner::RunNowOrPostTask(

platform_task_runner,

fml::MakeCopyable([&latch, //

&shell, //

parent_thread_merger, //

parent_io_manager, //

resource_cache_limit_calculator, //

task_runners = task_runners, //

platform_data = platform_data, //

settings = settings, //

vm = std::move(vm), //

isolate_snapshot = std::move(isolate_snapshot), //

on_create_platform_view = on_create_platform_view, //

on_create_rasterizer = on_create_rasterizer, //

on_create_engine = on_create_engine,

is_gpu_disabled]() mutable {

shell = CreateShellOnPlatformThread(std::move(vm), //

parent_thread_merger, //

parent_io_manager, //

resource_cache_limit_calculator, //

task_runners, //

platform_data, //

settings, //

std::move(isolate_snapshot), //

on_create_platform_view, //

on_create_rasterizer, //

on_create_engine, is_gpu_disabled);

latch.Signal();

}));

latch.Wait();

return shell;

}

Shell::Shell(DartVMRef vm,

const TaskRunners& task_runners,

fml::RefPtr<fml::RasterThreadMerger> parent_merger,

const std::shared_ptr<ResourceCacheLimitCalculator>&

resource_cache_limit_calculator,

const Settings& settings,

std::shared_ptr<VolatilePathTracker> volatile_path_tracker,

bool is_gpu_disabled)

: task_runners_(task_runners),

parent_raster_thread_merger_(std::move(parent_merger)),

resource_cache_limit_calculator_(resource_cache_limit_calculator),

settings_(settings),

vm_(std::move(vm)),

is_gpu_disabled_sync_switch_(new fml::SyncSwitch(is_gpu_disabled)),

volatile_path_tracker_(std::move(volatile_path_tracker)),

weak_factory_gpu_(nullptr),

weak_factory_(this) {

FML_CHECK(!settings.enable_software_rendering || !settings.enable_impeller)

<< "Software rendering is incompatible with Impeller.";

FML_CHECK(vm_) << "Must have access to VM to create a shell.";

FML_DCHECK(task_runners_.IsValid());

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

display_manager_ = std::make_unique<DisplayManager>();

resource_cache_limit_calculator->AddResourceCacheLimitItem(

weak_factory_.GetWeakPtr());

// Generate a WeakPtrFactory for use with the raster thread. This does not

// need to wait on a latch because it can only ever be used from the raster

// thread from this class, so we have ordering guarantees.

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetRasterTaskRunner(), fml::MakeCopyable([this]() mutable {

this->weak_factory_gpu_ =

std::make_unique<fml::TaskRunnerAffineWeakPtrFactory<Shell>>(this);

}));

// Install service protocol handlers.

service_protocol_handlers_[ServiceProtocol::kScreenshotExtensionName] = {

task_runners_.GetRasterTaskRunner(),

std::bind(&Shell::OnServiceProtocolScreenshot, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_[ServiceProtocol::kScreenshotSkpExtensionName] = {

task_runners_.GetRasterTaskRunner(),

std::bind(&Shell::OnServiceProtocolScreenshotSKP, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_[ServiceProtocol::kRunInViewExtensionName] = {

task_runners_.GetUITaskRunner(),

std::bind(&Shell::OnServiceProtocolRunInView, this, std::placeholders::_1,

std::placeholders::_2)};

service_protocol_handlers_

[ServiceProtocol::kFlushUIThreadTasksExtensionName] = {

task_runners_.GetUITaskRunner(),

std::bind(&Shell::OnServiceProtocolFlushUIThreadTasks, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_

[ServiceProtocol::kSetAssetBundlePathExtensionName] = {

task_runners_.GetUITaskRunner(),

std::bind(&Shell::OnServiceProtocolSetAssetBundlePath, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_

[ServiceProtocol::kGetDisplayRefreshRateExtensionName] = {

task_runners_.GetUITaskRunner(),

std::bind(&Shell::OnServiceProtocolGetDisplayRefreshRate, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_[ServiceProtocol::kGetSkSLsExtensionName] = {

task_runners_.GetIOTaskRunner(),

std::bind(&Shell::OnServiceProtocolGetSkSLs, this, std::placeholders::_1,

std::placeholders::_2)};

service_protocol_handlers_

[ServiceProtocol::kEstimateRasterCacheMemoryExtensionName] = {

task_runners_.GetRasterTaskRunner(),

std::bind(&Shell::OnServiceProtocolEstimateRasterCacheMemory, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_

[ServiceProtocol::kRenderFrameWithRasterStatsExtensionName] = {

task_runners_.GetRasterTaskRunner(),

std::bind(&Shell::OnServiceProtocolRenderFrameWithRasterStats, this,

std::placeholders::_1, std::placeholders::_2)};

service_protocol_handlers_[ServiceProtocol::kReloadAssetFonts] = {

task_runners_.GetPlatformTaskRunner(),

std::bind(&Shell::OnServiceProtocolReloadAssetFonts, this,

std::placeholders::_1, std::placeholders::_2)};

}

Shell::~Shell() {

PersistentCache::GetCacheForProcess()->RemoveWorkerTaskRunner(

task_runners_.GetIOTaskRunner());

vm_->GetServiceProtocol()->RemoveHandler(this);

fml::AutoResetWaitableEvent ui_latch, gpu_latch, platform_latch, io_latch;

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetUITaskRunner(),

fml::MakeCopyable([this, &ui_latch]() mutable {

engine_.reset();

ui_latch.Signal();

}));

ui_latch.Wait();

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetRasterTaskRunner(),

fml::MakeCopyable(

[this, rasterizer = std::move(rasterizer_), &gpu_latch]() mutable {

rasterizer.reset();

this->weak_factory_gpu_.reset();

gpu_latch.Signal();

}));

gpu_latch.Wait();

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetIOTaskRunner(),

fml::MakeCopyable([io_manager = std::move(io_manager_),

platform_view = platform_view_.get(),

&io_latch]() mutable {

io_manager.reset();

if (platform_view) {

platform_view->ReleaseResourceContext();

}

io_latch.Signal();

}));

io_latch.Wait();

// The platform view must go last because it may be holding onto platform side

// counterparts to resources owned by subsystems running on other threads. For

// example, the NSOpenGLContext on the Mac.

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetPlatformTaskRunner(),

fml::MakeCopyable([platform_view = std::move(platform_view_),

&platform_latch]() mutable {

platform_view.reset();

platform_latch.Signal();

}));

platform_latch.Wait();

}

std::unique_ptr<Shell> Shell::Spawn(

RunConfiguration run_configuration,

const std::string& initial_route,

const CreateCallback<PlatformView>& on_create_platform_view,

const CreateCallback<Rasterizer>& on_create_rasterizer) const {

FML_DCHECK(task_runners_.IsValid());

// It's safe to store this value since it is set on the platform thread.

bool is_gpu_disabled = false;

GetIsGpuDisabledSyncSwitch()->Execute(

fml::SyncSwitch::Handlers()

.SetIfFalse([&is_gpu_disabled] { is_gpu_disabled = false; })

.SetIfTrue([&is_gpu_disabled] { is_gpu_disabled = true; }));

std::unique_ptr<Shell> result = CreateWithSnapshot(

PlatformData{}, task_runners_, rasterizer_->GetRasterThreadMerger(),

io_manager_, resource_cache_limit_calculator_, GetSettings(), vm_,

vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,

on_create_rasterizer,

[engine = this->engine_.get(), initial_route](

Engine::Delegate& delegate,

const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,

const fml::RefPtr<const DartSnapshot>& isolate_snapshot,

const TaskRunners& task_runners, const PlatformData& platform_data,

const Settings& settings, std::unique_ptr<Animator> animator,

const fml::WeakPtr<IOManager>& io_manager,

const fml::RefPtr<SkiaUnrefQueue>& unref_queue,

fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,

const std::shared_ptr<VolatilePathTracker>& volatile_path_tracker,

const std::shared_ptr<fml::SyncSwitch>& is_gpu_disabled_sync_switch) {

return engine->Spawn(

/*delegate=*/delegate,

/*dispatcher_maker=*/dispatcher_maker,

/*settings=*/settings,

/*animator=*/std::move(animator),

/*initial_route=*/initial_route,

/*io_manager=*/io_manager,

/*snapshot_delegate=*/std::move(snapshot_delegate),

/*gpu_disabled_switch=*/is_gpu_disabled_sync_switch);

},

is_gpu_disabled);

result->RunEngine(std::move(run_configuration));

return result;

}

void Shell::NotifyLowMemoryWarning() const {

auto trace_id = fml::tracing::TraceNonce();

TRACE_EVENT_ASYNC_BEGIN0("flutter", "Shell::NotifyLowMemoryWarning",

trace_id);

// This does not require a current isolate but does require a running VM.

// Since a valid shell will not be returned to the embedder without a valid

// DartVMRef, we can be certain that this is a safe spot to assume a VM is

// running.

::Dart_NotifyLowMemory();

task_runners_.GetRasterTaskRunner()->PostTask(

[rasterizer = rasterizer_->GetWeakPtr(), trace_id = trace_id]() {

if (rasterizer) {

rasterizer->NotifyLowMemoryWarning();

}

TRACE_EVENT_ASYNC_END0("flutter", "Shell::NotifyLowMemoryWarning",

trace_id);

});

// The IO Manager uses resource cache limits of 0, so it is not necessary

// to purge them.

}

void Shell::RunEngine(RunConfiguration run_configuration) {

RunEngine(std::move(run_configuration), nullptr);

}

void Shell::RunEngine(

RunConfiguration run_configuration,

const std::function<void(Engine::RunStatus)>& result_callback) {

auto result = [platform_runner = task_runners_.GetPlatformTaskRunner(),

result_callback](Engine::RunStatus run_result) {

if (!result_callback) {

return;

}

platform_runner->PostTask(

[result_callback, run_result]() { result_callback(run_result); });

};

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

fml::TaskRunner::RunNowOrPostTask(

task_runners_.GetUITaskRunner(),

fml::MakeCopyable(

[run_configuration = std::move(run_configuration),

weak_engine = weak_engine_, result]() mutable {

if (!weak_engine) {

FML_LOG(ERROR)

<< "Could not launch engine with configuration - no engine.";

result(Engine::RunStatus::Failure);

return;

}

auto run_result = weak_engine->Run(std::move(run_configuration));

if (run_result == flutter::Engine::RunStatus::Failure) {

FML_LOG(ERROR) << "Could not launch engine with configuration.";

}

result(run_result);

}));

}

std::optional<DartErrorCode> Shell::GetUIIsolateLastError() const {

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

if (!weak_engine_) {

return std::nullopt;

}

switch (weak_engine_->GetUIIsolateLastError()) {

case tonic::kCompilationErrorType:

return DartErrorCode::CompilationError;

case tonic::kApiErrorType:

return DartErrorCode::ApiError;

case tonic::kUnknownErrorType:

return DartErrorCode::UnknownError;

case tonic::kNoError:

return DartErrorCode::NoError;

}

return DartErrorCode::UnknownError;

}

bool Shell::EngineHasLivePorts() const {

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

if (!weak_engine_) {

return false;

}

return weak_engine_->UIIsolateHasLivePorts();

}

bool Shell::IsSetup() const {

return is_set_up_;

}

bool Shell::Setup(std::unique_ptr<PlatformView> platform_view,

std::unique_ptr<Engine> engine,

std::unique_ptr<Rasterizer> rasterizer,

const std::shared_ptr<ShellIOManager>& io_manager) {

if (is_set_up_) {

return false;

}

if (!platform_view || !engine || !rasterizer || !io_manager) {

return false;

}

platform_view_ = std::move(platform_view);

platform_message_handler_ = platform_view_->GetPlatformMessageHandler();

route_messages_through_platform_thread_.store(true);

task_runners_.GetPlatformTaskRunner()->PostTask(

[self = weak_factory_.GetWeakPtr()] {

if (self) {

self->route_messages_through_platform_thread_.store(false);

}

});

engine_ = std::move(engine);

rasterizer_ = std::move(rasterizer);

io_manager_ = io_manager;

// Set the external view embedder for the rasterizer.

auto view_embedder = platform_view_->CreateExternalViewEmbedder();

rasterizer_->SetExternalViewEmbedder(view_embedder);

rasterizer_->SetSnapshotSurfaceProducer(

platform_view_->CreateSnapshotSurfaceProducer());

// The weak ptr must be generated in the platform thread which owns the unique

// ptr.

weak_engine_ = engine_->GetWeakPtr();

weak_rasterizer_ = rasterizer_->GetWeakPtr();

weak_platform_view_ = platform_view_->GetWeakPtr();

engine_->AddView(kFlutterImplicitViewId, ViewportMetrics{});

// Setup the time-consuming default font manager right after engine created.

if (!settings_.prefetched_default_font_manager) {

fml::TaskRunner::RunNowOrPostTask(task_runners_.GetUITaskRunner(),

[engine = weak_engine_] {

if (engine) {

engine->SetupDefaultFontManager();

}

});

}

is_set_up_ = true;

PersistentCache::GetCacheForProcess()->AddWorkerTaskRunner(

task_runners_.GetIOTaskRunner());

PersistentCache::GetCacheForProcess()->SetIsDumpingSkp(

settings_.dump_skp_on_shader_compilation);

if (settings_.purge_persistent_cache) {

PersistentCache::GetCacheForProcess()->Purge();

}

return true;

}

const Settings& Shell::GetSettings() const {

return settings_;

}

const TaskRunners& Shell::GetTaskRunners() const {

return task_runners_;

}

const fml::RefPtr<fml::RasterThreadMerger> Shell::GetParentRasterThreadMerger()

const {

return parent_raster_thread_merger_;

}

fml::TaskRunnerAffineWeakPtr<Rasterizer> Shell::GetRasterizer() const {

FML_DCHECK(is_set_up_);

return weak_rasterizer_;

}

fml::WeakPtr<Engine> Shell::GetEngine() {

FML_DCHECK(is_set_up_);

return weak_engine_;

}

fml::WeakPtr<PlatformView> Shell::GetPlatformView() {

FML_DCHECK(is_set_up_);

return weak_platform_view_;

}

fml::WeakPtr<ShellIOManager> Shell::GetIOManager() {

FML_DCHECK(is_set_up_);

return io_manager_->GetWeakPtr();

}

DartVM* Shell::GetDartVM() {

return &vm_;

}

// |PlatformView::Delegate|

void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {

TRACE_EVENT0("flutter", "Shell::OnPlatformViewCreated");

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

// Prevent any request to change the thread configuration for raster and

// platform queues while the platform view is being created.

//

// This prevents false positives such as this method starts assuming that the

// raster and platform queues have a given thread configuration, but then the

// configuration is changed by a task, and the assumption is no longer true.

//

// This incorrect assumption can lead to deadlock.

// See `should_post_raster_task` for more.

rasterizer_->DisableThreadMergerIfNeeded();

// The normal flow executed by this method is that the platform thread is

// starting the sequence and waiting on the latch. Later the UI thread posts

// raster_task to the raster thread which signals the latch. If the raster and

// the platform threads are the same this results in a deadlock as the

// raster_task will never be posted to the platform/raster thread that is

// blocked on a latch. To avoid the described deadlock, if the raster and the

// platform threads are the same, should_post_raster_task will be false, and

// then instead of posting a task to the raster thread, the ui thread just

// signals the latch and the platform/raster thread follows with executing

// raster_task.

const bool should_post_raster_task =

!task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread();

auto raster_task = fml::MakeCopyable(

[&waiting_for_first_frame = waiting_for_first_frame_, //

rasterizer = rasterizer_->GetWeakPtr(), //

surface = std::move(surface) //

]() mutable {

if (rasterizer) {

// Enables the thread merger which may be used by the external view

// embedder.

rasterizer->EnableThreadMergerIfNeeded();

rasterizer->Setup(std::move(surface));

}

waiting_for_first_frame.store(true);

});

auto ui_task = [engine = engine_->GetWeakPtr()] {

if (engine) {

engine->ScheduleFrame();

}

};

// Threading: Capture platform view by raw pointer and not the weak pointer.

// We are going to use the pointer on the IO thread which is not safe with a

// weak pointer. However, we are preventing the platform view from being

// collected by using a latch.

auto* platform_view = platform_view_.get();

FML_DCHECK(platform_view);

fml::AutoResetWaitableEvent latch;

auto io_task = [io_manager = io_manager_->GetWeakPtr(), platform_view,

ui_task_runner = task_runners_.GetUITaskRunner(), ui_task,

raster_task_runner = task_runners_.GetRasterTaskRunner(),

raster_task, should_post_raster_task, &latch] {

if (io_manager && !io_manager->GetResourceContext()) {

sk_sp<GrDirectContext> resource_context =

platform_view->CreateResourceContext();

io_manager->NotifyResourceContextAvailable(resource_context);

}

// Step 1: Post a task on the UI thread to tell the engine that it has

// an output surface.

fml::TaskRunner::RunNowOrPostTask(ui_task_runner, ui_task);

// Step 2: Tell the raster thread that it should create a surface for

// its rasterizer.

if (should_post_raster_task) {

fml::TaskRunner::RunNowOrPostTask(raster_task_runner, raster_task);

}

latch.Signal();

};

fml::TaskRunner::RunNowOrPostTask(task_runners_.GetIOTaskRunner(), io_task);

latch.Wait();

if (!should_post_raster_task) {

// See comment on should_post_raster_task, in this case the raster_task

// wasn't executed, and we just run it here as the platform thread

// is the raster thread.

raster_task();

}

}

// |PlatformView::Delegate|

void Shell::OnPlatformViewDestroyed() {

TRACE_EVENT0("flutter", "Shell::OnPlatformViewDestroyed");

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

// Prevent any request to change the thread configuration for raster and

// platform queues while the platform view is being destroyed.

//

// This prevents false positives such as this method starts assuming that the

// raster and platform queues have a given thread configuration, but then the

// configuration is changed by a task, and the assumption is no longer true.

//

// This incorrect assumption can lead to deadlock.

rasterizer_->DisableThreadMergerIfNeeded();

// Notify the Dart VM that the PlatformView has been destroyed and some

// cleanup activity can be done (e.g: garbage collect the Dart heap).

task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {

if (engine) {

engine->NotifyDestroyed();

}

});

// Note:

// This is a synchronous operation because certain platforms depend on

// setup/suspension of all activities that may be interacting with the GPU in

// a synchronous fashion.

// The UI thread does not need to be serialized here - there is sufficient

// guardrailing in the rasterizer to allow the UI thread to post work to it

// even after the surface has been torn down.

fml::AutoResetWaitableEvent latch;

auto io_task = [io_manager = io_manager_.get(), &latch]() {

// Execute any pending Skia object deletions while GPU access is still

// allowed.

io_manager->GetIsGpuDisabledSyncSwitch()->Execute(

fml::SyncSwitch::Handlers().SetIfFalse(

[&] { io_manager->GetSkiaUnrefQueue()->Drain(); }));

// Step 4: All done. Signal the latch that the platform thread is waiting

// on.

latch.Signal();

};

auto raster_task = [rasterizer = rasterizer_->GetWeakPtr(),

io_task_runner = task_runners_.GetIOTaskRunner(),

io_task]() {

if (rasterizer) {

// Enables the thread merger which is required prior tearing down the

// rasterizer. If the raster and platform threads are merged, tearing down

// the rasterizer unmerges the threads.

rasterizer->EnableThreadMergerIfNeeded();

rasterizer->Teardown();

}

// Step 2: Tell the IO thread to complete its remaining work.

fml::TaskRunner::RunNowOrPostTask(io_task_runner, io_task);

};

// Step 1: Post a task to the Raster thread (possibly this thread) to tell the

// rasterizer the output surface is going away.

fml::TaskRunner::RunNowOrPostTask(task_runners_.GetRasterTaskRunner(),

raster_task);

latch.Wait();

// On Android, the external view embedder may post a task to the platform

// thread, and wait until it completes if overlay surfaces must be released.

// However, the platform thread might be blocked when Dart is initializing.

// In this situation, calling TeardownExternalViewEmbedder is safe because no

// platform views have been created before Flutter renders the first frame.

// Overall, the longer term plan is to remove this implementation once

// https://github.com/flutter/flutter/issues/96679 is fixed.

rasterizer_->TeardownExternalViewEmbedder();

}

// |PlatformView::Delegate|

void Shell::OnPlatformViewScheduleFrame() {

TRACE_EVENT0("flutter", "Shell::OnPlatformViewScheduleFrame");

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {

if (engine) {

engine->ScheduleFrame();

}

});

}

// |PlatformView::Delegate|

void Shell::OnPlatformViewSetViewportMetrics(int64_t view_id,

const ViewportMetrics& metrics) {

FML_DCHECK(is_set_up_);

FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

if (metrics.device_pixel_ratio <= 0 || metrics.physical_width <= 0 ||

metrics.physical_height <= 0) {

// Ignore invalid view-port metrics.

return;

}

// This is the formula Android uses.

// https://android.googlesource.com/platform/frameworks/base/+/39ae5bac216757bc201490f4c7b8c0f63006c6cd/libs/hwui/renderthread/CacheManager.cpp#45

resource_cache_limit_ =

metrics.physical_width * metrics.physical_height * 12 * 4;

size_t resource_cache_max_bytes =

resource_cache_limit_calculator_->GetResourceCacheMaxBytes();

task_runners_.GetRasterTaskRunner()->PostTask(

[rasterizer = rasterizer_->GetWeakPtr(), resource_cache_max_bytes] {

if (rasterizer) {

rasterizer->SetResourceCacheMaxBytes(resource_cache_max_bytes, false);

}

});

task_runners_.GetUITaskRunner()->PostTask(

[engine = engine_->GetWeakPtr(), view_id, metrics]() {

if (engine) {

engine->SetViewportMetrics(view_id, metrics);

}

});

{

std::scoped_lock<std::mutex> lock(resize_mutex_);

expected_frame_sizes_[view_id] =