viz/android: Plumbing to support preferred refresh rate setting.

Plumb the supported refresh rates from the browser to GPU process and
the preferred refresh rate setting from the GPU to browser process.

R=ericrk@chromium.org

Bug: 938106
Change-Id: I00f2564dfa523bebe0c76fa855ae844b72ba68da
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1556415
Commit-Queue: Khushal <khushalsagar@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Auto-Submit: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#652403}

android_webview/browser/gfx/surfaces_instance.cc

@@ -308,4 +308,9 @@ void SurfacesInstance::ReclaimResources(
 
 void SurfacesInstance::OnBeginFramePausedChanged(bool paused) {}
 
+base::TimeDelta SurfacesInstance::GetPreferredFrameIntervalForFrameSinkId(
+    const viz::FrameSinkId& id) {
+  return frame_sink_manager_->GetPreferredFrameIntervalForFrameSinkId(id);
+}
+
 }  // namespace android_webview

android_webview/browser/gfx/surfaces_instance.h

@@ -73,6 +73,9 @@ class SurfacesInstance : public base::RefCounted<SurfacesInstance>,
   void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) override {}
   void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override {}
+  void SetPreferredFrameInterval(base::TimeDelta interval) override {}
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const viz::FrameSinkId& id) override;
 
   // viz::mojom::CompositorFrameSinkClient implementation.
   void DidReceiveCompositorFrameAck(

components/viz/service/display/display.cc

@@ -890,15 +890,12 @@ void Display::RunDrawCallbacks() {
 }
 
 void Display::SetPreferredFrameInterval(base::TimeDelta interval) {
-  // TODO(khushalsagar): Plumb this to the |client_| and hook it up to the
-  // platform API for toggling the preferred setting.
+  client_->SetPreferredFrameInterval(interval);
 }
 
 base::TimeDelta Display::GetPreferredFrameIntervalForFrameSinkId(
     const FrameSinkId& id) {
-  // TODO(khushalsagar): Hook up with the preferred setting received from the
-  // media code.
-  return base::TimeDelta::Max();
+  return client_->GetPreferredFrameIntervalForFrameSinkId(id);
 }
 
 void Display::SetSupportedFrameIntervals(

components/viz/service/display/display_client.h

@@ -12,6 +12,7 @@ struct CALayerParams;
 }  // namespace gfx
 
 namespace viz {
+class FrameSinkId;
 
 class DisplayClient {
  public:
@@ -25,6 +26,9 @@ class DisplayClient {
   virtual void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) = 0;
   virtual void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) = 0;
+  virtual void SetPreferredFrameInterval(base::TimeDelta interval) = 0;
+  virtual base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) = 0;
 };
 
 }  // namespace viz

components/viz/service/display/display_unittest.cc

@@ -104,6 +104,11 @@ class StubDisplayClient : public DisplayClient {
   void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) override {}
   void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override {}
+  void SetPreferredFrameInterval(base::TimeDelta interval) override {}
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) override {
+    return BeginFrameArgs::MinInterval();
+  }
 };
 
 void CopyCallback(bool* called, std::unique_ptr<CopyOutputResult> result) {

components/viz/service/display/frame_rate_decider.cc

@@ -33,7 +33,6 @@ FrameRateDecider::~FrameRateDecider() {
 
 void FrameRateDecider::SetSupportedFrameIntervals(
     std::vector<base::TimeDelta> supported_intervals) {
-  DCHECK_GT(supported_intervals.size(), 0u);
   DCHECK(!inside_surface_aggregation_);
 
   supported_intervals_ = std::move(supported_intervals);

components/viz/service/frame_sinks/direct_layer_tree_frame_sink.cc

@@ -234,6 +234,19 @@ void DirectLayerTreeFrameSink::DisplayDidCompleteSwapWithSize(
   // Not needed in non-OOP-D mode.
 }
 
+void DirectLayerTreeFrameSink::SetPreferredFrameInterval(
+    base::TimeDelta interval) {
+  // Not supported in non-OOP-D mode.
+  NOTREACHED() << "Can not specify preferred interval, "
+                  "no supported intervals were provided";
+}
+
+base::TimeDelta
+DirectLayerTreeFrameSink::GetPreferredFrameIntervalForFrameSinkId(
+    const FrameSinkId& id) {
+  return frame_sink_manager_->GetPreferredFrameIntervalForFrameSinkId(id);
+}
+
 void DirectLayerTreeFrameSink::DidReceiveCompositorFrameAck(
     const std::vector<ReturnedResource>& resources) {
   // Submitting a CompositorFrame can synchronously draw and dispatch a frame

components/viz/service/frame_sinks/direct_layer_tree_frame_sink.h

@@ -85,6 +85,9 @@ class VIZ_SERVICE_EXPORT DirectLayerTreeFrameSink
   void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) override;
   void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override;
+  void SetPreferredFrameInterval(base::TimeDelta interval) override;
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) override;
 
  private:
   // mojom::CompositorFrameSinkClient implementation:

components/viz/service/frame_sinks/frame_sink_manager_impl.cc

@@ -583,4 +583,13 @@ const CompositorFrameSinkSupport* FrameSinkManagerImpl::GetFrameSinkForId(
   return nullptr;
 }
 
+base::TimeDelta FrameSinkManagerImpl::GetPreferredFrameIntervalForFrameSinkId(
+    const FrameSinkId& id) const {
+  auto it = frame_sink_data_.find(id);
+  if (it == frame_sink_data_.end())
+    return BeginFrameArgs::MinInterval();
+
+  return it->second.preferred_frame_interval;
+}
+
 }  // namespace viz

components/viz/service/frame_sinks/frame_sink_manager_impl.h

@@ -197,6 +197,9 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl
   const CompositorFrameSinkSupport* GetFrameSinkForId(
       const FrameSinkId& frame_sink_id) const;
 
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) const;
+
  private:
   friend class FrameSinkManagerTest;
 
@@ -217,6 +220,8 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl
     // notification.
     bool report_activation;
 
+    base::TimeDelta preferred_frame_interval = BeginFrameArgs::MinInterval();
+
    private:
     DISALLOW_COPY_AND_ASSIGN(FrameSinkData);
   };

components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc

@@ -168,6 +168,19 @@ void RootCompositorFrameSinkImpl::UpdateRefreshRate(float refresh_rate) {
   if (external_begin_frame_source_)
     external_begin_frame_source_->UpdateRefreshRate(refresh_rate);
 }
+
+void RootCompositorFrameSinkImpl::SetSupportedRefreshRates(
+    const std::vector<float>& supported_refresh_rates) {
+  std::vector<base::TimeDelta> supported_frame_intervals(
+      supported_refresh_rates.size());
+  for (size_t i = 0; i < supported_refresh_rates.size(); ++i) {
+    supported_frame_intervals[i] =
+        base::TimeDelta::FromSecondsD(1 / supported_refresh_rates[i]);
+  }
+
+  display_->SetSupportedFrameIntervals(supported_frame_intervals);
+}
+
 #endif  // defined(OS_ANDROID)
 
 void RootCompositorFrameSinkImpl::SetNeedsBeginFrame(bool needs_begin_frame) {
@@ -305,6 +318,24 @@ void RootCompositorFrameSinkImpl::DisplayDidCompleteSwapWithSize(
 #endif
 }
 
+void RootCompositorFrameSinkImpl::SetPreferredFrameInterval(
+    base::TimeDelta interval) {
+#if defined(OS_ANDROID)
+  float refresh_rate = 1 / interval.InSecondsF();
+  if (display_client_)
+    display_client_->SetPreferredRefreshRate(refresh_rate);
+#else
+  NOTREACHED();
+#endif
+}
+
+base::TimeDelta
+RootCompositorFrameSinkImpl::GetPreferredFrameIntervalForFrameSinkId(
+    const FrameSinkId& id) {
+  return support_->frame_sink_manager()
+      ->GetPreferredFrameIntervalForFrameSinkId(id);
+}
+
 void RootCompositorFrameSinkImpl::DisplayDidDrawAndSwap() {}
 
 BeginFrameSource* RootCompositorFrameSinkImpl::begin_frame_source() {

components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h

@@ -53,6 +53,8 @@ class RootCompositorFrameSinkImpl : public mojom::CompositorFrameSink,
 #if defined(OS_ANDROID)
   void SetVSyncPaused(bool paused) override;
   void UpdateRefreshRate(float refresh_rate) override;
+  void SetSupportedRefreshRates(
+      const std::vector<float>& supported_refresh_rates) override;
 #endif
 
   // mojom::CompositorFrameSink:
@@ -96,6 +98,9 @@ class RootCompositorFrameSinkImpl : public mojom::CompositorFrameSink,
   void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) override;
   void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override;
+  void SetPreferredFrameInterval(base::TimeDelta interval) override;
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) override;
 
   BeginFrameSource* begin_frame_source();
 

components/viz/test/mock_display_client.h

@@ -32,6 +32,7 @@ class MockDisplayClient : public mojom::DisplayClient {
   MOCK_METHOD1(DidCompleteSwapWithSize, void(const gfx::Size&));
   MOCK_METHOD1(OnFatalOrSurfaceContextCreationFailure,
                void(gpu::ContextResult));
+  MOCK_METHOD1(SetPreferredRefreshRate, void(float refresh_rate));
 #endif
 
  private:

components/viz/test/test_layer_tree_frame_sink.cc

@@ -270,4 +270,9 @@ void TestLayerTreeFrameSink::SendCompositorFrameAckToClient() {
   client_->DidReceiveCompositorFrameAck();
 }
 
+base::TimeDelta TestLayerTreeFrameSink::GetPreferredFrameIntervalForFrameSinkId(
+    const FrameSinkId& id) {
+  return BeginFrameArgs::MinInterval();
+}
+
 }  // namespace viz

components/viz/test/test_layer_tree_frame_sink.h

@@ -115,6 +115,9 @@ class TestLayerTreeFrameSink : public cc::LayerTreeFrameSink,
   void DisplayDidReceiveCALayerParams(
       const gfx::CALayerParams& ca_layer_params) override;
   void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override;
+  void SetPreferredFrameInterval(base::TimeDelta interval) override {}
+  base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+      const FrameSinkId& id) override;
 
   const std::set<SharedBitmapId>& owned_bitmaps() const {
     return owned_bitmaps_;

content/browser/android/overscroll_controller_android_unittest.cc

@@ -51,6 +51,8 @@ class MockCompositor : public WindowAndroidCompositor {
   bool IsDrawingFirstVisibleFrame() const override { return false; }
   void SetVSyncPaused(bool paused) override {}
   void OnUpdateRefreshRate(float refresh_rate) override {}
+  void OnUpdateSupportedRefreshRates(
+      const std::vector<float>& supported_refresh_rates) override {}
 };
 
 class MockGlowClient : public OverscrollGlowClient {

content/browser/renderer_host/compositor_impl_android.cc

@@ -146,34 +146,6 @@ class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
   ~SingleThreadTaskGraphRunner() override { Shutdown(); }
 };
 
-// An implementation of HostDisplayClient which handles swap callbacks.
-class AndroidHostDisplayClient : public viz::HostDisplayClient {
- public:
-  explicit AndroidHostDisplayClient(
-      base::RepeatingCallback<void(const gfx::Size&)> on_swap,
-      base::RepeatingCallback<void(gpu::ContextResult)>
-          on_context_creation_failure)
-      : HostDisplayClient(gfx::kNullAcceleratedWidget),
-        on_swap_(std::move(on_swap)),
-        on_context_creation_failure_(std::move(on_context_creation_failure)) {}
-
-  // viz::mojom::DisplayClient implementation:
-  void DidCompleteSwapWithSize(const gfx::Size& pixel_size) override {
-    if (on_swap_)
-      on_swap_.Run(pixel_size);
-  }
-  void OnFatalOrSurfaceContextCreationFailure(
-      gpu::ContextResult context_result) override {
-    if (on_context_creation_failure_)
-      on_context_creation_failure_.Run(context_result);
-  }
-
- private:
-  base::RepeatingCallback<void(const gfx::Size&)> on_swap_;
-  base::RepeatingCallback<void(gpu::ContextResult)>
-      on_context_creation_failure_;
-};
-
 class CompositorDependencies {
  public:
   static CompositorDependencies& Get() {
@@ -542,6 +514,30 @@ static bool g_initialized = false;
 
 }  // anonymous namespace
 
+// An implementation of HostDisplayClient which handles swap callbacks.
+class CompositorImpl::AndroidHostDisplayClient : public viz::HostDisplayClient {
+ public:
+  explicit AndroidHostDisplayClient(CompositorImpl* compositor)
+      : HostDisplayClient(gfx::kNullAcceleratedWidget),
+        compositor_(compositor) {}
+
+  // viz::mojom::DisplayClient implementation:
+  void DidCompleteSwapWithSize(const gfx::Size& pixel_size) override {
+    compositor_->DidSwapBuffers(pixel_size);
+  }
+  void OnFatalOrSurfaceContextCreationFailure(
+      gpu::ContextResult context_result) override {
+    compositor_->OnFatalOrSurfaceContextCreationFailure(context_result);
+  }
+  void SetPreferredRefreshRate(float refresh_rate) override {
+    if (compositor_->root_window_)
+      compositor_->root_window_->SetPreferredRefreshRate(refresh_rate);
+  }
+
+ private:
+  CompositorImpl* compositor_;
+};
+
 // static
 Compositor* Compositor::Create(CompositorClient* client,
                                gfx::NativeWindow root_window) {
@@ -1185,6 +1181,12 @@ void CompositorImpl::OnUpdateRefreshRate(float refresh_rate) {
     display_private_->UpdateRefreshRate(refresh_rate);
 }
 
+void CompositorImpl::OnUpdateSupportedRefreshRates(
+    const std::vector<float>& supported_refresh_rates) {
+  if (display_private_)
+    display_private_->SetSupportedRefreshRates(supported_refresh_rates);
+}
+
 void CompositorImpl::InitializeVizLayerTreeFrameSink(
     scoped_refptr<ws::ContextProviderCommandBuffer> context_provider) {
   DCHECK(enable_viz_);
@@ -1206,12 +1208,7 @@ void CompositorImpl::InitializeVizLayerTreeFrameSink(
   viz::mojom::CompositorFrameSinkClientRequest client_request =
       mojo::MakeRequest(&root_params->compositor_frame_sink_client);
   root_params->display_private = mojo::MakeRequest(&display_private_);
-  display_client_ = std::make_unique<AndroidHostDisplayClient>(
-      base::BindRepeating(&CompositorImpl::DidSwapBuffers,
-                          weak_factory_.GetWeakPtr()),
-      base::BindRepeating(
-          &CompositorImpl::OnFatalOrSurfaceContextCreationFailure,
-          weak_factory_.GetWeakPtr()));
+  display_client_ = std::make_unique<AndroidHostDisplayClient>(this);
   root_params->display_client =
       display_client_->GetBoundPtr(task_runner).PassInterface();
 
@@ -1260,6 +1257,8 @@ void CompositorImpl::InitializeVizLayerTreeFrameSink(
   display_private_->SetDisplayColorSpace(display_color_space_,
                                          display_color_space_);
   display_private_->SetVSyncPaused(vsync_paused_);
+  display_private_->SetSupportedRefreshRates(
+      root_window_->GetSupportedRefreshRates());
 }
 
 viz::LocalSurfaceIdAllocation CompositorImpl::GenerateLocalSurfaceId() {

content/browser/renderer_host/compositor_impl_android.h

@@ -97,6 +97,8 @@ class CONTENT_EXPORT CompositorImpl
   }
 
  private:
+  class AndroidHostDisplayClient;
+
   // Compositor implementation.
   void SetRootWindow(gfx::NativeWindow root_window) override;
   void SetRootLayer(scoped_refptr<cc::Layer> root) override;
@@ -160,6 +162,8 @@ class CONTENT_EXPORT CompositorImpl
   bool IsDrawingFirstVisibleFrame() const override;
   void SetVSyncPaused(bool paused) override;
   void OnUpdateRefreshRate(float refresh_rate) override;
+  void OnUpdateSupportedRefreshRates(
+      const std::vector<float>& supported_refresh_rates) override;
 
   // viz::HostFrameSinkClient implementation.
   void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;

content/renderer/android/synchronous_layer_tree_frame_sink.cc

@@ -107,6 +107,11 @@ class SynchronousLayerTreeFrameSink::SoftwareOutputSurface
   unsigned UpdateGpuFence() override { return 0; }
 };
 
+base::TimeDelta SynchronousLayerTreeFrameSink::StubDisplayClient::
+    GetPreferredFrameIntervalForFrameSinkId(const viz::FrameSinkId& id) {
+  return viz::BeginFrameArgs::MinInterval();
+}
+
 SynchronousLayerTreeFrameSink::SynchronousLayerTreeFrameSink(
     scoped_refptr<viz::ContextProvider> context_provider,
     scoped_refptr<viz::RasterContextProvider> worker_context_provider,

content/renderer/android/synchronous_layer_tree_frame_sink.h

@@ -176,6 +176,9 @@ class SynchronousLayerTreeFrameSink
     void DisplayDidReceiveCALayerParams(
         const gfx::CALayerParams& ca_layer_params) override {}
     void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override {}
+    void SetPreferredFrameInterval(base::TimeDelta interval) override {}
+    base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
+        const viz::FrameSinkId& id) override;
   };
 
   // TODO(danakj): These don't to be stored in unique_ptrs when OutputSurface