Make cc::Display not own its BeginFrameSource

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 90 matching lines @@
         task_runner_(new base::NullTaskRunner) {
     manager_.RegisterSurfaceClientId(id_allocator_.client_id());
   }
 
   ~DisplayTest() override {
     manager_.InvalidateSurfaceClientId(id_allocator_.client_id());
   }
 
   void SetUpDisplay(const RendererSettings& settings,
                     std::unique_ptr<TestWebGraphicsContext3D> context) {
-    std::unique_ptr<BeginFrameSource> begin_frame_source(
-        new StubBeginFrameSource);
-
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (context) {
       output_surface = FakeOutputSurface::Create3d(std::move(context));
     } 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(&begin_frame_source_, task_runner_.get()));
     scheduler_ = scheduler.get();
 
     display_ = base::MakeUnique<Display>(
         &shared_bitmap_manager_, nullptr /* gpu_memory_buffer_manager */,
-        settings, std::move(begin_frame_source), std::move(output_surface),
+        settings, &begin_frame_source_, std::move(output_surface),
         std::move(scheduler),
         base::MakeUnique<TextureMailboxDeleter>(task_runner_.get()));
     display_->SetVisible(true);
   }
 
  protected:
   void SubmitCompositorFrame(RenderPassList* pass_list,
                              const SurfaceId& surface_id) {
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
     CompositorFrame frame;
     frame.delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   static constexpr int kArbitraryClientId = 3;
 
   SurfaceManager manager_;
   FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
   SurfaceIdAllocator id_allocator_;
+  StubBeginFrameSource begin_frame_source_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
   TestSharedBitmapManager shared_bitmap_manager_;
   std::unique_ptr<Display> display_;
   TestSoftwareOutputDevice* software_output_device_ = nullptr;
   FakeOutputSurface* output_surface_ = nullptr;
   TestDisplayScheduler* scheduler_ = nullptr;
 };
 
 class StubDisplayClient : public DisplayClient {
  public:
@@ skipping 329 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