Hook up ui::Compositor to Display's BeginFrameSource

cc/surfaces/display.cc

Index: cc/surfaces/display.cc
diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index 6866cedc9cf27654d5e0ebcee75cbda329dae739..76b019b7d1a0883096609f7764d657901a9ede1d 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -32,22 +32,27 @@ Display::Display(DisplayClient* client,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                  const RendererSettings& settings)
     : client_(client),
-      manager_(manager),
+      surface_manager_(manager),
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
       device_scale_factor_(1.f),
       swapped_since_resize_(false),
-      scheduler_(nullptr),
+      vsync_begin_frame_source_(nullptr),
+      scheduler_begin_frame_source_(nullptr),
       texture_mailbox_deleter_(new TextureMailboxDeleter(nullptr)) {
-  manager_->AddObserver(this);
+  surface_manager_->AddObserver(this);
 }
 
 Display::~Display() {
-  manager_->RemoveObserver(this);
+  if (scheduler_begin_frame_source_) {
+    surface_manager_->RegisterBeginFrameSource(
+        nullptr, current_surface_id_.id_namespace());
+  }
+  surface_manager_->RemoveObserver(this);
   if (aggregator_) {
     for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
-      Surface* surface = manager_->GetSurfaceForId(id_entry.first);
+      Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
       if (surface)
         surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
     }
@@ -55,11 +60,15 @@ Display::~Display() {
 }
 
 bool Display::Initialize(scoped_ptr<OutputSurface> output_surface,
-                         DisplayScheduler* scheduler) {
-  // TODO(enne): register/unregister BeginFrameSource with SurfaceManager here.
+                         base::SingleThreadTaskRunner* task_runner) {
   output_surface_ = std::move(output_surface);
-  scheduler_ = scheduler;
-  return output_surface_->BindToClient(this);
+  if (!output_surface_->BindToClient(this))
+    return false;
+  DCHECK(vsync_begin_frame_source_);

[no sievers, 2016/03/25 18:55:08]

Then it looks like OutputSurfaceWithoutParent in compositor_impl_android.cc has
to call SetBeginFrameSource().

That's great actually since it already has ExternalBeginFrameSource there (for
the browser compositor, passed through
LayerTreeSettings.external_begin_frame_source) while awkwardly it looks like the
on screen display was using CommitVSyncParameters() with the synthetic one. Now
they can use the same, right?

+  scheduler_.reset(
+      new DisplayScheduler(this, vsync_begin_frame_source_, task_runner,
+                           output_surface_->capabilities().max_frames_pending));
+  return true;
 }
 
 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
@@ -67,13 +76,20 @@ void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
     return;
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
-
+  SurfaceId previous_id = current_surface_id_;
   current_surface_id_ = id;
   device_scale_factor_ = device_scale_factor;
 
   UpdateRootSurfaceResourcesLocked();
   if (scheduler_)
     scheduler_->SetNewRootSurface(id);
+
+  if (scheduler_begin_frame_source_ && previous_id != current_surface_id_) {
+    surface_manager_->RegisterBeginFrameSource(nullptr,
+                                               previous_id.id_namespace());
+    surface_manager_->RegisterBeginFrameSource(
+        scheduler_begin_frame_source_, current_surface_id_.id_namespace());
+  }
 }
 
 void Display::Resize(const gfx::Size& size) {
@@ -135,8 +151,8 @@ void Display::InitializeRenderer() {
   // overlays.
   bool output_partial_list = renderer_->Capabilities().using_partial_swap &&
                              !output_surface_->GetOverlayCandidateValidator();
-  aggregator_.reset(new SurfaceAggregator(manager_, resource_provider_.get(),
-                                          output_partial_list));
+  aggregator_.reset(new SurfaceAggregator(
+      surface_manager_, resource_provider_.get(), output_partial_list));
 }
 
 void Display::DidLoseOutputSurface() {
@@ -148,7 +164,7 @@ void Display::DidLoseOutputSurface() {
 }
 
 void Display::UpdateRootSurfaceResourcesLocked() {
-  Surface* surface = manager_->GetSurfaceForId(current_surface_id_);
+  Surface* surface = surface_manager_->GetSurfaceForId(current_surface_id_);
   bool root_surface_resources_locked = !surface || !surface->GetEligibleFrame();
   if (scheduler_)
     scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked);
@@ -178,7 +194,7 @@ bool Display::DrawAndSwap() {
 
   // Run callbacks early to allow pipelining.
   for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
-    Surface* surface = manager_->GetSurfaceForId(id_entry.first);
+    Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
     if (surface)
       surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN);
   }
@@ -264,6 +280,21 @@ bool Display::DrawAndSwap() {
   return true;
 }
 
+void Display::UpdateSchedulerBeginFrameSource(BeginFrameSource* source) {
+  if (source == scheduler_begin_frame_source_)
+    return;
+
+  if (scheduler_begin_frame_source_) {
+    surface_manager_->RegisterBeginFrameSource(
+        nullptr, current_surface_id_.id_namespace());
+  }
+  scheduler_begin_frame_source_ = source;
+  if (scheduler_begin_frame_source_) {
+    surface_manager_->RegisterBeginFrameSource(
+        scheduler_begin_frame_source_, current_surface_id_.id_namespace());
+  }
+}
+
 void Display::DidSwapBuffers() {
   if (scheduler_)
     scheduler_->DidSwapBuffers();
@@ -276,9 +307,15 @@ void Display::DidSwapBuffersComplete() {
     renderer_->SwapBuffersComplete();
 }
 
-void Display::CommitVSyncParameters(base::TimeTicks timebase,
-                                    base::TimeDelta interval) {
-  client_->CommitVSyncParameters(timebase, interval);
+void Display::SetBeginFrameSource(BeginFrameSource* source) {
+  // It's expected that there's only a single source from the

[enne (OOO), 2016/03/25 17:55:36]

I feel like this comment explains what has to happen here.

I do think this is a bit of an awkward variable push in the middle of
BindToClient where a pull would make more sense since it can only happen once. 
It does the trick, though.

+  // BrowserCompositorOutputSurface that corresponds to vsync.  The BFS is
+  // passed BrowserCompositorOutputSurface -> Display -> DisplayScheduler as an
+  // input.  DisplayScheduler makes a decision about which BFS to use and
+  // calls back to Display as DisplaySchedulerClient to register for that
+  // surface id.
+  DCHECK(!vsync_begin_frame_source_);
+  vsync_begin_frame_source_ = source;
 }
 
 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
@@ -320,7 +357,7 @@ void Display::SetFullRootLayerDamage() {
 void Display::OnSurfaceDamaged(SurfaceId surface_id, bool* changed) {
   if (aggregator_ &&
       aggregator_->previous_contained_surfaces().count(surface_id)) {
-    Surface* surface = manager_->GetSurfaceForId(surface_id);
+    Surface* surface = surface_manager_->GetSurfaceForId(surface_id);
     if (surface) {
       const CompositorFrame* current_frame = surface->GetEligibleFrame();
       if (!current_frame || !current_frame->delegated_frame_data ||