Skip to content

Commit 01cb246

Browse files
committed
Add a deferred platform-view-created path to the shell and use it on Android
On Android, surfaceCreated and surfaceChanged block the main thread until the raster thread has created the swapchain and set up the rasterizer. This happens inside the first view traversal, so the activity's first draw and Dart's first frame both wait behind it (about 100 ms on a Galaxy A16 and a Moto G05). shell/common: - Adds PlatformView::NotifyCreatedDeferred and PlatformView::Delegate::OnPlatformViewCreatedDeferred. The platform passes a surface factory; Shell runs it on the raster thread and requests a frame without waiting. - The default delegate implementation is synchronous, and no other platform calls the new path. - Rasterizer::Setup can now run while the platform thread disables or reads the thread merger, so that access is locked, a merger created while disabled starts disabled, and a spawned shell resolves its parent's merger lazily. Android: - PlatformViewAndroid::NotifyCreated and NotifyChanged post to the raster thread and return. A generation counter skips tasks from a surface that has since been destroyed or replaced. - NotifyDestroyed stays synchronous, and a failed surface creation is handled as before. Fixes flutter#196180
1 parent e6b33e6 commit 01cb246

8 files changed

Lines changed: 225 additions & 50 deletions

File tree

‎engine/src/flutter/shell/common/platform_view.cc‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,20 @@ void PlatformView::NotifyCreated() {
8484
delegate_.OnPlatformViewCreated(std::move(surface));
8585
}
8686

87+
void PlatformView::Delegate::OnPlatformViewCreatedDeferred(
88+
// NOLINTNEXTLINE(performance-unnecessary-value-param)
89+
SurfaceFactory surface_factory) {
90+
std::unique_ptr<Surface> surface =
91+
surface_factory ? surface_factory() : nullptr;
92+
if (surface && surface->IsValid()) {
93+
OnPlatformViewCreated(std::move(surface));
94+
}
95+
}
96+
97+
void PlatformView::NotifyCreatedDeferred(SurfaceFactory surface_factory) {
98+
delegate_.OnPlatformViewCreatedDeferred(std::move(surface_factory));
99+
}
100+
87101
void PlatformView::NotifyDestroyed() {
88102
delegate_.OnPlatformViewDestroyed();
89103
}

‎engine/src/flutter/shell/common/platform_view.h‎

Lines changed: 30 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ class PlatformView {
5353
public:
5454
using AddViewCallback = std::function<void(bool added)>;
5555
using RemoveViewCallback = std::function<void(bool removed)>;
56+
using SurfaceFactory = std::function<std::unique_ptr<Surface>()>;
5657
//----------------------------------------------------------------------------
5758
/// @brief Used to forward events from the platform view to interested
5859
/// subsystems. This forwarding is done by the shell which sets
@@ -62,6 +63,7 @@ class PlatformView {
6263
public:
6364
using AddViewCallback = PlatformView::AddViewCallback;
6465
using RemoveViewCallback = PlatformView::RemoveViewCallback;
66+
using SurfaceFactory = PlatformView::SurfaceFactory;
6567
using KeyDataResponse = std::function<void(bool)>;
6668
//--------------------------------------------------------------------------
6769
/// @brief Notifies the delegate that the platform view was created
@@ -74,6 +76,25 @@ class PlatformView {
7476
///
7577
virtual void OnPlatformViewCreated(std::unique_ptr<Surface> surface) = 0;
7678

79+
//--------------------------------------------------------------------------
80+
/// @brief Notifies the delegate that the platform view was created,
81+
/// allowing deferring delegates (`Shell`) to invoke
82+
/// `surface_factory` asynchronously on the raster task runner
83+
/// so the platform thread does not block waiting on GPU context
84+
/// or swapchain initialization.
85+
///
86+
/// The default implementation is a synchronous fallback on the
87+
/// calling thread (`OnPlatformViewCreated(surface_factory())`)
88+
/// for delegates/test mocks that do not support deferral.
89+
///
90+
/// @param[in] surface_factory Callable that constructs and returns the
91+
/// rendering surface (on the raster task
92+
/// runner when deferred by `Shell`), or
93+
/// nullptr / an invalid surface if
94+
/// cancelled/failed.
95+
///
96+
virtual void OnPlatformViewCreatedDeferred(SurfaceFactory surface_factory);
97+
7798
//--------------------------------------------------------------------------
7899
/// @brief Notifies the delegate that the platform view was destroyed.
79100
/// This is usually a sign to the rasterizer to suspend
@@ -1035,7 +1056,15 @@ class PlatformView {
10351056
virtual void SetupImpellerContext() {}
10361057

10371058
protected:
1038-
// This is the only method called on the raster task runner.
1059+
//----------------------------------------------------------------------------
1060+
/// @brief Notifies the shell that a platform view has been created,
1061+
/// running `surface_factory` asynchronously on the raster task
1062+
/// runner when supported by the delegate.
1063+
///
1064+
void NotifyCreatedDeferred(SurfaceFactory surface_factory);
1065+
1066+
// Called on the raster task runner (as is `surface_factory` when deferred via
1067+
// `Shell::OnPlatformViewCreatedDeferred`).
10391068
virtual std::unique_ptr<Surface> CreateRenderingSurface();
10401069

10411070
PlatformView::Delegate& delegate_;

‎engine/src/flutter/shell/common/rasterizer.cc‎

Lines changed: 16 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -98,8 +98,17 @@ void Rasterizer::Setup(std::unique_ptr<Surface> surface) {
9898
delegate_.GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId();
9999
const auto gpu_id =
100100
delegate_.GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId();
101-
raster_thread_merger_ = fml::RasterThreadMerger::CreateOrShareThreadMerger(
102-
delegate_.GetParentRasterThreadMerger(), platform_id, gpu_id);
101+
fml::RefPtr<fml::RasterThreadMerger> parent_merger =
102+
delegate_.GetParentRasterThreadMerger();
103+
{
104+
std::scoped_lock lock(raster_thread_merger_mutex_);
105+
raster_thread_merger_ =
106+
fml::RasterThreadMerger::CreateOrShareThreadMerger(
107+
parent_merger, platform_id, gpu_id);
108+
if (thread_merger_disabled_) {
109+
raster_thread_merger_->Disable();
110+
}
111+
}
103112
}
104113
if (raster_thread_merger_) {
105114
raster_thread_merger_->SetMergeUnmergeCallback([this]() {
@@ -159,12 +168,16 @@ std::optional<DrawSurfaceStatus> Rasterizer::GetLastDrawStatus(
159168
}
160169

161170
void Rasterizer::EnableThreadMergerIfNeeded() {
171+
std::scoped_lock lock(raster_thread_merger_mutex_);
172+
thread_merger_disabled_ = false;
162173
if (raster_thread_merger_) {
163174
raster_thread_merger_->Enable();
164175
}
165176
}
166177

167178
void Rasterizer::DisableThreadMergerIfNeeded() {
179+
std::scoped_lock lock(raster_thread_merger_mutex_);
180+
thread_merger_disabled_ = true;
168181
if (raster_thread_merger_) {
169182
raster_thread_merger_->Disable();
170183
}
@@ -1166,6 +1179,7 @@ void Rasterizer::SetSnapshotSurfaceProducer(
11661179
}
11671180

11681181
fml::RefPtr<fml::RasterThreadMerger> Rasterizer::GetRasterThreadMerger() {
1182+
std::scoped_lock lock(raster_thread_merger_mutex_);
11691183
return raster_thread_merger_;
11701184
}
11711185

‎engine/src/flutter/shell/common/rasterizer.h‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77

88
#include <future>
99
#include <memory>
10+
#include <mutex>
1011
#include <optional>
1112
#include <unordered_map>
1213

@@ -584,7 +585,8 @@ class Rasterizer final : public SnapshotDelegate,
584585

585586
//----------------------------------------------------------------------------
586587
/// @brief Disables the thread merger if the external view embedder
587-
/// supports dynamic thread merging.
588+
/// supports dynamic thread merging, or ensures a merger created
589+
/// later by `Rasterizer::Setup` starts disabled.
588590
///
589591
/// @attention This method is thread-safe. When the thread merger is
590592
/// disabled, the raster task queue will continue to run in the
@@ -812,7 +814,12 @@ class Rasterizer final : public SnapshotDelegate,
812814
fml::closure next_frame_callback_;
813815
bool user_override_resource_cache_bytes_ = false;
814816
std::optional<size_t> max_cache_bytes_;
817+
// Guards cross-thread access to `raster_thread_merger_` and
818+
// `thread_merger_disabled_` (raster-thread reads of `raster_thread_merger_`
819+
// are unlocked since `Setup` on the raster thread is the sole writer).
820+
std::mutex raster_thread_merger_mutex_;
815821
fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger_;
822+
bool thread_merger_disabled_ = false;
816823
std::shared_ptr<ExternalViewEmbedder> external_view_embedder_;
817824
std::unique_ptr<SnapshotController> snapshot_controller_;
818825

‎engine/src/flutter/shell/common/shell.cc‎

Lines changed: 99 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -235,22 +235,24 @@ std::unique_ptr<Shell> Shell::Create(
235235
std::make_shared<ResourceCacheLimitCalculator>(
236236
settings.resource_cache_max_bytes_threshold);
237237

238-
return CreateWithSnapshot(platform_data, //
239-
task_runners, //
240-
/*parent_thread_merger=*/nullptr, //
241-
/*parent_io_manager=*/nullptr, //
242-
resource_cache_limit_calculator, //
243-
settings, //
244-
std::move(vm), //
245-
std::move(isolate_snapshot), //
246-
on_create_platform_view, //
247-
on_create_rasterizer, //
238+
return CreateWithSnapshot(platform_data, //
239+
task_runners, //
240+
/*parent_thread_merger=*/nullptr, //
241+
/*parent_rasterizer=*/std::nullopt, //
242+
/*parent_io_manager=*/nullptr, //
243+
resource_cache_limit_calculator, //
244+
settings, //
245+
std::move(vm), //
246+
std::move(isolate_snapshot), //
247+
on_create_platform_view, //
248+
on_create_rasterizer, //
248249
CreateEngine, is_gpu_disabled);
249250
}
250251

251252
std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
252253
DartVMRef vm,
253254
fml::RefPtr<fml::RasterThreadMerger> parent_merger,
255+
std::optional<fml::TaskRunnerAffineWeakPtr<Rasterizer>> parent_rasterizer,
254256
std::shared_ptr<ShellIOManager> parent_io_manager,
255257
const std::shared_ptr<ResourceCacheLimitCalculator>&
256258
resource_cache_limit_calculator,
@@ -269,7 +271,8 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
269271

270272
auto shell = std::unique_ptr<Shell>(
271273
new Shell(std::move(vm), task_runners, std::move(parent_merger),
272-
resource_cache_limit_calculator, settings, is_gpu_disabled));
274+
std::move(parent_rasterizer), resource_cache_limit_calculator,
275+
settings, is_gpu_disabled));
273276

274277
// Create the platform view on the platform thread (this thread).
275278
auto platform_view = on_create_platform_view(*shell.get());
@@ -442,6 +445,7 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
442445
const PlatformData& platform_data,
443446
const TaskRunners& task_runners,
444447
const fml::RefPtr<fml::RasterThreadMerger>& parent_thread_merger,
448+
std::optional<fml::TaskRunnerAffineWeakPtr<Rasterizer>> parent_rasterizer,
445449
const std::shared_ptr<ShellIOManager>& parent_io_manager,
446450
const std::shared_ptr<ResourceCacheLimitCalculator>&
447451
resource_cache_limit_calculator,
@@ -471,6 +475,7 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
471475
fml::MakeCopyable([&latch, //
472476
&shell, //
473477
parent_thread_merger, //
478+
parent_rasterizer = std::move(parent_rasterizer), //
474479
parent_io_manager, //
475480
resource_cache_limit_calculator, //
476481
task_runners = task_runners, //
@@ -484,6 +489,7 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
484489
is_gpu_disabled]() mutable {
485490
shell = CreateShellOnPlatformThread(std::move(vm), //
486491
parent_thread_merger, //
492+
std::move(parent_rasterizer), //
487493
parent_io_manager, //
488494
resource_cache_limit_calculator, //
489495
task_runners, //
@@ -500,15 +506,18 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
500506
return shell;
501507
}
502508

503-
Shell::Shell(DartVMRef vm,
504-
const TaskRunners& task_runners,
505-
fml::RefPtr<fml::RasterThreadMerger> parent_merger,
506-
const std::shared_ptr<ResourceCacheLimitCalculator>&
507-
resource_cache_limit_calculator,
508-
const Settings& settings,
509-
bool is_gpu_disabled)
509+
Shell::Shell(
510+
DartVMRef vm,
511+
const TaskRunners& task_runners,
512+
fml::RefPtr<fml::RasterThreadMerger> parent_merger,
513+
std::optional<fml::TaskRunnerAffineWeakPtr<Rasterizer>> parent_rasterizer,
514+
const std::shared_ptr<ResourceCacheLimitCalculator>&
515+
resource_cache_limit_calculator,
516+
const Settings& settings,
517+
bool is_gpu_disabled)
510518
: task_runners_(task_runners),
511519
parent_raster_thread_merger_(std::move(parent_merger)),
520+
parent_rasterizer_(std::move(parent_rasterizer)),
512521
resource_cache_limit_calculator_(resource_cache_limit_calculator),
513522
settings_(settings),
514523
vm_(std::move(vm)),
@@ -709,9 +718,9 @@ std::unique_ptr<Shell> Shell::Spawn(
709718
.SetIfTrue([&is_gpu_disabled] { is_gpu_disabled = true; }));
710719
std::unique_ptr<Shell> result = CreateWithSnapshot(
711720
PlatformData{}, task_runners_, rasterizer_->GetRasterThreadMerger(),
712-
io_manager_, resource_cache_limit_calculator_, GetSettings(), vm_,
713-
vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,
714-
on_create_rasterizer,
721+
weak_rasterizer_, io_manager_, resource_cache_limit_calculator_,
722+
GetSettings(), vm_, vm_->GetVMData()->GetIsolateSnapshot(),
723+
on_create_platform_view, on_create_rasterizer,
715724
[engine = this->engine_.get(), initial_route](
716725
Engine::Delegate& delegate, DartVM& vm,
717726
const fml::RefPtr<const DartSnapshot>& isolate_snapshot,
@@ -938,7 +947,21 @@ const TaskRunners& Shell::GetTaskRunners() const {
938947

939948
const fml::RefPtr<fml::RasterThreadMerger> Shell::GetParentRasterThreadMerger()
940949
const {
941-
return parent_raster_thread_merger_;
950+
if (parent_raster_thread_merger_) {
951+
return parent_raster_thread_merger_;
952+
}
953+
// If the parent's `Rasterizer::Setup()` was still deferred on the raster
954+
// thread when `Shell::Spawn()` ran, resolve the immediate parent's merger
955+
// lazily on the raster thread. (Note: for >=3-deep spawn chains where an
956+
// intermediate child also has no merger yet at grandchild setup time, only
957+
// the immediate parent's rasterizer is consulted, matching prior behavior
958+
// when an intermediate shell never attached a view.)
959+
if (parent_rasterizer_.has_value() &&
960+
task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread() &&
961+
*parent_rasterizer_) {
962+
return (*parent_rasterizer_)->GetRasterThreadMerger();
963+
}
964+
return nullptr;
942965
}
943966

944967
fml::TaskRunnerAffineWeakPtr<Rasterizer> Shell::GetRasterizer() const {
@@ -1061,6 +1084,60 @@ void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
10611084
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
10621085
}
10631086

1087+
// |PlatformView::Delegate|
1088+
void Shell::OnPlatformViewCreatedDeferred(
1089+
PlatformView::SurfaceFactory surface_factory) {
1090+
TRACE_EVENT0("flutter", "Shell::OnPlatformViewCreatedDeferred");
1091+
FML_DCHECK(is_set_up_);
1092+
FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
1093+
1094+
// `platform_view` and `waiting_for_first_frame_` outlive both the raster task
1095+
// and the IO task it posts because `Shell::~Shell()` drains UI -> Raster ->
1096+
// IO synchronously via latches before resetting `platform_view_`. Posting the
1097+
// IO resource-context setup from inside the raster task orders it after
1098+
// `SetupImpellerContext()`.
1099+
auto* platform_view = platform_view_.get();
1100+
FML_DCHECK(platform_view);
1101+
fml::TaskRunner::RunNowOrPostTask(
1102+
task_runners_.GetRasterTaskRunner(),
1103+
fml::MakeCopyable([&waiting_for_first_frame = waiting_for_first_frame_,
1104+
rasterizer = rasterizer_->GetWeakPtr(),
1105+
io_task_runner = task_runners_.GetIOTaskRunner(),
1106+
io_manager = io_manager_->GetWeakPtr(), platform_view,
1107+
surface_factory =
1108+
std::move(surface_factory)]() mutable {
1109+
TRACE_EVENT0("flutter", "Shell::OnPlatformViewCreatedDeferred::Raster");
1110+
if (!rasterizer) {
1111+
return;
1112+
}
1113+
std::unique_ptr<Surface> surface = surface_factory();
1114+
if (!surface || !surface->IsValid()) {
1115+
return;
1116+
}
1117+
fml::TaskRunner::RunNowOrPostTask(
1118+
io_task_runner, [io_manager, platform_view]() {
1119+
if (io_manager && !io_manager->GetResourceContext()) {
1120+
sk_sp<GrDirectContext> resource_context =
1121+
platform_view->CreateResourceContext();
1122+
io_manager->NotifyResourceContextAvailable(resource_context);
1123+
}
1124+
});
1125+
// `DisableThreadMergerIfNeeded()` is not called on the deferred path;
1126+
// if `OnPlatformViewDestroyed()` set `thread_merger_disabled_` while
1127+
// `surface_factory()` was in flight, `Rasterizer::Setup()` creates the
1128+
// merger already disabled.
1129+
rasterizer->Setup(std::move(surface));
1130+
waiting_for_first_frame.store(true);
1131+
}));
1132+
1133+
// Schedule the UI frame right after posting the raster setup task so UI frame
1134+
// construction overlaps surface creation while any resulting draw queues
1135+
// behind `Rasterizer::Setup()` on the raster FIFO (if `surface_factory()`
1136+
// returns null/invalid, at most one frame is dropped as `kNotSetUp`, matching
1137+
// `PlatformViewAndroid::NotifySurfaceWindowChanged`).
1138+
OnPlatformViewScheduleFrame();
1139+
}
1140+
10641141
// |PlatformView::Delegate|
10651142
void Shell::OnPlatformViewDestroyed() {
10661143
TRACE_EVENT0("flutter", "Shell::OnPlatformViewDestroyed");

0 commit comments

Comments
 (0)