Moves ownership of the cc::Display's BeginFrameSource out of Display.

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"
@@ skipping 43 matching lines @@
 class TestSoftwareOutputDevice : public SoftwareOutputDevice {
  public:
   TestSoftwareOutputDevice() {}
 
   gfx::Rect damage_rect() const { return damage_rect_; }
   gfx::Size viewport_pixel_size() const { return viewport_pixel_size_; }
 };
 
 class TestDisplayScheduler : public DisplayScheduler {
  public:
-  TestDisplayScheduler(BeginFrameSource* begin_frame_source,
-                       base::SingleThreadTaskRunner* task_runner)
-      : DisplayScheduler(begin_frame_source, task_runner, 1),
+  explicit TestDisplayScheduler(base::SingleThreadTaskRunner* task_runner)
+      : DisplayScheduler(task_runner, 1),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
         swapped(false) {}
 
   ~TestDisplayScheduler() override {}
 
   void DisplayResized() override { display_resized_ = true; }
 
   void SetNewRootSurface(const SurfaceId& root_surface_id) override {
@@ skipping 27 matching lines @@
     manager_.RegisterFrameSinkId(kArbitraryFrameSinkId);
   }
 
   ~DisplayTest() override {
     manager_.InvalidateFrameSinkId(kArbitraryFrameSinkId);
     factory_.EvictSurface();
   }
 
   void SetUpDisplay(const RendererSettings& settings,
                     std::unique_ptr<TestWebGraphicsContext3D> context) {
-    std::unique_ptr<BeginFrameSource> begin_frame_source(
-        new StubBeginFrameSource);
+    begin_frame_source_.reset(new StubBeginFrameSource);
 
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (context) {
       auto provider = TestContextProvider::Create(std::move(context));
       provider->BindToCurrentThread();
       output_surface = FakeOutputSurface::Create3d(std::move(provider));
     } else {
       std::unique_ptr<TestSoftwareOutputDevice> device(
           new TestSoftwareOutputDevice);
       software_output_device_ = device.get();
       output_surface = FakeOutputSurface::CreateSoftware(std::move(device));
     }
     output_surface_ = output_surface.get();
 
     std::unique_ptr<TestDisplayScheduler> scheduler(
-        new TestDisplayScheduler(begin_frame_source.get(), task_runner_.get()));
+        new TestDisplayScheduler(task_runner_.get()));
     scheduler_ = scheduler.get();
 
     display_ = base::MakeUnique<Display>(
         &shared_bitmap_manager_, nullptr /* gpu_memory_buffer_manager */,
-        settings, kArbitraryFrameSinkId, std::move(begin_frame_source),
+        settings, kArbitraryFrameSinkId, begin_frame_source_.get(),
         std::move(output_surface), std::move(scheduler),
         base::MakeUnique<TextureMailboxDeleter>(task_runner_.get()));
     display_->SetVisible(true);
   }
 
  protected:
   void SubmitCompositorFrame(RenderPassList* pass_list,
                              const LocalFrameId& local_frame_id) {
     CompositorFrame frame;
     pass_list->swap(frame.render_pass_list);
 
     factory_.SubmitCompositorFrame(local_frame_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   SurfaceManager manager_;
   FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
   SurfaceIdAllocator id_allocator_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
   TestSharedBitmapManager shared_bitmap_manager_;
+  std::unique_ptr<BeginFrameSource> begin_frame_source_;
   std::unique_ptr<Display> display_;
   TestSoftwareOutputDevice* software_output_device_ = nullptr;
   FakeOutputSurface* output_surface_ = nullptr;
   TestDisplayScheduler* scheduler_ = nullptr;
 };
 
 class StubDisplayClient : public DisplayClient {
  public:
   void DisplayOutputSurfaceLost() override {}
   void DisplayWillDrawAndSwap(bool will_draw_and_swap,
@@ skipping 339 matching lines @@
   // Verify DidLoseOutputSurface callback is hooked up correctly.
   EXPECT_EQ(0, client.loss_count());
   output_surface_->context_provider()->ContextGL()->LoseContextCHROMIUM(
       GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
   output_surface_->context_provider()->ContextGL()->Flush();
   EXPECT_EQ(1, client.loss_count());
 }
 
 }  // namespace
 }  // namespace cc