[embedder] Arg to specify the display refresh rate

This is then wired to the vsync waiter to provide the
advisory display refresh rate.

Author: Kaushik Iska

shell/common/shell.cc

@@ -1430,7 +1430,7 @@ bool Shell::OnServiceProtocolGetDisplayRefreshRate(
   FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
   response->SetObject();
   response->AddMember("type", "DisplayRefreshRate", response->GetAllocator());
-  response->AddMember("fps", engine_->GetDisplayRefreshRate(),
+  response->AddMember("fps", display_refresh_rate_.load(),
                       response->GetAllocator());
   return true;
 }

shell/common/vsync_waiter_fallback.cc

@@ -21,8 +21,15 @@ static fml::TimePoint SnapToNextTick(fml::TimePoint value,
 
 }  // namespace
 
+VsyncWaiterFallback::VsyncWaiterFallback(TaskRunners task_runners,
+                                         float display_refresh_rate)
+    : VsyncWaiter(std::move(task_runners)),
+      phase_(fml::TimePoint::Now()),
+      display_refresh_rate_(display_refresh_rate) {}
+
 VsyncWaiterFallback::VsyncWaiterFallback(TaskRunners task_runners)
-    : VsyncWaiter(std::move(task_runners)), phase_(fml::TimePoint::Now()) {}
+    : VsyncWaiterFallback(std::move(task_runners),
+                          VsyncWaiter::kUnknownRefreshRateFPS) {}
 
 VsyncWaiterFallback::~VsyncWaiterFallback() = default;
 
@@ -37,4 +44,8 @@ void VsyncWaiterFallback::AwaitVSync() {
   FireCallback(next, next + kSingleFrameInterval);
 }
 
+float VsyncWaiterFallback::GetDisplayRefreshRate() const {
+  return display_refresh_rate_;
+}
+
 }  // namespace flutter

shell/common/vsync_waiter_fallback.h

@@ -17,10 +17,15 @@ class VsyncWaiterFallback final : public VsyncWaiter {
  public:
   VsyncWaiterFallback(TaskRunners task_runners);
 
+  VsyncWaiterFallback(TaskRunners task_runners, float display_refresh_rate);
+
   ~VsyncWaiterFallback() override;
 
+  float GetDisplayRefreshRate() const override;
+
  private:
-  fml::TimePoint phase_;
+  const fml::TimePoint phase_;
+  const float display_refresh_rate_;
 
   // |VsyncWaiter|
   void AwaitVSync() override;

shell/platform/embedder/embedder.cc

@@ -46,6 +46,7 @@ extern const intptr_t kPlatformStrongDillSize;
 #include "flutter/shell/common/persistent_cache.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/switches.h"
+#include "flutter/shell/common/vsync_waiter.h"
 #include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/embedder/embedder_engine.h"
 #include "flutter/shell/platform/embedder/embedder_platform_message_response.h"
@@ -992,13 +993,17 @@ FlutterEngineResult FlutterEngineInitialize(size_t version,
                               "Compositor arguments were invalid.");
   }
 
+  float display_refresh_rate = SAFE_ACCESS(
+      args, display_refresh_rate, flutter::VsyncWaiter::kUnknownRefreshRateFPS);
+
   flutter::PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table =
       {
           update_semantics_nodes_callback,            //
           update_semantics_custom_actions_callback,   //
           platform_message_response_callback,         //
           vsync_callback,                             //
           compute_platform_resolved_locale_callback,  //
+          display_refresh_rate,                       //
       };
 
   auto on_create_platform_view = InferPlatformViewCreationCallback(

shell/platform/embedder/embedder.h

@@ -1318,6 +1318,12 @@ typedef struct {
   /// matches what the platform would natively resolve to as possible.
   FlutterComputePlatformResolvedLocaleCallback
       compute_platform_resolved_locale_callback;
+
+  /// The refresh rate of the display in frames per second.
+  ///
+  /// This information is purely advisory and is not used by any component. It
+  /// is only used by the tooling to visualize frame performance.
+  float display_refresh_rate;
 } FlutterProjectArgs;
 
 //------------------------------------------------------------------------------

shell/platform/embedder/platform_view_embedder.cc

@@ -85,12 +85,13 @@ sk_sp<GrDirectContext> PlatformViewEmbedder::CreateResourceContext() const {
 // |PlatformView|
 std::unique_ptr<VsyncWaiter> PlatformViewEmbedder::CreateVSyncWaiter() {
   if (!platform_dispatch_table_.vsync_callback) {
-    // Superclass implementation creates a timer based fallback.
-    return PlatformView::CreateVSyncWaiter();
+    return std::make_unique<VsyncWaiterFallback>(
+        task_runners_, platform_dispatch_table_.display_refresh_rate);
   }
 
   return std::make_unique<VsyncWaiterEmbedder>(
-      platform_dispatch_table_.vsync_callback, task_runners_);
+      platform_dispatch_table_.vsync_callback, task_runners_,
+      platform_dispatch_table_.display_refresh_rate);
 }
 
 // |PlatformView|

shell/platform/embedder/platform_view_embedder.h

@@ -9,6 +9,7 @@
 
 #include "flutter/fml/macros.h"
 #include "flutter/shell/common/platform_view.h"
+#include "flutter/shell/common/vsync_waiter_fallback.h"
 #include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/embedder/embedder_surface.h"
 #include "flutter/shell/platform/embedder/embedder_surface_gl.h"
@@ -38,6 +39,7 @@ class PlatformViewEmbedder final : public PlatformView {
     VsyncWaiterEmbedder::VsyncCallback vsync_callback;  // optional
     ComputePlatformResolvedLocaleCallback
         compute_platform_resolved_locale_callback;
+    float display_refresh_rate;
   };
 
   // Creates a platform view that sets up an OpenGL rasterizer.

shell/platform/embedder/tests/embedder_config_builder.cc

@@ -232,6 +232,10 @@ void EmbedderConfigBuilder::SetPlatformMessageCallback(
   context_.SetPlatformMessageCallback(callback);
 }
 
+void EmbedderConfigBuilder::SetDisplayRefreshRate(float display_refresh_rate) {
+  project_args_.display_refresh_rate = display_refresh_rate;
+}
+
 void EmbedderConfigBuilder::SetCompositor() {
   context_.SetupCompositor();
   auto& compositor = context_.GetCompositor();

shell/platform/embedder/tests/embedder_config_builder.h

@@ -86,6 +86,10 @@ class EmbedderConfigBuilder {
 
   void SetCompositor();
 
+  /// Sets the `FlutterProjectArgs`'s display refresh rate. This is in frames
+  /// per second.
+  void SetDisplayRefreshRate(float display_refresh_rate);
+
   FlutterCompositor& GetCompositor();
 
   UniqueEngine LaunchEngine() const;

shell/platform/embedder/tests/embedder_unittests.cc

@@ -4459,5 +4459,48 @@ TEST_F(EmbedderTest, PresentInfoContainsValidFBOId) {
   frame_latch.Wait();
 }
 
+TEST_F(EmbedderTest, DisplayRefreshRateIsSet) {
+  auto& context = GetEmbedderContext();
+  fml::AutoResetWaitableEvent latch;
+  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
+  EmbedderConfigBuilder builder(context);
+  builder.SetSoftwareRendererConfig();
+  constexpr float refresh_rate = 60.0f;
+  builder.SetDisplayRefreshRate(refresh_rate);
+  auto engine = builder.LaunchEngine();
+  ASSERT_TRUE(engine.is_valid());
+  // Wait for the root isolate to launch.
+  latch.Wait();
+
+  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
+  auto vsync_waiter = shell.GetPlatformView()->CreateVSyncWaiter();
+
+  const float embedder_refresh_rate = vsync_waiter->GetDisplayRefreshRate();
+  ASSERT_FLOAT_EQ(refresh_rate, embedder_refresh_rate);
+
+  engine.reset();
+}
+
+TEST_F(EmbedderTest, DefaultDisplayRefreshRateIsUnknown) {
+  auto& context = GetEmbedderContext();
+  fml::AutoResetWaitableEvent latch;
+  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
+  EmbedderConfigBuilder builder(context);
+  builder.SetSoftwareRendererConfig();
+  auto engine = builder.LaunchEngine();
+  ASSERT_TRUE(engine.is_valid());
+  // Wait for the root isolate to launch.
+  latch.Wait();
+
+  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
+  auto vsync_waiter = shell.GetPlatformView()->CreateVSyncWaiter();
+
+  const float embedder_refresh_rate = vsync_waiter->GetDisplayRefreshRate();
+  ASSERT_FLOAT_EQ(flutter::VsyncWaiter::kUnknownRefreshRateFPS,
+                  embedder_refresh_rate);
+
+  engine.reset();
+}
+
 }  // namespace testing
 }  // namespace flutter