Skip to content

Commit 5ab00e8

Browse files
committed
[Android] Make PlatformViewAndroid::NotifyCreated and NotifyChanged asynchronous
Defer PlatformViewAndroid::NotifyCreated and NotifyChanged onto the raster task runner with monotonic surface_generation_ ordering so stale surface setup or resize tasks after NotifyDestroyed or rapid recreate cycles are skipped without blocking the Android main thread. Preserve existing attempt-and-validate surface creation semantics on the raster thread by invoking SetNativeWindow followed unconditionally by CreateRenderingSurface and surface->IsValid(). Dispatch IO resource-context setup from inside OnPlatformViewCreatedDeferred's raster task after surface creation succeeds so it remains ordered after asynchronous SetupImpellerContext, and schedule the initial UI frame immediately after posting that deferred raster task so UI frame construction overlaps surface creation while any resulting draw queues behind Rasterizer::Setup. Guard cross-thread RasterThreadMerger access under raster_thread_merger_mutex_ now that deferred Rasterizer::Setup runs concurrently with platform-thread DisableThreadMergerIfNeeded and GetRasterThreadMerger calls, and carry a pending thread_merger_disabled_ state over to a merger created by deferred Setup. Preserve Shell::Spawn thread-merger sharing via parent_rasterizer_ when the immediate parent's setup is still deferred. Fixes flutter#196180
1 parent e6b33e6 commit 5ab00e8

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 also 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+
// `NotifySurfaceWindowChanged`).
1138+
OnPlatformViewScheduleFrame();
1139+
}
1140+
10641141
// |PlatformView::Delegate|
10651142
void Shell::OnPlatformViewDestroyed() {
10661143
TRACE_EVENT0("flutter", "Shell::OnPlatformViewDestroyed");

0 commit comments

Comments
 (0)