Get rid of virtual Display::CreateScheduler.

cc/surfaces/display_unittest.cc

 // Copyright 2015 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 <utility>
 
 #include "base/test/null_task_runner.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/resources/shared_bitmap_manager.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 27 matching lines @@
   gfx::Rect damage_rect() const { return damage_rect_; }
   gfx::Size viewport_pixel_size() const { return viewport_pixel_size_; }
 };
 
 class DisplayTest : public testing::Test {
  public:
   DisplayTest()
       : factory_(&manager_, &surface_factory_client_),
         id_allocator_(kArbitrarySurfaceNamespace),
         software_output_device_(nullptr),
-        task_runner_(new base::NullTaskRunner) {
+        task_runner_(new base::NullTaskRunner),
+        begin_frame_source_(task_runner_.get()) {
     id_allocator_.RegisterSurfaceIdNamespace(&manager_);
   }
 
  protected:
   void SetUpContext(std::unique_ptr<TestWebGraphicsContext3D> context) {
     if (context) {
       output_surface_ = FakeOutputSurface::Create3d(
           TestContextProvider::Create(std::move(context)));
     } else {
       std::unique_ptr<TestSoftwareOutputDevice> output_device(
@@ skipping 20 matching lines @@
   enum { kArbitrarySurfaceNamespace = 3 };
 
   SurfaceManager manager_;
   FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
   SurfaceIdAllocator id_allocator_;
   TestSoftwareOutputDevice* software_output_device_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   FakeOutputSurface* output_surface_ptr_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
+  BackToBackBeginFrameSource begin_frame_source_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
 };
 
 class StubDisplayClient : public DisplayClient {
  public:
   void DisplayOutputSurfaceLost() override {}
   void DisplaySetMemoryPolicy(const ManagedMemoryPolicy& policy) override {}
 };
 
 class TestDisplayScheduler : public DisplayScheduler {
@@ skipping 38 matching lines @@
 };
 
 class TestDisplay : public Display {
  public:
   TestDisplay(SurfaceManager* manager,
               SharedBitmapManager* bitmap_manager,
               gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
               const RendererSettings& settings,
               uint32_t compositor_surface_namespace,
               base::SingleThreadTaskRunner* task_runner,
+              BeginFrameSource* begin_frame_source,
               std::unique_ptr<OutputSurface> output_surface)
       : Display(manager,
                 bitmap_manager,
                 gpu_memory_buffer_manager,
                 settings,
                 compositor_surface_namespace,
                 task_runner,
-                std::move(output_surface)),
-        task_runner_(task_runner) {}
+                begin_frame_source,
+                std::move(output_surface),
+                base::MakeUnique<TestDisplayScheduler>(this,
+                                                       begin_frame_source,
+                                                       task_runner)) {}
 
   TestDisplayScheduler& scheduler() {
-    return *static_cast<TestDisplayScheduler*>(scheduler_.get());
+    return *static_cast<TestDisplayScheduler*>(SchedulerForTesting());
   }
-
- protected:
-  void CreateScheduler() override {
-    scheduler_.reset(new TestDisplayScheduler(this, vsync_begin_frame_source_,
-                                              task_runner_));
-  }
-
- private:
-  base::SingleThreadTaskRunner* task_runner_;
 };
 
 void CopyCallback(bool* called, std::unique_ptr<CopyOutputResult> result) {
   *called = true;
 }
 
 // Check that frame is damaged and swapped only under correct conditions.
 TEST_F(DisplayTest, DisplayDamaged) {
   SetUpContext(nullptr);
   StubDisplayClient client;
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
   TestDisplay display(&manager_, shared_bitmap_manager_.get(), nullptr,
                       settings, id_allocator_.id_namespace(),
-                      task_runner_.get(), std::move(output_surface_));
+                      task_runner_.get(), &begin_frame_source_,
+                      std::move(output_surface_));
   display.Initialize(&client);
   TestDisplayScheduler& scheduler = display.scheduler();
 
   SurfaceId surface_id(id_allocator_.GenerateId());
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.has_new_root_surface);
   display.SetSurfaceId(surface_id, 1.f);
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.display_resized_);
   EXPECT_TRUE(scheduler.has_new_root_surface);
@@ skipping 247 matching lines @@
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
 
   SurfaceId surface_id(id_allocator_.GenerateId());
 
   StubDisplayClient client;
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
   TestDisplay display(&manager_, shared_bitmap_manager_.get(), nullptr,
                       settings, surface_id.id_namespace(), task_runner_.get(),
-                      std::move(output_surface_));
+                      &begin_frame_source_, std::move(output_surface_));
   display.Initialize(&client);
 
   display.SetSurfaceId(surface_id, 1.f);
 
   display.Resize(gfx::Size(100, 100));
   factory_.Create(surface_id);
 
   {
     RenderPassList pass_list;
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
@@ skipping 37 matching lines @@
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
   display.Resize(gfx::Size(250, 250));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   factory_.Destroy(surface_id);
 }
 
 }  // namespace
 }  // namespace cc