Get rid of virtual Display::CreateScheduler.

ui/compositor/test/in_process_context_factory.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 "ui/compositor/test/in_process_context_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
+#include "cc/output/texture_mailbox_deleter.h"
+#include "cc/scheduler/begin_frame_source.h"
+#include "cc/surfaces/display.h"
+#include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/reflector.h"
@@ skipping 12 matching lines @@
   void AddMirroringLayer(Layer* layer) override {}
   void RemoveMirroringLayer(Layer* layer) override {}
 };
 
 // An OutputSurface implementation that directly draws and swaps to an actual
 // GL surface.
 class DirectOutputSurface : public cc::OutputSurface {
  public:
   DirectOutputSurface(
       const scoped_refptr<cc::ContextProvider>& context_provider,
-      const scoped_refptr<cc::ContextProvider>& worker_context_provider,
-      std::unique_ptr<cc::BeginFrameSource> begin_frame_source)
+      const scoped_refptr<cc::ContextProvider>& worker_context_provider)
       : cc::OutputSurface(context_provider, worker_context_provider, nullptr),
-        begin_frame_source_(std::move(begin_frame_source)),
         weak_ptr_factory_(this) {}
 
   ~DirectOutputSurface() override {}
 
   // cc::OutputSurface implementation
   bool BindToClient(cc::OutputSurfaceClient* client) override {
     if (!OutputSurface::BindToClient(client))
       return false;
-
-    client->SetBeginFrameSource(begin_frame_source_.get());
     return true;
   }
   void SwapBuffers(cc::CompositorFrame* frame) override {
     DCHECK(context_provider_.get());
     DCHECK(frame->gl_frame_data);
     if (frame->gl_frame_data->sub_buffer_rect ==
         gfx::Rect(frame->gl_frame_data->size)) {
       context_provider_->ContextSupport()->Swap();
     } else {
       context_provider_->ContextSupport()->PartialSwapBuffers(
           frame->gl_frame_data->sub_buffer_rect);
     }
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
     gl->ShallowFlushCHROMIUM();
 
     gpu::SyncToken sync_token;
     gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
     context_provider_->ContextSupport()->SignalSyncToken(
         sync_token, base::Bind(&OutputSurface::OnSwapBuffersComplete,
                                weak_ptr_factory_.GetWeakPtr()));
     client_->DidSwapBuffers();
   }
 
  private:
-  std::unique_ptr<cc::BeginFrameSource> begin_frame_source_;
-
   base::WeakPtrFactory<DirectOutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectOutputSurface);
 };
 
 }  // namespace
 
 InProcessContextFactory::InProcessContextFactory(
     bool context_factory_for_test,
     cc::SurfaceManager* surface_manager)
@@ skipping 41 matching lines @@
   attribs.sample_buffers = 0;
   attribs.fail_if_major_perf_caveat = false;
   attribs.bind_generates_resource = false;
   scoped_refptr<InProcessContextProvider> context_provider =
       InProcessContextProvider::Create(
           attribs, shared_worker_context_provider_.get(),
           &gpu_memory_buffer_manager_, &image_factory_, compositor->widget(),
           "UICompositor");
 
   std::unique_ptr<cc::OutputSurface> display_output_surface;
-  std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
-      new cc::SyntheticBeginFrameSource(compositor->task_runner().get(),
-                                        cc::BeginFrameArgs::DefaultInterval()));
-
   if (use_test_surface_) {
     bool flipped_output_surface = false;
     display_output_surface = base::WrapUnique(new cc::PixelTestOutputSurface(
         context_provider, shared_worker_context_provider_,
-        flipped_output_surface, std::move(begin_frame_source)));
+        flipped_output_surface));
   } else {
     display_output_surface = base::WrapUnique(new DirectOutputSurface(
-        context_provider, shared_worker_context_provider_,
-        std::move(begin_frame_source)));
+        context_provider, shared_worker_context_provider_));
   }
 
   if (surface_manager_) {
-    std::unique_ptr<cc::Display> display(new cc::Display(
+    std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
+        new cc::SyntheticBeginFrameSource(
+            compositor->task_runner().get(),
+            cc::BeginFrameArgs::DefaultInterval()));
+    std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
+        begin_frame_source.get(), compositor->task_runner().get(),
+        display_output_surface->capabilities().max_frames_pending));
+    per_compositor_data_[compositor.get()] = base::MakeUnique<cc::Display>(
         surface_manager_, GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
         compositor->GetRendererSettings(),
         compositor->surface_id_allocator()->id_namespace(),
-        compositor->task_runner().get(), std::move(display_output_surface)));
+        std::move(begin_frame_source), std::move(display_output_surface),
+        std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>(
+                                  compositor->task_runner().get()));
+
+    auto* display = per_compositor_data_[compositor.get()].get();
     std::unique_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
         new cc::SurfaceDisplayOutputSurface(
-            surface_manager_, compositor->surface_id_allocator(), display.get(),
+            surface_manager_, compositor->surface_id_allocator(), display,
             context_provider, shared_worker_context_provider_));
-
     compositor->SetOutputSurface(std::move(surface_output_surface));
-
-    per_compositor_data_[compositor.get()] = std::move(display);
   } else {
     compositor->SetOutputSurface(std::move(display_output_surface));
   }
 }
 
 std::unique_ptr<Reflector> InProcessContextFactory::CreateReflector(
     Compositor* mirrored_compositor,
     Layer* mirroring_layer) {
   return base::WrapUnique(new FakeReflector);
 }
@@ skipping 60 matching lines @@
 }
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
   if (!per_compositor_data_.count(compositor))
     return;
   per_compositor_data_[compositor]->Resize(size);
 }
 
 }  // namespace ui