[android] Make RWHVAndroid a BeginFrameObserver.

Instead of directly observing the Window's vsyncs, RWHVAndroid now
observes a BeginFrameSource provided by the DelegatedFrameHost (clank)
or WindowAndroid (webview). To enable this, the BeginFrameSource
originally provided by CompositorImpl moves into WindowAndroid.

The patch also makes some changes to the BeginFrameSource's observer
iteration that are necessary to support
SynchronousBrowserCompositorFilter.

BUG=401336, 675289

Committed: https://crrev.com/1a6bd5037fc10e45646715d675e63146d23fc28d
Review-Url: https://codereview.chromium.org/2564403002
Cr-Original-Commit-Position: refs/heads/master@{#439072}
Cr-Commit-Position: refs/heads/master@{#439877}

content/browser/android/synchronous_compositor_browser_filter.cc

@@ -45,7 +45,7 @@ void SynchronousCompositorBrowserFilter::SyncStateAfterVSync(
   if (window_android_in_vsync_)
     return;
   window_android_in_vsync_ = window_android;
-  window_android_in_vsync_->AddObserver(this);
+  window_android_in_vsync_->GetBeginFrameSource()->AddObserver(this);
 }
 
 bool SynchronousCompositorBrowserFilter::OnMessageReceived(
@@ -177,30 +177,13 @@ void SynchronousCompositorBrowserFilter::SignalAllFutures() {
   filter_ready_ = false;
 }
 
-void SynchronousCompositorBrowserFilter::OnCompositingDidCommit() {
-  NOTREACHED();
-}
-
-void SynchronousCompositorBrowserFilter::OnRootWindowVisibilityChanged(
-    bool visible) {
-  NOTREACHED();
-}
-
-void SynchronousCompositorBrowserFilter::OnAttachCompositor() {
-  NOTREACHED();
-}
-
-void SynchronousCompositorBrowserFilter::OnDetachCompositor() {
-  NOTREACHED();
-}
-
-void SynchronousCompositorBrowserFilter::OnVSync(base::TimeTicks frame_time,
-                                                 base::TimeDelta vsync_period) {
-  // This is called after DidSendBeginFrame for SynchronousCompositorHosts
+void SynchronousCompositorBrowserFilter::OnBeginFrame(
+    const cc::BeginFrameArgs& args) {
+  // This is called after DidSendBeginFrame for all SynchronousCompositorHosts
   // belonging to this WindowAndroid, since this is added as an Observer after
   // the observer iteration has started.
   DCHECK(window_android_in_vsync_);
-  window_android_in_vsync_->RemoveObserver(this);
+  window_android_in_vsync_->GetBeginFrameSource()->RemoveObserver(this);
   window_android_in_vsync_ = nullptr;
 
   std::vector<int> routing_ids;
@@ -229,12 +212,18 @@ void SynchronousCompositorBrowserFilter::OnVSync(base::TimeTicks frame_time,
   compositor_host_pending_renderer_state_.clear();
 }
 
-void SynchronousCompositorBrowserFilter::OnActivityStopped() {
+const cc::BeginFrameArgs&
+SynchronousCompositorBrowserFilter::LastUsedBeginFrameArgs() const {
+  // Not called by the source since we add and remove ourselves during a single
+  // OnVSync() iteration.
   NOTREACHED();
+  return last_used_begin_frame_args_;
 }
 
-void SynchronousCompositorBrowserFilter::OnActivityStarted() {
-  NOTREACHED();
+void SynchronousCompositorBrowserFilter::OnBeginFrameSourcePausedChanged(
+    bool paused) {
+  // The BeginFrameSources we listen to don't use this.
+  DCHECK(!paused);
 }
 
 }  // namespace content

content/browser/android/synchronous_compositor_browser_filter.h

@@ -11,7 +11,9 @@
 
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_metadata.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "ui/android/window_android_observer.h"
@@ -25,20 +27,15 @@ namespace content {
 class RenderProcessHost;
 class SynchronousCompositorHost;
 
-class SynchronousCompositorBrowserFilter : public ui::WindowAndroidObserver,
+class SynchronousCompositorBrowserFilter : public cc::BeginFrameObserver,
                                            public BrowserMessageFilter {
  public:
   explicit SynchronousCompositorBrowserFilter(int process_id);
 
-  // WindowAndroidObserver overrides.
-  void OnCompositingDidCommit() override;
-  void OnRootWindowVisibilityChanged(bool visible) override;
-  void OnAttachCompositor() override;
-  void OnDetachCompositor() override;
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override;
-  void OnActivityStopped() override;
-  void OnActivityStarted() override;
+  // cc::BeginFrameObserver overrides.
+  void OnBeginFrame(const cc::BeginFrameArgs& args) override;
+  const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
+  void OnBeginFrameSourcePausedChanged(bool paused) override;
 
   // BrowserMessageFilter overrides.
   bool OnMessageReceived(const IPC::Message& message) override;
@@ -70,6 +67,7 @@ class SynchronousCompositorBrowserFilter : public ui::WindowAndroidObserver,
   ui::WindowAndroid* window_android_in_vsync_ = nullptr;
   std::vector<SynchronousCompositorHost*>
       compositor_host_pending_renderer_state_;
+  cc::BeginFrameArgs last_used_begin_frame_args_;
 
   // Only accessed on the UI thread. Note this is not a parallel map to
   // |future_map_|.

content/browser/renderer_host/compositor_impl_android.cc

@@ -40,7 +40,6 @@
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/resources/ui_resource_manager.h"
-#include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/direct_compositor_frame_sink.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
@@ -138,78 +137,6 @@ gpu::gles2::ContextCreationAttribHelper GetCompositorContextAttributes(
   return attributes;
 }
 
-class ExternalBeginFrameSource : public cc::BeginFrameSource,
-                                 public CompositorImpl::VSyncObserver {
- public:
-  explicit ExternalBeginFrameSource(CompositorImpl* compositor)
-      : compositor_(compositor) {
-    compositor_->AddObserver(this);
-  }
-  ~ExternalBeginFrameSource() override { compositor_->RemoveObserver(this); }
-
-  // cc::BeginFrameSource implementation.
-  void AddObserver(cc::BeginFrameObserver* obs) override;
-  void RemoveObserver(cc::BeginFrameObserver* obs) override;
-  void DidFinishFrame(cc::BeginFrameObserver* obs,
-                      size_t remaining_frames) override {}
-  bool IsThrottled() const override { return true; }
-
-  // CompositorImpl::VSyncObserver implementation.
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override;
-
- private:
-  CompositorImpl* const compositor_;
-  std::unordered_set<cc::BeginFrameObserver*> observers_;
-  cc::BeginFrameArgs last_begin_frame_args_;
-};
-
-void ExternalBeginFrameSource::AddObserver(cc::BeginFrameObserver* obs) {
-  DCHECK(obs);
-  DCHECK(observers_.find(obs) == observers_.end());
-
-  observers_.insert(obs);
-  obs->OnBeginFrameSourcePausedChanged(false);
-  compositor_->OnNeedsBeginFramesChange(true);
-
-  if (last_begin_frame_args_.IsValid()) {
-    // Send a MISSED begin frame if necessary.
-    cc::BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
-    if (!last_args.IsValid() ||
-        (last_begin_frame_args_.frame_time > last_args.frame_time)) {
-      last_begin_frame_args_.type = cc::BeginFrameArgs::MISSED;
-      // TODO(crbug.com/602485): A deadline doesn't make too much sense
-      // for a missed BeginFrame (the intention rather is 'immediately'),
-      // but currently the retro frame logic is very strict in discarding
-      // BeginFrames.
-      last_begin_frame_args_.deadline =
-          base::TimeTicks::Now() + last_begin_frame_args_.interval;
-      obs->OnBeginFrame(last_begin_frame_args_);
-    }
-  }
-}
-
-void ExternalBeginFrameSource::RemoveObserver(cc::BeginFrameObserver* obs) {
-  DCHECK(obs);
-  DCHECK(observers_.find(obs) != observers_.end());
-
-  observers_.erase(obs);
-  if (observers_.empty())
-    compositor_->OnNeedsBeginFramesChange(false);
-}
-
-void ExternalBeginFrameSource::OnVSync(base::TimeTicks frame_time,
-                                       base::TimeDelta vsync_period) {
-  // frame time is in the past, so give the next vsync period as the deadline.
-  base::TimeTicks deadline = frame_time + vsync_period;
-  last_begin_frame_args_ =
-      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
-                                 vsync_period, cc::BeginFrameArgs::NORMAL);
-  std::unordered_set<cc::BeginFrameObserver*> observers(observers_);
-  for (auto* obs : observers)
-    obs->OnBeginFrame(last_begin_frame_args_);
-}
-
 class AndroidOutputSurface : public cc::OutputSurface {
  public:
   explicit AndroidOutputSurface(
@@ -406,7 +333,6 @@ CompositorImpl::CompositorImpl(CompositorClient* client,
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       compositor_frame_sink_request_pending_(false),
-      needs_begin_frames_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
@@ -726,7 +652,6 @@ void CompositorImpl::InitializeDisplay(
   cc::SurfaceManager* manager =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
-  begin_frame_source_.reset(new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       task_runner, display_output_surface->capabilities().max_frames_pending));
 
@@ -734,7 +659,7 @@ void CompositorImpl::InitializeDisplay(
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
       host_->GetSettings().renderer_settings, frame_sink_id_,
-      begin_frame_source_.get(), std::move(display_output_surface),
+      root_window_->GetBeginFrameSource(), std::move(display_output_surface),
       std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner)));
 
@@ -753,14 +678,6 @@ void CompositorImpl::InitializeDisplay(
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
-void CompositorImpl::AddObserver(VSyncObserver* observer) {
-  observer_list_.AddObserver(observer);
-}
-
-void CompositorImpl::RemoveObserver(VSyncObserver* observer) {
-  observer_list_.RemoveObserver(observer);
-}
-
 cc::UIResourceId CompositorImpl::CreateUIResource(
     cc::UIResourceClient* client) {
   TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
@@ -806,23 +723,6 @@ void CompositorImpl::RequestCopyOfOutputOnRootLayer(
   root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
 }
 
-void CompositorImpl::OnVSync(base::TimeTicks frame_time,
-                             base::TimeDelta vsync_period) {
-  for (auto& observer : observer_list_)
-    observer.OnVSync(frame_time, vsync_period);
-  if (needs_begin_frames_)
-    root_window_->RequestVSyncUpdate();
-}
-
-void CompositorImpl::OnNeedsBeginFramesChange(bool needs_begin_frames) {
-  if (needs_begin_frames_ == needs_begin_frames)
-    return;
-
-  needs_begin_frames_ = needs_begin_frames;
-  if (needs_begin_frames_)
-    root_window_->RequestVSyncUpdate();
-}
-
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->IsVisible())

content/browser/renderer_host/compositor_impl_android.h

@@ -33,7 +33,6 @@ struct ANativeWindow;
 
 namespace cc {
 class AnimationHost;
-class BeginFrameSource;
 class Display;
 class Layer;
 class LayerTreeHost;
@@ -54,21 +53,11 @@ class CONTENT_EXPORT CompositorImpl
       public ui::UIResourceProvider,
       public ui::WindowAndroidCompositor {
  public:
-  class VSyncObserver {
-   public:
-    virtual void OnVSync(base::TimeTicks timebase,
-                         base::TimeDelta interval) = 0;
-  };
-
   CompositorImpl(CompositorClient* client, gfx::NativeWindow root_window);
   ~CompositorImpl() override;
 
   static bool IsInitialized();
 
-  void AddObserver(VSyncObserver* observer);
-  void RemoveObserver(VSyncObserver* observer);
-  void OnNeedsBeginFramesChange(bool needs_begin_frames);
-
   // ui::ResourceProvider implementation.
   cc::UIResourceId CreateUIResource(cc::UIResourceClient* client) override;
   void DeleteUIResource(cc::UIResourceId resource_id) override;
@@ -113,8 +102,6 @@ class CONTENT_EXPORT CompositorImpl
   void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) override;
   void RequestCopyOfOutputOnRootLayer(
       std::unique_ptr<cc::CopyOutputRequest> request) override;
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override;
   void SetNeedsAnimate() override;
   cc::FrameSinkId GetFrameSinkId() override;
 
@@ -147,12 +134,10 @@ class CONTENT_EXPORT CompositorImpl
   scoped_refptr<cc::Layer> readback_layer_tree_;
 
   // Destruction order matters here:
-  base::ObserverList<VSyncObserver, true> observer_list_;
   std::unique_ptr<cc::AnimationHost> animation_host_;
   std::unique_ptr<cc::LayerTreeHost> host_;
   ui::ResourceManagerImpl resource_manager_;
 
-  std::unique_ptr<cc::BeginFrameSource> begin_frame_source_;
   std::unique_ptr<cc::Display> display_;
 
   gfx::Size size_;
@@ -182,7 +167,6 @@ class CONTENT_EXPORT CompositorImpl
   bool compositor_frame_sink_request_pending_;
 
   gpu::Capabilities gpu_capabilities_;
-  bool needs_begin_frames_;
   base::WeakPtrFactory<CompositorImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorImpl);

content/browser/renderer_host/render_widget_host_view_android.h

@@ -20,6 +20,7 @@
 #include "base/process/process.h"
 #include "cc/input/selection.h"
 #include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/android/content_view_core_impl_observer.h"
 #include "content/browser/renderer_host/delegated_frame_evictor.h"
@@ -31,6 +32,7 @@
 #include "content/public/browser/readback_types.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"
 #include "ui/android/view_client.h"
 #include "ui/android/window_android_observer.h"
@@ -47,10 +49,6 @@ namespace ui {
 struct DidOverscrollParams;
 }
 
-namespace ui {
-class DelegatedFrameHostAndroid;
-}
-
 namespace content {
 class ContentViewCoreImpl;
 class OverscrollControllerAndroid;
@@ -72,7 +70,9 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
       public StylusTextSelectorClient,
       public ui::TouchSelectionControllerClient,
       public content::ContentViewCoreImplObserver,
-      public content::TextInputManager::Observer {
+      public content::TextInputManager::Observer,
+      public ui::DelegatedFrameHostAndroid::Client,
+      public cc::BeginFrameObserver {
  public:
   RenderWidgetHostViewAndroid(RenderWidgetHostImpl* widget,
                               ContentViewCoreImpl* content_view_core);
@@ -170,8 +170,6 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   void OnRootWindowVisibilityChanged(bool visible) override;
   void OnAttachCompositor() override;
   void OnDetachCompositor() override;
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override;
   void OnAnimate(base::TimeTicks begin_frame_time) override;
   void OnActivityStopped() override;
   void OnActivityStarted() override;
@@ -200,6 +198,15 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   void OnSelectionEvent(ui::SelectionEventType event) override;
   std::unique_ptr<ui::TouchHandleDrawable> CreateDrawable() override;
 
+  // DelegatedFrameHostAndroid::Client implementation.
+  void SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) override;
+  void ReturnResources(const cc::ReturnedResourceArray& resources) override;
+
+  // cc::BeginFrameObserver implementation.
+  void OnBeginFrame(const cc::BeginFrameArgs& args) override;
+  const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
+  void OnBeginFrameSourcePausedChanged(bool paused) override;
+
   // Non-virtual methods
   void SetContentViewCore(ContentViewCoreImpl* content_view_core);
   SkColor GetCachedBackgroundColor() const;
@@ -291,17 +298,16 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   void DestroyDelegatedContent();
   void OnLostResources();
 
-  void ReturnResources(const cc::ReturnedResourceArray& resources);
-
-  enum VSyncRequestType {
+  enum BeginFrameRequestType {
     FLUSH_INPUT = 1 << 0,
     BEGIN_FRAME = 1 << 1,
     PERSISTENT_BEGIN_FRAME = 1 << 2
   };
-  void RequestVSyncUpdate(uint32_t requests);
+  void AddBeginFrameRequest(BeginFrameRequestType request);
+  void ClearBeginFrameRequest(BeginFrameRequestType request);
   void StartObservingRootWindow();
   void StopObservingRootWindow();
-  void SendBeginFrame(base::TimeTicks frame_time, base::TimeDelta vsync_period);
+  void SendBeginFrame(cc::BeginFrameArgs args);
   bool Animate(base::TimeTicks frame_time);
   void RequestDisallowInterceptTouchEvent();
 
@@ -314,8 +320,13 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid
   // The model object.
   RenderWidgetHostImpl* host_;
 
-  // Used to control action dispatch at the next |OnVSync()| call.
-  uint32_t outstanding_vsync_requests_;
+  // The begin frame source being observed.  Null if none.
+  cc::BeginFrameSource* begin_frame_source_;
+  cc::BeginFrameArgs last_begin_frame_args_;
+
+  // 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_;
 

ui/android/DEPS

@@ -2,6 +2,7 @@ include_rules = [
   "+cc/layers",
   "+cc/output",
   "+cc/resources",
+  "+cc/scheduler/begin_frame_source.h",
   "+cc/surfaces",
   "+cc/test/stub_layer_tree_host_client.h",
   "+cc/test/test_task_graph_runner.h",

ui/android/delegated_frame_host_android.cc

@@ -51,17 +51,16 @@ void CopyOutputRequestCallback(
 
 }  // namespace
 
-DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
-    ui::ViewAndroid* view,
-    SkColor background_color,
-    ReturnResourcesCallback return_resources_callback)
+DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(ui::ViewAndroid* view,
+                                                     SkColor background_color,
+                                                     Client* client)
     : frame_sink_id_(
           ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()),
       view_(view),
-      return_resources_callback_(return_resources_callback),
+      client_(client),
       background_layer_(cc::SolidColorLayer::Create()) {
   DCHECK(view_);
-  DCHECK(!return_resources_callback_.is_null());
+  DCHECK(client_);
 
   surface_manager_ =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
@@ -223,13 +222,12 @@ void DelegatedFrameHostAndroid::UnregisterFrameSinkHierarchy() {
 
 void DelegatedFrameHostAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
-  return_resources_callback_.Run(resources);
+  client_->ReturnResources(resources);
 }
 
 void DelegatedFrameHostAndroid::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
-  // TODO(enne): hook this up instead of making RWHVAndroid a
-  // WindowAndroidObserver.
+  client_->SetBeginFrameSource(begin_frame_source);
 }
 
 void DelegatedFrameHostAndroid::UpdateBackgroundLayer() {

ui/android/delegated_frame_host_android.h

@@ -32,12 +32,16 @@ class WindowAndroidCompositor;
 class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
     : public cc::SurfaceFactoryClient {
  public:
-  using ReturnResourcesCallback =
-      base::Callback<void(const cc::ReturnedResourceArray&)>;
+  class Client {
+   public:
+    virtual void SetBeginFrameSource(
+        cc::BeginFrameSource* begin_frame_source) = 0;
+    virtual void ReturnResources(const cc::ReturnedResourceArray&) = 0;
+  };
 
   DelegatedFrameHostAndroid(ViewAndroid* view,
                             SkColor background_color,
-                            ReturnResourcesCallback return_resources_callback);
+                            Client* client);
 
   ~DelegatedFrameHostAndroid() override;
 
@@ -81,7 +85,7 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
   cc::SurfaceManager* surface_manager_;
   std::unique_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
   cc::FrameSinkId registered_parent_frame_sink_id_;
-  ReturnResourcesCallback return_resources_callback_;
+  Client* client_;
 
   std::unique_ptr<cc::SurfaceFactory> surface_factory_;
 

ui/android/window_android.cc

@@ -4,12 +4,19 @@
 
 #include "ui/android/window_android.h"
 
+#include <unordered_set>
+
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/auto_reset.h"
+#include "base/observer_list.h"
+#include "base/stl_util.h"
+#include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "jni/WindowAndroid_jni.h"
 #include "ui/android/window_android_compositor.h"
 #include "ui/android/window_android_observer.h"
@@ -21,8 +28,107 @@ using base::android::JavaParamRef;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
+class WindowAndroid::WindowBeginFrameSource : public cc::BeginFrameSource {
+ public:
+  explicit WindowBeginFrameSource(WindowAndroid* window)
+      : window_(window),
+        observer_count_(0),
+        in_on_vsync_(false) {}
+  ~WindowBeginFrameSource() override {}
+
+  // cc::BeginFrameSource implementation.
+  void AddObserver(cc::BeginFrameObserver* obs) override;
+  void RemoveObserver(cc::BeginFrameObserver* obs) override;
+  void DidFinishFrame(cc::BeginFrameObserver* obs,
+                      size_t remaining_frames) override {}
+  bool IsThrottled() const override { return true; }
+
+  void OnVSync(base::TimeTicks frame_time,
+               base::TimeDelta vsync_period);
+
+ private:
+  WindowAndroid* const window_;
+  base::ObserverList<cc::BeginFrameObserver> observers_;
+  int observer_count_;
+  cc::BeginFrameArgs last_begin_frame_args_;
+  bool in_on_vsync_;
+};
+
+void WindowAndroid::WindowBeginFrameSource::AddObserver(
+    cc::BeginFrameObserver* obs) {
+  DCHECK(obs);
+  DCHECK(!observers_.HasObserver(obs));
+
+  observers_.AddObserver(obs);
+  observer_count_++;
+  obs->OnBeginFrameSourcePausedChanged(false);
+  window_->SetNeedsBeginFrames(true);
+
+  // Send a MISSED BeginFrame if possible and necessary. If an observer is added
+  // during OnVSync(), it will get a NORMAL BeginFrame from OnVSync() instead.
+  if (!in_on_vsync_ && last_begin_frame_args_.IsValid()) {
+    cc::BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
+    if (!last_args.IsValid() ||
+        last_args.frame_time < last_begin_frame_args_.frame_time) {
+      last_begin_frame_args_.type = cc::BeginFrameArgs::MISSED;
+      // TODO(crbug.com/602485): A deadline doesn't make too much sense
+      // for a missed BeginFrame (the intention rather is 'immediately'),
+      // but currently the retro frame logic is very strict in discarding
+      // BeginFrames.
+      last_begin_frame_args_.deadline =
+          base::TimeTicks::Now() + last_begin_frame_args_.interval;
+      obs->OnBeginFrame(last_begin_frame_args_);
+    }
+  }
+}
+
+void WindowAndroid::WindowBeginFrameSource::RemoveObserver(
+    cc::BeginFrameObserver* obs) {
+  DCHECK(obs);
+  DCHECK(observers_.HasObserver(obs));
+
+  observers_.RemoveObserver(obs);
+  observer_count_--;
+  if (observer_count_ <= 0)
+    window_->SetNeedsBeginFrames(false);
+}
+
+void WindowAndroid::WindowBeginFrameSource::OnVSync(
+    base::TimeTicks frame_time,
+    base::TimeDelta vsync_period) {
+  // frame time is in the past, so give the next vsync period as the deadline.
+  base::TimeTicks deadline = frame_time + vsync_period;
+  last_begin_frame_args_ =
+      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
+                                 vsync_period, cc::BeginFrameArgs::NORMAL);
+  DCHECK(last_begin_frame_args_.IsValid());
+
+  // We support adding/removing observers during observer iteration through
+  // base::ObserverList. We also prevent observers that are added during
+  // observer iteration from receiving a MISSED BeginFrame by means of
+  // |in_on_vsync_| - they will receive the current NORMAL one during the
+  // iteration instead. Note that SynchronousCompositorBrowserFilter relies on
+  // this behavior.
+  // TODO(eseckler): Remove SynchronousCompositorBrowserFilter's dependency on
+  // this and replace observers_ by a std::unordered_set, iterate on a copy.
+  base::AutoReset<bool> auto_reset(&in_on_vsync_, true);
+  std::unordered_set<cc::BeginFrameObserver*> notified_observers;
+  for (auto& obs : observers_) {
+    // An observer may remove and add itself during a single OnBeginFrame, in
+    // which case it'd appear twice during the iteration. To deal with this, we
+    // keep track of whether we already notified it.
+    if (!base::ContainsKey(notified_observers, &obs)) {
+      obs.OnBeginFrame(last_begin_frame_args_);
+      notified_observers.insert(&obs);
+    }
+  }
+}
+
 WindowAndroid::WindowAndroid(JNIEnv* env, jobject obj, int display_id)
-    : display_id_(display_id), compositor_(NULL) {
+    : display_id_(display_id),
+      compositor_(NULL),
+      begin_frame_source_(new WindowBeginFrameSource(this)),
+      needs_begin_frames_(false) {
   java_window_.Reset(env, obj);
 }
 
@@ -69,6 +175,10 @@ void WindowAndroid::RemoveObserver(WindowAndroidObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
+cc::BeginFrameSource* WindowAndroid::GetBeginFrameSource() {
+  return begin_frame_source_.get();
+}
+
 void WindowAndroid::AttachCompositor(WindowAndroidCompositor* compositor) {
   if (compositor_ && compositor != compositor_)
     DetachCompositor();
@@ -90,6 +200,15 @@ void WindowAndroid::RequestVSyncUpdate() {
   Java_WindowAndroid_requestVSyncUpdate(env, GetJavaObject());
 }
 
+void WindowAndroid::SetNeedsBeginFrames(bool needs_begin_frames) {
+  if (needs_begin_frames_ == needs_begin_frames)
+    return;
+
+  needs_begin_frames_ = needs_begin_frames;
+  if (needs_begin_frames_)
+    RequestVSyncUpdate();
+}
+
 void WindowAndroid::SetNeedsAnimate() {
   if (compositor_)
     compositor_->SetNeedsAnimate();
@@ -107,10 +226,9 @@ void WindowAndroid::OnVSync(JNIEnv* env,
   base::TimeTicks frame_time(base::TimeTicks::FromInternalValue(time_micros));
   base::TimeDelta vsync_period(
       base::TimeDelta::FromMicroseconds(period_micros));
-  for (WindowAndroidObserver& observer : observer_list_)
-    observer.OnVSync(frame_time, vsync_period);
-  if (compositor_)
-    compositor_->OnVSync(frame_time, vsync_period);
+  begin_frame_source_->OnVSync(frame_time, vsync_period);
+  if (needs_begin_frames_)
+    RequestVSyncUpdate();
 }
 
 void WindowAndroid::OnVisibilityChanged(JNIEnv* env,

ui/android/window_android.h

@@ -6,6 +6,7 @@
 #define UI_ANDROID_WINDOW_ANDROID_H_
 
 #include <jni.h>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -18,9 +19,13 @@
 #include "ui/android/view_android.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
+namespace cc {
+class BeginFrameSource;
+}  // namespace cc
+
 namespace display {
 class DisplayAndroidManager;
-}
+}  // namespace display
 
 namespace ui {
 
@@ -59,8 +64,8 @@ class UI_ANDROID_EXPORT WindowAndroid : public ViewAndroid {
   void RemoveObserver(WindowAndroidObserver* observer);
 
   WindowAndroidCompositor* GetCompositor() { return compositor_; }
+  cc::BeginFrameSource* GetBeginFrameSource();
 
-  void RequestVSyncUpdate();
   void SetNeedsAnimate();
   void Animate(base::TimeTicks begin_frame_time);
   void OnVSync(JNIEnv* env,
@@ -86,10 +91,15 @@ class UI_ANDROID_EXPORT WindowAndroid : public ViewAndroid {
   void DestroyForTesting();
 
  private:
+  class WindowBeginFrameSource;
   friend class DisplayAndroidManager;
+  friend class WindowBeginFrameSource;
 
   ~WindowAndroid() override;
 
+  void SetNeedsBeginFrames(bool needs_begin_frames);
+  void RequestVSyncUpdate();
+
   // ViewAndroid overrides.
   WindowAndroid* GetWindowAndroid() const override;
 
@@ -103,6 +113,9 @@ class UI_ANDROID_EXPORT WindowAndroid : public ViewAndroid {
 
   base::ObserverList<WindowAndroidObserver> observer_list_;
 
+  std::unique_ptr<WindowBeginFrameSource> begin_frame_source_;
+  bool needs_begin_frames_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowAndroid);
 };
 

ui/android/window_android_compositor.h

@@ -27,8 +27,6 @@ class UI_ANDROID_EXPORT WindowAndroidCompositor {
   virtual void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) = 0;
   virtual void RequestCopyOfOutputOnRootLayer(
       std::unique_ptr<cc::CopyOutputRequest> request) = 0;
-  virtual void OnVSync(base::TimeTicks frame_time,
-                       base::TimeDelta vsync_period) = 0;
   virtual void SetNeedsAnimate() = 0;
   virtual ResourceManager& GetResourceManager() = 0;
   virtual cc::FrameSinkId GetFrameSinkId() = 0;

ui/android/window_android_observer.h

@@ -15,8 +15,6 @@ class UI_ANDROID_EXPORT WindowAndroidObserver {
   virtual void OnRootWindowVisibilityChanged(bool visible) = 0;
   virtual void OnAttachCompositor() = 0;
   virtual void OnDetachCompositor() = 0;
-  virtual void OnVSync(base::TimeTicks frame_time,
-                       base::TimeDelta vsync_period) = 0;
   virtual void OnAnimate(base::TimeTicks frame_begin_time) {}
 
   // Note that activity state callbacks will only be made if the WindowAndroid