Hook up ui::Compositor to Display's BeginFrameSource

cc/surfaces/display.cc

 // Copyright 2014 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 "cc/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 12 matching lines @@
 #include "cc/surfaces/surface_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/buffer_types.h"
 
 namespace cc {
 
 Display::Display(DisplayClient* client,
                  SurfaceManager* manager,
                  SharedBitmapManager* bitmap_manager,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-                 const RendererSettings& settings)
+                 const RendererSettings& settings,
+                 uint32_t compositor_surface_namespace)
     : client_(client),
-      manager_(manager),
+      surface_manager_(manager),
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
+      compositor_surface_namespace_(compositor_surface_namespace),
       device_scale_factor_(1.f),
       swapped_since_resize_(false),
-      scheduler_(nullptr),
+      vsync_begin_frame_source_(nullptr),
+      observed_begin_frame_source_(nullptr),
       texture_mailbox_deleter_(new TextureMailboxDeleter(nullptr)) {
-  manager_->AddObserver(this);
+  surface_manager_->AddObserver(this);
 }
 
 Display::~Display() {
-  manager_->RemoveObserver(this);
+  if (observed_begin_frame_source_)
+    surface_manager_->UnregisterBeginFrameSource(observed_begin_frame_source_);
+  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);
     }
   }
 }
 
-bool Display::Initialize(scoped_ptr<OutputSurface> output_surface,
-                         DisplayScheduler* scheduler) {
-  // TODO(enne): register/unregister BeginFrameSource with SurfaceManager here.
+void Display::CreateScheduler() {
+  DCHECK(!scheduler_);
+  DCHECK(vsync_begin_frame_source_);
+
+  base::SingleThreadTaskRunner* task_runner =
+      base::ThreadTaskRunnerHandle::Get().get();
+
+  observed_begin_frame_source_ = vsync_begin_frame_source_;
+  if (settings_.disable_display_vsync) {
+    unthrottled_begin_frame_source_.reset(
+        new BackToBackBeginFrameSource(task_runner));
+    observed_begin_frame_source_ = unthrottled_begin_frame_source_.get();
+  }
+
+  scheduler_.reset(
+      new DisplayScheduler(this, observed_begin_frame_source_, task_runner,
+                           output_surface_->capabilities().max_frames_pending));
+  surface_manager_->RegisterBeginFrameSource(observed_begin_frame_source_,
+                                             compositor_surface_namespace_);
+}
+
+bool Display::Initialize(scoped_ptr<OutputSurface> output_surface) {
   output_surface_ = std::move(output_surface);
-  scheduler_ = scheduler;
-  return output_surface_->BindToClient(this);
+  if (!output_surface_->BindToClient(this))
+    return false;
+  CreateScheduler();
+  return true;
 }
 
 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
+  DCHECK_EQ(id.id_namespace(), compositor_surface_namespace_);
   if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
     return;
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
-
   current_surface_id_ = id;
   device_scale_factor_ = device_scale_factor;
 
   UpdateRootSurfaceResourcesLocked();
   if (scheduler_)
     scheduler_->SetNewRootSurface(id);
 }
 
 void Display::Resize(const gfx::Size& size) {
   if (size == current_surface_size_)
@@ skipping 47 matching lines @@
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
   }
 
   resource_provider_ = std::move(resource_provider);
   // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
   // 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() {
   if (scheduler_)
     scheduler_->OutputSurfaceLost();
   // WARNING: The client may delete the Display in this method call. Do not
   // make any additional references to members after this call.
   client_->OutputSurfaceLost();
 }
 
 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);
 }
 
 bool Display::DrawAndSwap() {
   TRACE_EVENT0("cc", "Display::DrawAndSwap");
 
   if (current_surface_id_.is_null()) {
     TRACE_EVENT_INSTANT0("cc", "No root surface.", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   InitializeRenderer();
   if (!output_surface_) {
     TRACE_EVENT_INSTANT0("cc", "No output surface", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   scoped_ptr<CompositorFrame> frame =
       aggregator_->Aggregate(current_surface_id_);
   if (!frame) {
     TRACE_EVENT_INSTANT0("cc", "Empty aggregated frame.",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // 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);
   }
 
   DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 
   frame->metadata.latency_info.insert(frame->metadata.latency_info.end(),
                                       stored_latency_info_.begin(),
                                       stored_latency_info_.end());
   stored_latency_info_.clear();
@@ skipping 77 matching lines @@
     scheduler_->DidSwapBuffers();
 }
 
 void Display::DidSwapBuffersComplete() {
   if (scheduler_)
     scheduler_->DidSwapBuffersComplete();
   if (renderer_)
     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
+  // 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) {
   client_->SetMemoryPolicy(policy);
 }
 
 void Display::OnDraw(const gfx::Transform& transform,
                      const gfx::Rect& viewport,
                      const gfx::Rect& clip,
                      bool resourceless_software_draw) {
@@ skipping 21 matching lines @@
 }
 
 void Display::SetFullRootLayerDamage() {
   if (aggregator_ && !current_surface_id_.is_null())
     aggregator_->SetFullDamageForSurface(current_surface_id_);
 }
 
 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 ||
           !current_frame->delegated_frame_data->resource_list.size()) {
         aggregator_->ReleaseResources(surface_id);
       }
     }
     if (scheduler_)
       scheduler_->SurfaceDamaged(surface_id);
     *changed = true;
   } else if (surface_id == current_surface_id_) {
     if (scheduler_)
       scheduler_->SurfaceDamaged(surface_id);
     *changed = true;
   }
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc