Get rid of virtual Display::CreateScheduler.

cc/surfaces/display.cc

Index: cc/surfaces/display.cc
diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index 1619092afda73a44963b0b8cec69cd1d8264bcb2..88a517703ea8fb12e6ac268b43917b134f235511 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -15,6 +15,7 @@
 #include "cc/output/gl_renderer.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_renderer.h"
+#include "cc/output/texture_mailbox_deleter.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
@@ -27,18 +28,6 @@
 #include "cc/output/vulkan_renderer.h"
 #endif
 
-namespace {
-
-class EmptyBeginFrameSource : public cc::BeginFrameSource {
- public:
-  void DidFinishFrame(cc::BeginFrameObserver* obs,
-                      size_t remaining_frames) override{};
-  void AddObserver(cc::BeginFrameObserver* obs) override{};
-  void RemoveObserver(cc::BeginFrameObserver* obs) override{};
-};
-
-}  // namespace
-
 namespace cc {
 
 Display::Display(SurfaceManager* manager,
@@ -46,71 +35,75 @@ Display::Display(SurfaceManager* manager,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                  const RendererSettings& settings,
                  uint32_t compositor_surface_namespace,
-                 base::SingleThreadTaskRunner* task_runner,
-                 std::unique_ptr<OutputSurface> output_surface)
+                 std::unique_ptr<BeginFrameSource> begin_frame_source,
+                 std::unique_ptr<OutputSurface> output_surface,
+                 std::unique_ptr<DisplayScheduler> scheduler,
+                 std::unique_ptr<TextureMailboxDeleter> texture_mailbox_deleter)
     : surface_manager_(manager),
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
       compositor_surface_namespace_(compositor_surface_namespace),
-      task_runner_(task_runner),
+      begin_frame_source_(std::move(begin_frame_source)),
       output_surface_(std::move(output_surface)),
-      texture_mailbox_deleter_(task_runner) {
-  surface_manager_->AddObserver(this);
-}
+      scheduler_(std::move(scheduler)),
+      texture_mailbox_deleter_(std::move(texture_mailbox_deleter)) {
+  DCHECK(output_surface_);
+  DCHECK(texture_mailbox_deleter_);
+  // If there's a DisplayScheduler, it will have a BeginFrameSource and we
+  // should know about it here.
+  DCHECK(!scheduler_ || begin_frame_source_);
 
-Display::~Display() {
-  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 = surface_manager_->GetSurfaceForId(id_entry.first);
-      if (surface)
-        surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
-    }
-  }
-}
+  surface_manager_->AddObserver(this);
 
-void Display::CreateScheduler() {
-  DCHECK(!scheduler_);
-  if (!task_runner_) {
+  /*
+  if (!task_runner) {
+    DCHECK(!begin_frame_source);
     // WebView doesn't have a task runner or a real begin frame source,
     // so just create something fake here.
     internal_begin_frame_source_.reset(new EmptyBeginFrameSource());
     vsync_begin_frame_source_ = internal_begin_frame_source_.get();
     observed_begin_frame_source_ = vsync_begin_frame_source_;
   } else {
-    DCHECK(vsync_begin_frame_source_);
-
+    DCHECK(begin_frame_source);
+    vsync_begin_frame_source_ = begin_frame_source;
     observed_begin_frame_source_ = vsync_begin_frame_source_;
     if (settings_.disable_display_vsync) {
       internal_begin_frame_source_.reset(
-          new BackToBackBeginFrameSource(task_runner_));
+          new BackToBackBeginFrameSource(task_runner));

[jbauman, 2016/06/03 02:34:27]

Where is this code to create a BackToBackBeginFrameSource going to live?

[danakj, 2016/06/03 17:26:31]

Oh I forgot this, it needs to be added to GpuProcessTransformFactory.

       observed_begin_frame_source_ = internal_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_);
+  if (scheduler_)
+    scheduler_->SetClient(this);
+  // scheduler_.reset(new DisplayScheduler(
+  //    this, observed_begin_frame_source_, task_runner,
+  //    output_surface_->capabilities().max_frames_pending));
+  if (begin_frame_source_) {
+    surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
+                                               compositor_surface_namespace_);
+  }
 }
 
-bool Display::Initialize(DisplayClient* client) {
-  client_ = client;
-  if (!output_surface_->BindToClient(this))
-    return false;
-  CreateScheduler();
-  return true;
+Display::~Display() {
+  if (begin_frame_source_)
+    surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
+  surface_manager_->RemoveObserver(this);
+  if (aggregator_) {
+    for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
+      Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
+      if (surface)
+        surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
+    }
+  }
 }
 
-bool Display::InitializeSynchronous(DisplayClient* client) {
+bool Display::Initialize(DisplayClient* client) {
   client_ = client;
   if (!output_surface_->BindToClient(this))
     return false;
-  // No scheduler created here.
   return true;
 }
 
@@ -182,7 +175,7 @@ void Display::InitializeRenderer() {
   if (output_surface_->context_provider()) {
     std::unique_ptr<GLRenderer> renderer = GLRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
-        &texture_mailbox_deleter_, settings_.highp_threshold_min);
+        texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
@@ -190,7 +183,7 @@ void Display::InitializeRenderer() {
 #if defined(ENABLE_VULKAN)
     std::unique_ptr<VulkanRenderer> renderer = VulkanRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
-        &texture_mailbox_deleter_, settings_.highp_threshold_min);
+        texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
@@ -354,15 +347,16 @@ void Display::DidSwapBuffersComplete() {
     renderer_->SwapBuffersComplete();
 }
 
+void Display::CommitVSyncParameters(base::TimeTicks timebase,
+                                    base::TimeDelta interval) {
+  // Display uses a BeginFrameSource instead.
+  NOTREACHED();
+}
+
 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;
+  // The BeginFrameSource is set from the constructor, it doesn't come
+  // from the OutputSurface for the Display.
+  NOTREACHED();
 }
 
 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {