cc: Implement unified BeginFrame on aura

content/browser/compositor/delegated_frame_host.cc

Index: content/browser/compositor/delegated_frame_host.cc
diff --git a/content/browser/compositor/delegated_frame_host.cc b/content/browser/compositor/delegated_frame_host.cc
index 20752a87b12b5b1c96332e512ea9e8329d96bbcc..0b0a603b79513eab22aec1e39fe9570b2af1735a 100644
--- a/content/browser/compositor/delegated_frame_host.cc
+++ b/content/browser/compositor/delegated_frame_host.cc
@@ -6,6 +6,8 @@
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
+#include "cc/base/switches.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
@@ -17,6 +19,7 @@
 #include "content/browser/compositor/resize_lock.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/common/gpu/client/gl_helper.h"
+#include "content/common/view_messages.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/video_frame.h"
@@ -85,8 +88,13 @@ DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
       skipped_frames_(false),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
-      delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
+      delegated_frame_evictor_(new DelegatedFrameEvictor(this)),
+      begin_frame_scheduling_enabled_(false),
+      needs_begin_frames_(false) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
+  begin_frame_scheduling_enabled_ =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          cc::switches::kEnableBeginFrameScheduling);
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
@@ -865,6 +873,26 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
                                      finished_callback);
 }
 
+void DelegatedFrameHost::OnSetNeedsBeginFrames(bool needs_begin_frames) {
+  DCHECK(begin_frame_scheduling_enabled_);
+  DCHECK(client_->GetCompositor());
+
+  if (needs_begin_frames_ == needs_begin_frames)
+    return;
+
+  TRACE_EVENT1("cc",
+               "DelegatedFrameHost::OnSetNeedsBeginFrames",
+               "needs_begin_frames",
+               needs_begin_frames);
+
+  needs_begin_frames_ = needs_begin_frames;
+
+  if (needs_begin_frames)
+    StartObservingBeginFrames();
+  else
+    StopObservingBeginFrames();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::CompositorObserver implementation:
 
@@ -909,11 +937,29 @@ void DelegatedFrameHost::OnCompositingLockStateChanged(
   }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// ui::CompositorBeginFrameObserver implementation.
+void DelegatedFrameHost::OnSendBeginFrame(
+    const cc::BeginFrameArgs& args) {
+  DCHECK(begin_frame_scheduling_enabled_);
+
+  TRACE_EVENT0("cc", "DelegatedFrameHost::OnSendBeginFrame");
+  RenderWidgetHostImpl* host = client_->GetHost();
+  DCHECK(host);
+  host->Send(new ViewMsg_BeginFrame(host->GetRoutingID(), args));
+  last_begin_frame_args_ = args;
+  SetVSyncParams(args.frame_time, args.interval);
+  vsync_timebase_ = args.frame_time;
+  vsync_interval_ = args.interval;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ui::CompositorVSyncManager::Observer implementation.
 void DelegatedFrameHost::OnUpdateVSyncParameters(
     base::TimeTicks timebase,
     base::TimeDelta interval) {
-  vsync_timebase_ = timebase;
-  vsync_interval_ = interval;
+  DCHECK(!begin_frame_scheduling_enabled_);
+  SetVSyncParams(timebase, interval);
   RenderWidgetHostImpl* host = client_->GetHost();
   if (client_->IsVisible())
     host->UpdateVSyncParameters(timebase, interval);
@@ -969,6 +1015,14 @@ void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
 }
 
 void DelegatedFrameHost::AddedToWindow() {
+  // When |begin_frame_scheduling_enabled_| is true, vsync parameter is not used
+  // in renderer.
+  if (begin_frame_scheduling_enabled_) {
+    if (needs_begin_frames_)
+      StartObservingBeginFrames();
+    return;
+  }
+
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor) {
     DCHECK(!vsync_manager_.get());
@@ -985,6 +1039,13 @@ void DelegatedFrameHost::RemovingFromWindow() {
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
 
+  if (begin_frame_scheduling_enabled_) {
+    DCHECK(!vsync_manager_) << "Not used with unifed BeginFrame";
+    if (needs_begin_frames_)
+      StopObservingBeginFrames();
+    return;
+  }
+
   if (vsync_manager_.get()) {
     vsync_manager_->RemoveObserver(this);
     vsync_manager_ = NULL;
@@ -1001,6 +1062,28 @@ void DelegatedFrameHost::UnlockResources() {
   delegated_frame_evictor_->UnlockFrame();
 }
 
+void DelegatedFrameHost::StartObservingBeginFrames() {
+  DCHECK(begin_frame_scheduling_enabled_);
+  DCHECK(client_->GetCompositor());
+  DCHECK(!client_->GetCompositor()->HasBeginFrameObserver(this));
+
+  client_->GetCompositor()->AddBeginFrameObserver(this, last_begin_frame_args_);
+}
+
+void DelegatedFrameHost::StopObservingBeginFrames() {
+  DCHECK(begin_frame_scheduling_enabled_);
+  DCHECK(client_->GetCompositor());
+  DCHECK(client_->GetCompositor()->HasBeginFrameObserver(this));
+
+  client_->GetCompositor()->RemoveBeginFrameObserver(this);
+}
+
+void DelegatedFrameHost::SetVSyncParams(base::TimeTicks timebase,
+                                        base::TimeDelta interval) {
+  vsync_timebase_ = timebase;
+  vsync_interval_ = interval;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::LayerOwnerDelegate implementation: