Synchronize main thread and gpu thread for first render frame

shell/common/shell.cc

@@ -457,18 +457,21 @@ void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
   // 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.
-
   fml::AutoResetWaitableEvent latch;
-  auto gpu_task = fml::MakeCopyable([rasterizer = rasterizer_->GetWeakPtr(),  //
-                                     surface = std::move(surface),            //
-                                     &latch]() mutable {
-    if (rasterizer) {
-      rasterizer->Setup(std::move(surface));
-    }
-    // Step 3: All done. Signal the latch that the platform thread is waiting
-    // on.
-    latch.Signal();
-  });
+  auto gpu_task =
+      fml::MakeCopyable([this, rasterizer = rasterizer_->GetWeakPtr(),  //
+                         surface = std::move(surface),                  //
+                         &latch]() mutable {
+        if (rasterizer) {
+          rasterizer->Setup(std::move(surface));
+        }
+
+        waiting_for_first_frame_.store(true);
+
+        // Step 3: All done. Signal the latch that the platform thread is
+        // waiting on.
+        latch.Signal();
+      });
 
   // 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
@@ -800,10 +803,15 @@ void Shell::OnAnimatorDraw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
   FML_DCHECK(is_setup_);
 
   task_runners_.GetGPUTaskRunner()->PostTask(
-      [rasterizer = rasterizer_->GetWeakPtr(),
+      [this, rasterizer = rasterizer_->GetWeakPtr(),
        pipeline = std::move(pipeline)]() {
         if (rasterizer) {
           rasterizer->Draw(pipeline);
+
+          if (waiting_for_first_frame_.load()) {
+            waiting_for_first_frame_.store(false);
+            waiting_for_first_frame_condition_.notify_all();
+          }
         }
       });
 }
@@ -1240,4 +1248,15 @@ Rasterizer::Screenshot Shell::Screenshot(
   return screenshot;
 }
 
+bool Shell::WaitForFirstFrame(fml::TimeDelta timeout) {
+  FML_DCHECK(is_setup_);
+  FML_DCHECK(!task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(!task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
+  std::unique_lock<std::mutex> lock(waiting_for_first_frame_mutex_);
+  bool success = waiting_for_first_frame_condition_.wait_for(
+      lock, std::chrono::milliseconds(timeout.ToMilliseconds()),
+      [this] { return !waiting_for_first_frame_.load(); });
+  return !success;
+}
+
 }  // namespace flutter

shell/common/shell.h

@@ -243,6 +243,12 @@ class Shell final : public PlatformView::Delegate,
   Rasterizer::Screenshot Screenshot(Rasterizer::ScreenshotType type,
                                     bool base64_encode);
 
+  /// Pauses the calling thread until the first frame is presented.
+  ///\details Don't call this from the GPU thread or the UI thread or you will
+  ///         create a deadlock.
+  ///\returns true when there has been a timeout.
+  bool WaitForFirstFrame(fml::TimeDelta timeout);
+
  private:
   using ServiceProtocolHandler =
       std::function<bool(const ServiceProtocol::Handler::ServiceProtocolMap&,
@@ -271,6 +277,9 @@ class Shell final : public PlatformView::Delegate,
   uint64_t next_pointer_flow_id_ = 0;
 
   bool first_frame_rasterized_ = false;
+  std::atomic<bool> waiting_for_first_frame_ = true;
+  std::mutex waiting_for_first_frame_mutex_;
+  std::condition_variable waiting_for_first_frame_condition_;
 
   // Written in the UI thread and read from the GPU thread. Hence make it
   // atomic.

shell/platform/darwin/ios/framework/Source/FlutterViewController.mm

@@ -406,8 +406,9 @@ - (void)viewWillAppear:(BOOL)animated {
 
   // Only recreate surface on subsequent appearances when viewport metrics are known.
   // First time surface creation is done on viewDidLayoutSubviews.
-  if (_viewportMetrics.physical_width)
+  if (_viewportMetrics.physical_width) {
     [self surfaceUpdated:YES];
+  }
   [[_engine.get() lifecycleChannel] sendMessage:@"AppLifecycleState.inactive"];
 
   [super viewWillAppear:animated];
@@ -698,8 +699,22 @@ - (void)viewDidLayoutSubviews {
 
   // This must run after updateViewportMetrics so that the surface creation tasks are queued after
   // the viewport metrics update tasks.
-  if (firstViewBoundsUpdate)
+  if (firstViewBoundsUpdate) {
     [self surfaceUpdated:YES];
+
+    flutter::Shell& shell = [_engine.get() shell];
+    fml::TimeDelta waitTime =
+#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
+        fml::TimeDelta::FromMilliseconds(200);
+#else
+        fml::TimeDelta::FromMilliseconds(100);
+#endif
+    if (shell.WaitForFirstFrame(waitTime)) {
+      FML_LOG(INFO) << "Timeout waiting for the first frame to render.  This may happen in "
+                    << "unoptimized builds.  If this is a release build, you should load a less "
+                    << "complex frame to avoid the timeout.";
+    }
+  }
 }
 
 - (void)viewSafeAreaInsetsDidChange {