aw: Move BeginFrame code to SynchronousCompositor

This CL moves BeginFrame related code to SynchronousCompositorHost
from RenderWidgetHostViewAndroid as it was used only for WebView.
This is part of ongoing refactoring for viz for WebView.

Bug: 805739
Change-Id: I06c264db4fceb8ebee281660f1c771ac45a68b3e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1992250
Commit-Queue: Vasiliy Telezhnikov <vasilyt@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#730155}

content/browser/android/synchronous_compositor_host.cc

@@ -156,6 +156,7 @@ SynchronousCompositorHost::SynchronousCompositorHost(
 }
 
 SynchronousCompositorHost::~SynchronousCompositorHost() {
+  SetBeginFrameSource(nullptr);
   client_->DidDestroyCompositor(this, frame_sink_id_);
   bridge_->HostDestroyedOnUIThread();
 }
@@ -435,7 +436,10 @@ void SynchronousCompositorHost::ReturnResources(
 void SynchronousCompositorHost::DidPresentCompositorFrames(
     viz::FrameTimingDetailsMap timing_details,
     uint32_t frame_token) {
-  rwhva_->DidPresentCompositorFrames(timing_details);
+  timing_details_ = timing_details;
+  if (!timing_details_.empty())
+    AddBeginFrameRequest(BEGIN_FRAME);
+
   UpdatePresentedFrameToken(frame_token);
 }
 
@@ -509,25 +513,13 @@ void SynchronousCompositorHost::DidOverscroll(
                          over_scroll_params.current_fling_velocity);
 }
 
-void SynchronousCompositorHost::BeginFrame(
-    ui::WindowAndroid* window_android,
-    const viz::BeginFrameArgs& args,
-    const viz::FrameTimingDetailsMap& timing_details) {
-  if (!bridge_->WaitAfterVSyncOnUIThread(window_android))
-    return;
-  mojom::SynchronousCompositor* compositor = GetSynchronousCompositor();
-  DCHECK(compositor);
-  compositor->BeginFrame(args, timing_details);
-}
-
-void SynchronousCompositorHost::SetBeginFramePaused(bool paused) {
-  begin_frame_paused_ = paused;
-  if (mojom::SynchronousCompositor* compositor = GetSynchronousCompositor())
-    compositor->SetBeginFrameSourcePaused(paused);
-}
-
 void SynchronousCompositorHost::SetNeedsBeginFrames(bool needs_begin_frames) {
-  rwhva_->SetNeedsBeginFrames(needs_begin_frames);
+  TRACE_EVENT1("cc", "SynchronousCompositorHost::SetNeedsBeginFrames",
+               "needs_begin_frames", needs_begin_frames);
+  if (needs_begin_frames)
+    AddBeginFrameRequest(PERSISTENT_BEGIN_FRAME);
+  else
+    ClearBeginFrameRequest(PERSISTENT_BEGIN_FRAME);
 }
 
 void SynchronousCompositorHost::LayerTreeFrameSinkCreated() {
@@ -539,8 +531,7 @@ void SynchronousCompositorHost::LayerTreeFrameSinkCreated() {
   DCHECK(compositor);
   compositor->SetMemoryPolicy(bytes_limit_);
 
-  if (begin_frame_paused_)
-    compositor->SetBeginFrameSourcePaused(begin_frame_paused_);
+  SendBeginFramePaused();
 }
 
 void SynchronousCompositorHost::UpdateState(
@@ -604,4 +595,135 @@ SynchronousCompositorHost::GetSynchronousCompositor() {
   return sync_compositor_.get();
 }
 
+void SynchronousCompositorHost::OnBeginFrame(const viz::BeginFrameArgs& args) {
+  TRACE_EVENT0("cc,benchmark", "SynchronousCompositorHost::OnBeginFrame");
+
+  // In sync mode, we disregard missed frame args to ensure that
+  // SynchronousCompositorBrowserFilter::SyncStateAfterVSync will be called
+  // during WindowAndroid::WindowBeginFrameSource::OnVSync() observer iteration.
+  if (args.type == viz::BeginFrameArgs::MISSED)
+    return;
+
+  // We need to check this before |outstanding_begin_frame_requests_| will be
+  // changed by ClearBeginFrameRequest below.
+  bool needs_begin_frame =
+      (outstanding_begin_frame_requests_ & BEGIN_FRAME) ||
+      (outstanding_begin_frame_requests_ & PERSISTENT_BEGIN_FRAME);
+
+  // Update |last_begin_frame_args_| before handling
+  // |outstanding_begin_frame_requests_| to prevent the BeginFrameSource from
+  // sending the same MISSED args in infinite recursion.
+  last_begin_frame_args_ = args;
+
+  ClearBeginFrameRequest(BEGIN_FRAME);
+
+  if (on_compute_scroll_called_ || !rwhva_->is_currently_scrolling_viewport()) {
+    rwhva_->host()->ProgressFlingIfNeeded(args.frame_time);
+  }
+
+  if (needs_begin_frame) {
+    SendBeginFrame(args);
+  }
+}
+
+const viz::BeginFrameArgs& SynchronousCompositorHost::LastUsedBeginFrameArgs()
+    const {
+  return last_begin_frame_args_;
+}
+
+void SynchronousCompositorHost::OnBeginFrameSourcePausedChanged(bool paused) {
+  if (paused != begin_frame_paused_) {
+    begin_frame_paused_ = paused;
+    SendBeginFramePaused();
+  }
+}
+
+bool SynchronousCompositorHost::WantsAnimateOnlyBeginFrames() const {
+  return false;
+}
+
+void SynchronousCompositorHost::SendBeginFramePaused() {
+  bool paused = begin_frame_paused_ || !observed_root_window_;
+
+  if (mojom::SynchronousCompositor* compositor = GetSynchronousCompositor())
+    compositor->SetBeginFrameSourcePaused(paused);
+}
+
+void SynchronousCompositorHost::SendBeginFrame(viz::BeginFrameArgs args) {
+  TRACE_EVENT2("cc", "SynchronousCompositorHost::SendBeginFrame",
+               "frame_number", args.frame_id.sequence_number, "frame_time_us",
+               args.frame_time);
+
+  DCHECK(observed_root_window_);
+  if (!bridge_->WaitAfterVSyncOnUIThread(observed_root_window_))
+    return;
+  mojom::SynchronousCompositor* compositor = GetSynchronousCompositor();
+  DCHECK(compositor);
+  compositor->BeginFrame(args, timing_details_);
+  timing_details_.clear();
+}
+
+void SynchronousCompositorHost::StartObservingRootWindow(
+    ui::WindowAndroid* window) {
+  DCHECK(window);
+  if (observed_root_window_) {
+    DCHECK(observed_root_window_ == window);
+    return;
+  }
+
+  observed_root_window_ = window;
+  SendBeginFramePaused();
+  SetBeginFrameSource(window->GetBeginFrameSource());
+}
+
+void SynchronousCompositorHost::StopObservingRootWindow() {
+  if (!observed_root_window_)
+    return;
+
+  // Reset window state variables to their defaults.
+  observed_root_window_ = nullptr;
+  SendBeginFramePaused();
+  SetBeginFrameSource(nullptr);
+  DCHECK(!begin_frame_source_);
+}
+
+void SynchronousCompositorHost::SetBeginFrameSource(
+    viz::BeginFrameSource* begin_frame_source) {
+  if (begin_frame_source_ == begin_frame_source)
+    return;
+
+  if (begin_frame_source_ && outstanding_begin_frame_requests_)
+    begin_frame_source_->RemoveObserver(this);
+  begin_frame_source_ = begin_frame_source;
+  if (begin_frame_source_ && outstanding_begin_frame_requests_)
+    begin_frame_source_->AddObserver(this);
+}
+
+void SynchronousCompositorHost::AddBeginFrameRequest(
+    BeginFrameRequestType request) {
+  uint32_t prior_requests = outstanding_begin_frame_requests_;
+  outstanding_begin_frame_requests_ = prior_requests | request;
+
+  // Note that if we don't currently have a BeginFrameSource, outstanding begin
+  // frame requests will be pushed if/when we get one during
+  // |StartObservingRootWindow()| or when the DelegatedFrameHostAndroid sets it.
+  viz::BeginFrameSource* source = begin_frame_source_;
+  if (source && outstanding_begin_frame_requests_ && !prior_requests)
+    source->AddObserver(this);
+}
+
+void SynchronousCompositorHost::ClearBeginFrameRequest(
+    BeginFrameRequestType request) {
+  uint32_t prior_requests = outstanding_begin_frame_requests_;
+  outstanding_begin_frame_requests_ = prior_requests & ~request;
+
+  viz::BeginFrameSource* source = begin_frame_source_;
+  if (source && !outstanding_begin_frame_requests_ && prior_requests)
+    source->RemoveObserver(this);
+}
+
+void SynchronousCompositorHost::RequestOneBeginFrame() {
+  AddBeginFrameRequest(BEGIN_FRAME);
+}
+
 }  // namespace content

content/browser/android/synchronous_compositor_host.h

@@ -14,6 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "components/viz/common/frame_sinks/begin_frame_source.h"
 #include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/common/surfaces/frame_sink_id.h"
 #include "content/common/input/synchronous_compositor.mojom.h"
@@ -39,7 +40,8 @@ class SynchronousCompositorSyncCallBridge;
 struct SyncCompositorCommonRendererParams;
 
 class SynchronousCompositorHost : public SynchronousCompositor,
-                                  public mojom::SynchronousCompositorHost {
+                                  public mojom::SynchronousCompositorHost,
+                                  public viz::BeginFrameObserver {
  public:
   static std::unique_ptr<SynchronousCompositorHost> Create(
       RenderWidgetHostViewAndroid* rwhva,
@@ -68,10 +70,6 @@ class SynchronousCompositorHost : public SynchronousCompositor,
 
   ui::ViewAndroid::CopyViewCallback GetCopyViewCallback();
   void DidOverscroll(const ui::DidOverscrollParams& over_scroll_params);
-  void BeginFrame(ui::WindowAndroid* window_android,
-                  const viz::BeginFrameArgs& args,
-                  const viz::FrameTimingDetailsMap& timing_details);
-  void SetBeginFramePaused(bool paused);
 
   // Called by SynchronousCompositorSyncCallBridge.
   void UpdateFrameMetaData(uint32_t version,
@@ -84,14 +82,27 @@ class SynchronousCompositorHost : public SynchronousCompositor,
 
   RenderProcessHost* GetRenderProcessHost();
 
+  void StartObservingRootWindow(ui::WindowAndroid* window);
+  void StopObservingRootWindow();
+  void RequestOneBeginFrame();
+
   // mojom::SynchronousCompositorHost overrides.
   void LayerTreeFrameSinkCreated() override;
   void UpdateState(const SyncCompositorCommonRendererParams& params) override;
   void SetNeedsBeginFrames(bool needs_begin_frames) override;
 
-  bool on_compute_scroll_called() { return on_compute_scroll_called_; }
+  // viz::BeginFrameObserver implementation.
+  void OnBeginFrame(const viz::BeginFrameArgs& args) override;
+  const viz::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
+  void OnBeginFrameSourcePausedChanged(bool paused) override;
+  bool WantsAnimateOnlyBeginFrames() const override;
 
  private:
+  enum BeginFrameRequestType {
+    BEGIN_FRAME = 1 << 0,
+    PERSISTENT_BEGIN_FRAME = 1 << 1
+  };
+
   class ScopedSendZeroMemory;
   struct SharedMemoryWithSize;
   friend class ScopedSetZeroMemory;
@@ -114,6 +125,12 @@ class SynchronousCompositorHost : public SynchronousCompositor,
   void UpdateRootLayerStateOnClient();
   void UpdatePresentedFrameToken(uint32_t frame_token);
 
+  void SendBeginFramePaused();
+  void SendBeginFrame(viz::BeginFrameArgs args);
+  void SetBeginFrameSource(viz::BeginFrameSource* begin_frame_source);
+  void AddBeginFrameRequest(BeginFrameRequestType request);
+  void ClearBeginFrameRequest(BeginFrameRequestType request);
+
   RenderWidgetHostViewAndroid* const rwhva_;
   SynchronousCompositorClient* const client_;
   const viz::FrameSinkId frame_sink_id_;
@@ -164,6 +181,16 @@ class SynchronousCompositorHost : public SynchronousCompositor,
 
   scoped_refptr<SynchronousCompositorSyncCallBridge> bridge_;
 
+  // Indicates whether and for what reason a request for begin frames has been
+  // issued. Used to control action dispatch at the next |OnBeginFrame()| call.
+  uint32_t outstanding_begin_frame_requests_ = 0;
+
+  // The begin frame source being observed.  Null if none.
+  viz::BeginFrameSource* begin_frame_source_ = nullptr;
+  viz::BeginFrameArgs last_begin_frame_args_;
+  ui::WindowAndroid* observed_root_window_ = nullptr;
+  viz::FrameTimingDetailsMap timing_details_;
+
   DISALLOW_COPY_AND_ASSIGN(SynchronousCompositorHost);
 };
 

content/browser/renderer_host/render_widget_host_view_android.cc

@@ -212,8 +212,6 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     gfx::NativeView parent_native_view)
     : RenderWidgetHostViewBase(widget_host),
-      begin_frame_source_(nullptr),
-      outstanding_begin_frame_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       is_window_visible_(true),
       is_window_activity_started_(true),
@@ -757,15 +755,6 @@ void RenderWidgetHostViewAndroid::OnTextSelectionChanged(
       base::UTF16ToUTF8(selection.selected_text()));
 }
 
-void RenderWidgetHostViewAndroid::SetNeedsBeginFrames(bool needs_begin_frames) {
-  TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::SetNeedsBeginFrames",
-               "needs_begin_frames", needs_begin_frames);
-  if (needs_begin_frames)
-    AddBeginFrameRequest(PERSISTENT_BEGIN_FRAME);
-  else
-    ClearBeginFrameRequest(PERSISTENT_BEGIN_FRAME);
-}
-
 viz::FrameSinkId RenderWidgetHostViewAndroid::GetRootFrameSinkId() {
   if (view_.GetWindowAndroid() && view_.GetWindowAndroid()->GetCompositor())
     return view_.GetWindowAndroid()->GetCompositor()->GetFrameSinkId();
@@ -884,9 +873,10 @@ bool RenderWidgetHostViewAndroid::OnTouchEvent(
   // scroll-inducing touch events. Note that Android's Choreographer ensures
   // that BeginFrame requests made during Action::MOVE dispatch will be honored
   // in the same vsync phase.
-  if (observing_root_window_ && result.moved_beyond_slop_region)
-    AddBeginFrameRequest(BEGIN_FRAME);
-
+  if (observing_root_window_ && result.moved_beyond_slop_region) {
+    if (sync_compositor_)
+      sync_compositor_->RequestOneBeginFrame();
+  }
   return true;
 }
 
@@ -1051,13 +1041,6 @@ bool RenderWidgetHostViewAndroid::ShouldRouteEvents() const {
          host()->delegate()->GetInputEventRouter();
 }
 
-void RenderWidgetHostViewAndroid::DidPresentCompositorFrames(
-    const viz::FrameTimingDetailsMap& timing_details) {
-  timing_details_ = timing_details;
-  if (!timing_details_.empty())
-    AddBeginFrameRequest(BEGIN_FRAME);
-}
-
 void RenderWidgetHostViewAndroid::EvictFrameIfNecessary() {
   if (!host()->delegate()->IsFullscreenForCurrentTab() ||
       current_surface_size_ == view_.GetPhysicalBackingSize()) {
@@ -1407,7 +1390,8 @@ void RenderWidgetHostViewAndroid::ShowInternal() {
 
   if (view_.parent() && view_.GetWindowAndroid()) {
     StartObservingRootWindow();
-    AddBeginFrameRequest(BEGIN_FRAME);
+    if (sync_compositor_)
+      sync_compositor_->RequestOneBeginFrame();
   }
 }
 
@@ -1447,41 +1431,6 @@ void RenderWidgetHostViewAndroid::HideInternal() {
   host()->WasHidden();
 }
 
-void RenderWidgetHostViewAndroid::SetBeginFrameSource(
-    viz::BeginFrameSource* begin_frame_source) {
-  if (begin_frame_source_ == begin_frame_source)
-    return;
-
-  if (begin_frame_source_ && outstanding_begin_frame_requests_)
-    begin_frame_source_->RemoveObserver(this);
-  begin_frame_source_ = begin_frame_source;
-  if (begin_frame_source_ && outstanding_begin_frame_requests_)
-    begin_frame_source_->AddObserver(this);
-}
-
-void RenderWidgetHostViewAndroid::AddBeginFrameRequest(
-    BeginFrameRequestType request) {
-  uint32_t prior_requests = outstanding_begin_frame_requests_;
-  outstanding_begin_frame_requests_ = prior_requests | request;
-
-  // Note that if we don't currently have a BeginFrameSource, outstanding begin
-  // frame requests will be pushed if/when we get one during
-  // |StartObservingRootWindow()| or when the DelegatedFrameHostAndroid sets it.
-  viz::BeginFrameSource* source = begin_frame_source_;
-  if (source && outstanding_begin_frame_requests_ && !prior_requests)
-    source->AddObserver(this);
-}
-
-void RenderWidgetHostViewAndroid::ClearBeginFrameRequest(
-    BeginFrameRequestType request) {
-  uint32_t prior_requests = outstanding_begin_frame_requests_;
-  outstanding_begin_frame_requests_ = prior_requests & ~request;
-
-  viz::BeginFrameSource* source = begin_frame_source_;
-  if (source && !outstanding_begin_frame_requests_ && prior_requests)
-    source->RemoveObserver(this);
-}
-
 void RenderWidgetHostViewAndroid::StartObservingRootWindow() {
   DCHECK(view_.parent());
   DCHECK(view_.GetWindowAndroid());
@@ -1490,11 +1439,10 @@ void RenderWidgetHostViewAndroid::StartObservingRootWindow() {
     return;
 
   observing_root_window_ = true;
-  SendBeginFramePaused();
   view_.GetWindowAndroid()->AddObserver(this);
   // When using browser compositor, DelegatedFrameHostAndroid provides the BFS.
-  if (!using_browser_compositor_ && !using_viz_for_webview_)
-    SetBeginFrameSource(view_.GetWindowAndroid()->GetBeginFrameSource());
+  if (!using_browser_compositor_ && sync_compositor_ && !using_viz_for_webview_)
+    sync_compositor_->StartObservingRootWindow(view_.GetWindowAndroid());
 
   ui::WindowAndroidCompositor* compositor =
       view_.GetWindowAndroid()->GetCompositor();
@@ -1519,32 +1467,13 @@ void RenderWidgetHostViewAndroid::StopObservingRootWindow() {
   is_window_visible_ = true;
   observing_root_window_ = false;
   OnUpdateScopedSelectionHandles();
-  SendBeginFramePaused();
   view_.GetWindowAndroid()->RemoveObserver(this);
-  if (!using_browser_compositor_)
-    SetBeginFrameSource(nullptr);
+  if (!using_browser_compositor_ && sync_compositor_ && !using_viz_for_webview_)
+    sync_compositor_->StopObservingRootWindow();
   // If the DFH has already been destroyed, it will have cleaned itself up.
   // This happens in some WebView cases.
   if (delegated_frame_host_)
     delegated_frame_host_->DetachFromCompositor();
-  DCHECK(!begin_frame_source_);
-}
-
-void RenderWidgetHostViewAndroid::SendBeginFrame(viz::BeginFrameArgs args) {
-  TRACE_EVENT2("cc", "RenderWidgetHostViewAndroid::SendBeginFrame",
-               "frame_number", args.frame_id.sequence_number, "frame_time_us",
-               args.frame_time.ToInternalValue());
-
-  // Synchronous compositor does not use deadline-based scheduling.
-  // TODO(brianderson): Replace this hardcoded deadline after Android
-  // switches to Surfaces and the Browser's commit isn't in the critical path.
-  args.deadline = sync_compositor_ ? base::TimeTicks()
-  : args.frame_time + (args.interval * 0.6);
-  if (sync_compositor_) {
-    sync_compositor_->BeginFrame(view_.GetWindowAndroid(), args,
-                                 timing_details_);
-  }
-  timing_details_.clear();
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
@@ -2131,69 +2060,6 @@ void RenderWidgetHostViewAndroid::OnDetachCompositor() {
     delegated_frame_host_->DetachFromCompositor();
 }
 
-void RenderWidgetHostViewAndroid::OnBeginFrame(
-    const viz::BeginFrameArgs& args) {
-  TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnBeginFrame");
-  if (!host())
-    return;
-
-  // In sync mode, we disregard missed frame args to ensure that
-  // SynchronousCompositorBrowserFilter::SyncStateAfterVSync will be called
-  // during WindowAndroid::WindowBeginFrameSource::OnVSync() observer iteration.
-  if (sync_compositor_ && args.type == viz::BeginFrameArgs::MISSED)
-    return;
-
-  bool needs_begin_frame =
-      (outstanding_begin_frame_requests_ & BEGIN_FRAME) ||
-      (outstanding_begin_frame_requests_ & PERSISTENT_BEGIN_FRAME);
-
-  // Update |last_begin_frame_args_| before handling
-  // |outstanding_begin_frame_requests_| to prevent the BeginFrameSource from
-  // sending the same MISSED args in infinite recursion.
-  last_begin_frame_args_ = args;
-
-  ClearBeginFrameRequest(BEGIN_FRAME);
-
-  bool webview_fling = sync_compositor_ && is_currently_scrolling_viewport_;
-  if (!webview_fling) {
-    host_->ProgressFlingIfNeeded(args.frame_time);
-  } else if (sync_compositor_->on_compute_scroll_called()) {
-    // On Android webview progress the fling only when |OnComputeScroll| is
-    // called since in some cases Apps override |OnComputeScroll| to cancel
-    // fling animation.
-    host_->ProgressFlingIfNeeded(args.frame_time);
-  }
-
-  if (needs_begin_frame) {
-    SendBeginFrame(args);
-  }
-}
-
-const viz::BeginFrameArgs& RenderWidgetHostViewAndroid::LastUsedBeginFrameArgs()
-    const {
-  return last_begin_frame_args_;
-}
-
-bool RenderWidgetHostViewAndroid::WantsAnimateOnlyBeginFrames() const {
-  return false;
-}
-
-void RenderWidgetHostViewAndroid::SendBeginFramePaused() {
-  bool paused = begin_frame_paused_ || !observing_root_window_;
-
-  if (!using_browser_compositor_ && !using_viz_for_webview_) {
-    if (sync_compositor_)
-      sync_compositor_->SetBeginFramePaused(paused);
-  }
-}
-
-void RenderWidgetHostViewAndroid::OnBeginFrameSourcePausedChanged(bool paused) {
-  if (paused != begin_frame_paused_) {
-    begin_frame_paused_ = paused;
-    SendBeginFramePaused();
-  }
-}
-
 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
   if (Animate(begin_frame_time))
     SetNeedsAnimate();
@@ -2483,7 +2349,8 @@ void RenderWidgetHostViewAndroid::SetWebContentsAccessibility(
 }
 
 void RenderWidgetHostViewAndroid::SetNeedsBeginFrameForFlingProgress() {
-  AddBeginFrameRequest(BEGIN_FRAME);
+  if (sync_compositor_)
+    sync_compositor_->RequestOneBeginFrame();
 }
 
 }  // namespace content

content/browser/renderer_host/render_widget_host_view_android.h

@@ -21,9 +21,6 @@
 #include "base/process/process.h"
 #include "base/time/time.h"
 #include "cc/trees/render_frame_metadata.h"
-#include "components/viz/common/frame_sinks/begin_frame_args.h"
-#include "components/viz/common/frame_sinks/begin_frame_source.h"
-#include "components/viz/common/frame_timing_details_map.h"
 #include "components/viz/common/quads/selection.h"
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
 #include "content/browser/renderer_host/input/mouse_wheel_phase_handler.h"
@@ -31,7 +28,6 @@
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/renderer_host/text_input_manager.h"
 #include "content/common/content_export.h"
-#include "gpu/command_buffer/common/mailbox.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/android/delegated_frame_host_android.h"
 #include "ui/android/view_android.h"
@@ -75,8 +71,7 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
       public ui::GestureProviderClient,
       public ui::TouchSelectionControllerClient,
       public ui::ViewAndroidObserver,
-      public ui::WindowAndroidObserver,
-      public viz::BeginFrameObserver {
+      public ui::WindowAndroidObserver {
  public:
   RenderWidgetHostViewAndroid(RenderWidgetHostImpl* widget,
                               gfx::NativeView parent_native_view);
@@ -99,8 +94,6 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
     return touch_selection_controller_.get();
   }
 
-  void SetNeedsBeginFrames(bool needs_begin_frames);
-
   // RenderWidgetHostView implementation.
   void InitAsChild(gfx::NativeView parent_view) override;
   void InitAsPopup(RenderWidgetHostView* parent_host_view,
@@ -233,17 +226,6 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   std::unique_ptr<ui::TouchHandleDrawable> CreateDrawable() override;
   void DidScroll() override;
 
-  // Used by DelegatedFrameHostClientAndroid.
-  void SetBeginFrameSource(viz::BeginFrameSource* begin_frame_source);
-  void DidPresentCompositorFrames(
-      const viz::FrameTimingDetailsMap& timing_details);
-
-  // viz::BeginFrameObserver implementation.
-  void OnBeginFrame(const viz::BeginFrameArgs& args) override;
-  const viz::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
-  void OnBeginFrameSourcePausedChanged(bool paused) override;
-  bool WantsAnimateOnlyBeginFrames() const override;
-
   // Non-virtual methods
   void UpdateNativeViewTree(gfx::NativeView parent_native_view);
 
@@ -434,16 +416,8 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   void EvictDelegatedContent();
   void OnLostResources();
 
-  enum BeginFrameRequestType {
-    BEGIN_FRAME = 1 << 0,
-    PERSISTENT_BEGIN_FRAME = 1 << 1
-  };
-  void AddBeginFrameRequest(BeginFrameRequestType request);
-  void ClearBeginFrameRequest(BeginFrameRequestType request);
   void StartObservingRootWindow();
   void StopObservingRootWindow();
-  void SendBeginFramePaused();
-  void SendBeginFrame(viz::BeginFrameArgs args);
   bool Animate(base::TimeTicks frame_time);
   void RequestDisallowInterceptTouchEvent();
 
@@ -465,15 +439,6 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
 
   void OnUpdateScopedSelectionHandles();
 
-  // The begin frame source being observed.  Null if none.
-  viz::BeginFrameSource* begin_frame_source_;
-  viz::BeginFrameArgs last_begin_frame_args_;
-  bool begin_frame_paused_ = false;
-
-  // Indicates whether and for what reason a request for begin frames has been
-  // issued. Used to control action dispatch at the next |OnBeginFrame()| call.
-  uint32_t outstanding_begin_frame_requests_;
-
   bool is_showing_;
 
   // Window-specific bits that affect widget visibility.
@@ -566,8 +531,6 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   // If true, then the next allocated surface should be embedded.
   bool navigation_while_hidden_ = false;
 
-  viz::FrameTimingDetailsMap timing_details_;
-
   // Tracks whether we are in SynchronousCopyContents to avoid repeated calls
   // into DevTools capture logic.
   // TODO(ericrk): Make this more robust.