Skip to content

Commit 2ffb63d

Browse files
committed
[Android] Avoid blocking platform thread in NotifyCreated and NotifyChanged
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. If SetNativeWindow fails on the raster thread, skip CreateRenderingSurface and Rasterizer::Setup rather than constructing an unrenderable GPU surface, and guard AndroidSurfaceVKImpeller::OnScreenSurfaceResize when no valid native window is attached. Dispatch IO resource-context setup from inside OnPlatformViewCreatedDeferred's raster task after surface creation succeeds so it remains ordered after asynchronous SetupImpellerContext, and post the deferred setup task before scheduling the initial UI frame so UI draws queue behind Rasterizer::Setup. Create RasterThreadMerger lazily on the raster thread in Rasterizer::Setup and guard cross-thread access and disable-scope depth under raster_thread_merger_mutex_ so SupportsDynamicThreadMerging never blocks the platform thread and an in-flight OnPlatformViewDestroyed publishes any newly created merger already disabled. 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 2ffb63d

9 files changed

Lines changed: 260 additions & 65 deletions

File tree

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

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,19 @@ 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+
if (std::unique_ptr<Surface> surface =
91+
surface_factory ? surface_factory() : nullptr) {
92+
OnPlatformViewCreated(std::move(surface));
93+
}
94+
}
95+
96+
void PlatformView::NotifyCreatedDeferred(SurfaceFactory surface_factory) {
97+
delegate_.OnPlatformViewCreatedDeferred(std::move(surface_factory));
98+
}
99+
87100
void PlatformView::NotifyDestroyed() {
88101
delegate_.OnPlatformViewDestroyed();
89102
}

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

Lines changed: 29 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,24 @@ 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 if cancelled/failed.
94+
///
95+
virtual void OnPlatformViewCreatedDeferred(SurfaceFactory surface_factory);
96+
7797
//--------------------------------------------------------------------------
7898
/// @brief Notifies the delegate that the platform view was destroyed.
7999
/// This is usually a sign to the rasterizer to suspend
@@ -1035,7 +1055,15 @@ class PlatformView {
10351055
virtual void SetupImpellerContext() {}
10361056

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

10411069
PlatformView::Delegate& delegate_;

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

Lines changed: 22 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -91,15 +91,23 @@ void Rasterizer::Setup(std::unique_ptr<Surface> surface) {
9191
compositor_context_->OnGrContextCreated();
9292
}
9393

94-
if (external_view_embedder_ &&
95-
external_view_embedder_->SupportsDynamicThreadMerging() &&
96-
!raster_thread_merger_) {
94+
if (!raster_thread_merger_ && external_view_embedder_ &&
95+
external_view_embedder_->SupportsDynamicThreadMerging()) {
9796
const auto platform_id =
9897
delegate_.GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId();
9998
const auto gpu_id =
10099
delegate_.GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId();
101-
raster_thread_merger_ = fml::RasterThreadMerger::CreateOrShareThreadMerger(
102-
delegate_.GetParentRasterThreadMerger(), platform_id, gpu_id);
100+
fml::RefPtr<fml::RasterThreadMerger> parent_merger =
101+
delegate_.GetParentRasterThreadMerger();
102+
{
103+
std::scoped_lock lock(raster_thread_merger_mutex_);
104+
raster_thread_merger_ =
105+
fml::RasterThreadMerger::CreateOrShareThreadMerger(
106+
parent_merger, platform_id, gpu_id);
107+
if (thread_merger_disabled_count_ > 0) {
108+
raster_thread_merger_->Disable();
109+
}
110+
}
103111
}
104112
if (raster_thread_merger_) {
105113
raster_thread_merger_->SetMergeUnmergeCallback([this]() {
@@ -159,12 +167,19 @@ std::optional<DrawSurfaceStatus> Rasterizer::GetLastDrawStatus(
159167
}
160168

161169
void Rasterizer::EnableThreadMergerIfNeeded() {
162-
if (raster_thread_merger_) {
170+
std::scoped_lock lock(raster_thread_merger_mutex_);
171+
FML_DCHECK(thread_merger_disabled_count_ > 0);
172+
if (thread_merger_disabled_count_ > 0) {
173+
--thread_merger_disabled_count_;
174+
}
175+
if (thread_merger_disabled_count_ == 0 && raster_thread_merger_) {
163176
raster_thread_merger_->Enable();
164177
}
165178
}
166179

167180
void Rasterizer::DisableThreadMergerIfNeeded() {
181+
std::scoped_lock lock(raster_thread_merger_mutex_);
182+
++thread_merger_disabled_count_;
168183
if (raster_thread_merger_) {
169184
raster_thread_merger_->Disable();
170185
}
@@ -1166,6 +1181,7 @@ void Rasterizer::SetSnapshotSurfaceProducer(
11661181
}
11671182

11681183
fml::RefPtr<fml::RasterThreadMerger> Rasterizer::GetRasterThreadMerger() {
1184+
std::scoped_lock lock(raster_thread_merger_mutex_);
11691185
return raster_thread_merger_;
11701186
}
11711187

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

Lines changed: 29 additions & 12 deletions
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

@@ -571,26 +572,32 @@ class Rasterizer final : public SnapshotDelegate,
571572
std::optional<size_t> GetResourceCacheMaxBytes() const;
572573

573574
//----------------------------------------------------------------------------
574-
/// @brief Enables the thread merger if the external view embedder
575-
/// supports dynamic thread merging.
575+
/// @brief Decrements the thread-merger disable depth count, re-enabling
576+
/// the raster thread merger once the count reaches zero (if a
577+
/// merger has been created).
576578
///
577-
/// @attention This method is thread-safe. When the thread merger is enabled,
578-
/// the raster task queue can run in the platform thread at any
579-
/// time.
579+
/// @attention This method is thread-safe. Every call to
580+
/// `DisableThreadMergerIfNeeded` must be paired with exactly one
581+
/// call to `EnableThreadMergerIfNeeded` on the raster thread.
582+
/// When the thread merger is enabled, the raster task queue can
583+
/// run on the platform thread at any time.
580584
///
581-
/// @see `ExternalViewEmbedder`
585+
/// @see `DisableThreadMergerIfNeeded`, `ExternalViewEmbedder`
582586
///
583587
void EnableThreadMergerIfNeeded();
584588

585589
//----------------------------------------------------------------------------
586-
/// @brief Disables the thread merger if the external view embedder
587-
/// supports dynamic thread merging.
590+
/// @brief Increments the thread-merger disable depth count and disables
591+
/// the raster thread merger immediately if it already exists, or
592+
/// ensures a merger created later by `Rasterizer::Setup` starts
593+
/// disabled.
588594
///
589-
/// @attention This method is thread-safe. When the thread merger is
590-
/// disabled, the raster task queue will continue to run in the
591-
/// same thread until |EnableThreadMergerIfNeeded| is called.
595+
/// @attention This method is thread-safe. Every call must be paired with
596+
/// exactly one call to `EnableThreadMergerIfNeeded` on the raster
597+
/// thread; the merger remains disabled until all overlapping
598+
/// disable scopes have balanced.
592599
///
593-
/// @see `ExternalViewEmbedder`
600+
/// @see `EnableThreadMergerIfNeeded`, `ExternalViewEmbedder`
594601
///
595602
void DisableThreadMergerIfNeeded();
596603

@@ -812,7 +819,17 @@ class Rasterizer final : public SnapshotDelegate,
812819
fml::closure next_frame_callback_;
813820
bool user_override_resource_cache_bytes_ = false;
814821
std::optional<size_t> max_cache_bytes_;
822+
// Guards `raster_thread_merger_` and `thread_merger_disabled_count_` across
823+
// the platform and raster threads (reads of `raster_thread_merger_` on the
824+
// raster thread skip the lock by design since `Setup` on the raster thread is
825+
// the sole writer). Lock order: `raster_thread_merger_mutex_` ->
826+
// `RasterThreadMerger::mutex_`; never invoke external callbacks under this
827+
// lock. A depth count keeps the merger disabled across overlapping
828+
// synchronous `Created`/`Destroyed` scopes until all paired raster `Enable`
829+
// calls run.
830+
mutable std::mutex raster_thread_merger_mutex_;
815831
fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger_;
832+
size_t thread_merger_disabled_count_ = 0;
816833
std::shared_ptr<ExternalViewEmbedder> external_view_embedder_;
817834
std::unique_ptr<SnapshotController> snapshot_controller_;
818835

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

Lines changed: 98 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,59 @@ 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) {
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()` incremented the disable count 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 first UI frame after posting the deferred setup task above so
1134+
// any UI-produced raster draw queues behind `Rasterizer::Setup()` on the
1135+
// raster FIFO queue while Dart frame construction overlaps with surface
1136+
// creation.
1137+
OnPlatformViewScheduleFrame();
1138+
}
1139+
10641140
// |PlatformView::Delegate|
10651141
void Shell::OnPlatformViewDestroyed() {
10661142
TRACE_EVENT0("flutter", "Shell::OnPlatformViewDestroyed");

0 commit comments

Comments
 (0)