Synchronize main thread and gpu thread for first render frame

fml/task_runner.cc

@@ -11,6 +11,7 @@
 #include "flutter/fml/logging.h"
 #include "flutter/fml/message_loop.h"
 #include "flutter/fml/message_loop_impl.h"
+#include "flutter/fml/synchronization/count_down_latch.h"
 
 namespace fml {
 
@@ -23,6 +24,15 @@ void TaskRunner::PostTask(fml::closure task) {
   loop_->PostTask(std::move(task), fml::TimePoint::Now());
 }
 
+void TaskRunner::AwaitTask(fml::closure task) {
+  CountDownLatch latch(1);
+  PostTask([&] {
+    task();
+    latch.CountDown();
+  });
+  latch.Wait();
+}
+
 void TaskRunner::PostTaskForTime(fml::closure task,
                                  fml::TimePoint target_time) {
   loop_->PostTask(std::move(task), target_time);

fml/task_runner.h

@@ -21,6 +21,8 @@ class TaskRunner : public fml::RefCountedThreadSafe<TaskRunner> {
 
   virtual void PostTask(fml::closure task);
 
+  virtual void AwaitTask(fml::closure task);
+
   virtual void PostTaskForTime(fml::closure task, fml::TimePoint target_time);
 
   virtual void PostDelayedTask(fml::closure task, fml::TimeDelta delay);

shell/common/animator.cc

@@ -239,4 +239,11 @@ void Animator::AwaitVSync() {
   delegate_.OnAnimatorNotifyIdle(dart_frame_deadline_);
 }
 
+void Animator::ForceVSync() {
+  regenerate_layer_tree_ = true;
+  frame_scheduled_ = true;
+  AwaitVSync();
+  waiter_->ForceVSync();
+}
+
 }  // namespace flutter

shell/common/animator.h

@@ -62,6 +62,8 @@ class Animator final {
   // will be ended during the next |BeginFrame|.
   void EnqueueTraceFlowId(uint64_t trace_flow_id);
 
+  void ForceVSync();
+
  private:
   using LayerTreePipeline = Pipeline<flutter::LayerTree>;
 

shell/common/engine.h

@@ -127,6 +127,8 @@ class Engine final : public RuntimeDelegate {
   // |RuntimeDelegate|
   FontCollection& GetFontCollection() override;
 
+  Animator* GetAnimator() { return animator_.get(); }
+
  private:
   Engine::Delegate& delegate_;
   const Settings settings_;

shell/common/shell.cc

@@ -922,6 +922,14 @@ void Shell::OnFrameRasterized(const FrameTiming& timing) {
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetGPUTaskRunner()->RunsTasksOnCurrentThread());
 
+  if (waiting_for_frame_.load()) {
+    {
+      std::lock_guard<std::mutex> lock(waiting_for_frame_mutex_);
+      waiting_for_frame_.store(false);
+    }
+    waiting_for_frame_condition_.notify_all();
+  }
+
   // The C++ callback defined in settings.h and set by Flutter runner. This is
   // independent of the timings report to the Dart side.
   if (settings_.frame_rasterized_callback) {
@@ -1229,4 +1237,15 @@ Rasterizer::Screenshot Shell::Screenshot(
   return screenshot;
 }
 
+bool Shell::WaitForFrameRender(fml::TimeDelta timeout) {
+  std::unique_lock<std::mutex> lock(waiting_for_frame_mutex_);
+  task_runners_.GetUITaskRunner()->AwaitTask(
+      [this] { engine_->GetAnimator()->ForceVSync(); });
+  waiting_for_frame_.store(true);
+  bool success = waiting_for_frame_condition_.wait_for(
+      lock, std::chrono::milliseconds(timeout.ToMilliseconds()),
+      [this] { return !waiting_for_frame_.load(); });
+  return !success;
+}
+
 }  // namespace flutter

shell/common/shell.h

@@ -90,6 +90,10 @@ class Shell final : public PlatformView::Delegate,
   Rasterizer::Screenshot Screenshot(Rasterizer::ScreenshotType type,
                                     bool base64_encode);
 
+  /// Schedules a frame to be rendered and waits for it to finish.
+  ///\returns true when there has been a timeout.
+  bool WaitForFrameRender(fml::TimeDelta timeout);
+
  private:
   using ServiceProtocolHandler =
       std::function<bool(const ServiceProtocol::Handler::ServiceProtocolMap&,
@@ -118,6 +122,9 @@ class Shell final : public PlatformView::Delegate,
   uint64_t next_pointer_flow_id_ = 0;
 
   bool first_frame_rasterized_ = false;
+  std::atomic<bool> waiting_for_frame_ = false;
+  std::mutex waiting_for_frame_mutex_;
+  std::condition_variable waiting_for_frame_condition_;
 
   // Written in the UI thread and read from the GPU thread. Hence make it
   // atomic.

shell/common/vsync_waiter.h

@@ -32,6 +32,8 @@ class VsyncWaiter : public std::enable_shared_from_this<VsyncWaiter> {
   // Return kUnknownRefreshRateFPS if the refresh rate is unknown.
   virtual float GetDisplayRefreshRate() const;
 
+  virtual void ForceVSync() {}
+
  protected:
   // On some backends, the |FireCallback| needs to be made from a static C
   // method.

shell/common/vsync_waiter_fallback.cc

@@ -36,4 +36,8 @@ void VsyncWaiterFallback::AwaitVSync() {
   FireCallback(next, next + kSingleFrameInterval);
 }
 
+void VsyncWaiterFallback::ForceVSync() {
+  AwaitVSync();
+}
+
 }  // namespace flutter

shell/common/vsync_waiter_fallback.h

@@ -19,6 +19,8 @@ class VsyncWaiterFallback final : public VsyncWaiter {
 
   ~VsyncWaiterFallback() override;
 
+  void ForceVSync() override;
+
  private:
   fml::TimePoint phase_;
 

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

@@ -399,8 +399,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];
@@ -689,8 +690,21 @@ - (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 NDEBUG
+        fml::TimeDelta::FromMilliseconds(100);
+#else
+        fml::TimeDelta::FromMilliseconds(200);
+#endif
+    if (shell.WaitForFrameRender(waitTime)) {
+      FML_LOG(INFO) << "Timeout waiting for first frame.  This is possible in debug builds but "
+                    << "should be reported as an error on release builds.";
+    }
+  }
 }
 
 - (void)viewSafeAreaInsetsDidChange {

shell/platform/darwin/ios/framework/Source/vsync_waiter_ios.h

@@ -20,6 +20,8 @@ class VsyncWaiterIOS final : public VsyncWaiter {
 
   ~VsyncWaiterIOS() override;
 
+  void ForceVSync() override;
+
  private:
   fml::scoped_nsobject<VSyncClient> client_;
 

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

@@ -23,6 +23,8 @@ - (void)await;
 
 - (void)invalidate;
 
+- (void)forceVSync;
+
 @end
 
 namespace flutter {
@@ -45,6 +47,10 @@ - (void)invalidate;
   [client_.get() await];
 }
 
+void VsyncWaiterIOS::ForceVSync() {
+  [client_.get() forceVSync];
+}
+
 }  // namespace flutter
 
 @implementation VSyncClient {
@@ -97,4 +103,8 @@ - (void)dealloc {
   [super dealloc];
 }
 
+- (void)forceVSync {
+  [self onDisplayLink:display_link_];
+}
+
 @end