cc: Remove BeginFrameSourcesConstructor.

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 251 matching lines @@
     // to be > BeginFrameArgs::DefaultInterval()
     now_src_->Advance(base::TimeDelta::FromMilliseconds(100));
     // Fail if we need to run 100 tasks in a row.
     task_runner_->SetRunTaskLimit(100);
   }
 
   ~SchedulerTest() override {}
 
  protected:
   TestScheduler* CreateScheduler() {
-    scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source;
     if (scheduler_settings_.use_external_begin_frame_source) {
-      fake_external_begin_frame_source.reset(
+      fake_external_begin_frame_source_.reset(
           new FakeExternalBeginFrameSource(client_.get()));
-      fake_external_begin_frame_source_ =
-          fake_external_begin_frame_source.get();
     }
-    scheduler_ = TestScheduler::Create(now_src_.get(), client_.get(),
-                                       scheduler_settings_, 0, task_runner_,
-                                       fake_external_begin_frame_source.Pass());
+    scheduler_ = TestScheduler::Create(
+        now_src_.get(), client_.get(), scheduler_settings_, 0,
+        task_runner_.get(), fake_external_begin_frame_source_.get());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
@@ skipping 116 matching lines @@
     // Creep the time forward so that any BeginFrameArgs is not equal to the
     // last one otherwise we violate the BeginFrameSource contract.
     now_src_->Advance(BeginFrameArgs::DefaultInterval());
     BeginFrameArgs args =
         CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
     fake_external_begin_frame_source_->TestOnBeginFrame(args);
     return args;
   }
 
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
-    return fake_external_begin_frame_source_;
+    return fake_external_begin_frame_source_.get();
   }
 
   void MainFrameInHighLatencyMode(
       int64 begin_main_frame_to_commit_estimate_in_ms,
       int64 commit_to_activate_estimate_in_ms,
       bool impl_latency_takes_priority,
       bool should_send_begin_main_frame);
   void BeginFramesNotFromClient(bool use_external_begin_frame_source,
                                 bool throttle_frame_production);
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
   void DidLoseOutputSurfaceAfterBeginFrameStartedWithHighLatency(
       bool impl_side_painting);
   void DidLoseOutputSurfaceAfterReadyToCommit(bool impl_side_painting);
 
   scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-  FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
+  scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
@@ skipping 2586 matching lines @@
   scheduler_->SetImplLatencyTakesPriority(true);
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
   EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc