cc: Introduce BeginFrame sequence numbers and acknowledgements.

content/browser/android/synchronous_compositor_browser_filter.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/android/synchronous_compositor_browser_filter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 27 matching lines @@
   DCHECK(!window_android_in_vsync_ ||
          window_android_in_vsync_ == window_android)
       << !!window_android_in_vsync_;
   DCHECK(compositor_host);
   DCHECK(!base::ContainsValue(compositor_host_pending_renderer_state_,
                               compositor_host));
   compositor_host_pending_renderer_state_.push_back(compositor_host);
   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(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorBrowserFilter, message)
     IPC_MESSAGE_HANDLER_GENERIC(SyncCompositorHostMsg_ReturnFrame,
                                 ReceiveFrame(message))
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 111 matching lines @@
   base::AutoLock lock(future_map_lock_);
   for (auto& pair : future_map_) {
     for (auto& future_ptr : pair.second) {
       future_ptr->SetFrame(nullptr);
     }
   }
   future_map_.clear();
   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;
   routing_ids.reserve(compositor_host_pending_renderer_state_.size());
   for (const auto host : compositor_host_pending_renderer_state_)
     routing_ids.push_back(host->routing_id());
 
   std::vector<SyncCompositorCommonRendererParams> params;
   params.reserve(compositor_host_pending_renderer_state_.size());
 
   if (!render_process_host_->Send(
           new SyncCompositorMsg_SynchronizeRendererState(routing_ids,
                                                          &params))) {
     return;
   }
 
   if (compositor_host_pending_renderer_state_.size() != params.size()) {
     bad_message::ReceivedBadMessage(render_process_host_,
                                     bad_message::SCO_INVALID_ARGUMENT);
     return;
   }
 
   for (size_t i = 0; i < compositor_host_pending_renderer_state_.size(); ++i) {
     compositor_host_pending_renderer_state_[i]->ProcessCommonParams(params[i]);
   }
   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();
+
+  static cc::BeginFrameArgs args;
+  return args;
 }
 
-void SynchronousCompositorBrowserFilter::OnActivityStarted() {
-  NOTREACHED();
+void SynchronousCompositorBrowserFilter::OnBeginFrameSourcePausedChanged(
+    bool paused) {
+  // The BeginFrameSources we listen to don't use this.
+  DCHECK(!paused);
 }
 
 }  // namespace content