Make disable vsync run the renderer independently

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 <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 197 matching lines @@
   bool automatic_swap_ack_;
   int num_draws_;
   BeginFrameArgs last_begin_main_frame_args_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<std::unique_ptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
+enum BeginFrameSourceType {
+  EXTERNAL_BFS,
+  UNTHROTTLED_BFS,
+  THROTTLED_BFS,
+};
+
 class SchedulerTest : public testing::Test {
  public:
   SchedulerTest()
       : now_src_(new base::SimpleTestTickClock()),
         task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)),
         fake_external_begin_frame_source_(nullptr) {
     now_src_->Advance(base::TimeDelta::FromMicroseconds(10000));
     // A bunch of tests require NowTicks()
     // 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() {
-    BeginFrameSource* frame_source;
+  TestScheduler* CreateScheduler(BeginFrameSourceType bfs_type) {
+    BeginFrameSource* frame_source = nullptr;
     unthrottled_frame_source_.reset(new BackToBackBeginFrameSource(
         base::MakeUnique<TestDelayBasedTimeSource>(now_src_.get(),
                                                    task_runner_.get())));
     fake_external_begin_frame_source_.reset(
         new FakeExternalBeginFrameSource(0.f, false));
     fake_external_begin_frame_source_->SetClient(client_.get());
     synthetic_frame_source_.reset(new DelayBasedBeginFrameSource(
         base::MakeUnique<TestDelayBasedTimeSource>(now_src_.get(),
                                                    task_runner_.get())));
-    if (!scheduler_settings_.throttle_frame_production) {
-      frame_source = unthrottled_frame_source_.get();
-    } else if (scheduler_settings_.use_external_begin_frame_source) {
-      frame_source = fake_external_begin_frame_source_.get();
-    } else {
-      frame_source = synthetic_frame_source_.get();
+    switch (bfs_type) {
+      case EXTERNAL_BFS:
+        frame_source = fake_external_begin_frame_source_.get();
+        break;
+      case UNTHROTTLED_BFS:
+        frame_source = unthrottled_frame_source_.get();
+        break;
+      case THROTTLED_BFS:
+        frame_source = synthetic_frame_source_.get();
+        break;
     }
+    DCHECK(frame_source);
 
     std::unique_ptr<FakeCompositorTimingHistory>
         fake_compositor_timing_history = FakeCompositorTimingHistory::Create(
             scheduler_settings_.using_synchronous_renderer_compositor);
     fake_compositor_timing_history_ = fake_compositor_timing_history.get();
 
     scheduler_.reset(
         new TestScheduler(now_src_.get(), client_.get(), scheduler_settings_, 0,
                           task_runner_.get(), frame_source,
                           std::move(fake_compositor_timing_history)));
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
 
     // Use large estimates by default to avoid latency recovery in most tests.
     fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
     return scheduler_.get();
   }
 
-  void CreateSchedulerAndInitSurface() {
-    CreateScheduler();
+  void SetUpScheduler(BeginFrameSourceType bfs_type,
+                      std::unique_ptr<FakeSchedulerClient> client) {
+    client_ = std::move(client);
+    CreateScheduler(bfs_type);
     EXPECT_SCOPED(InitializeCompositorFrameSinkAndFirstCommit());
   }
 
-  void SetUpScheduler(bool initSurface) {
-    SetUpScheduler(base::WrapUnique(new FakeSchedulerClient), initSurface);
+  void SetUpScheduler(BeginFrameSourceType bfs_type) {
+    SetUpScheduler(bfs_type, base::MakeUnique<FakeSchedulerClient>());
   }
 
-  void SetUpScheduler(std::unique_ptr<FakeSchedulerClient> client,
-                      bool initSurface) {
-    client_ = std::move(client);
-    if (initSurface)
-      CreateSchedulerAndInitSurface();
-    else
-      CreateScheduler();
+  void SetUpSchedulerWithNoCompositorFrameSink(BeginFrameSourceType bfs_type) {
+    client_ = base::MakeUnique<FakeSchedulerClient>();
+    CreateScheduler(bfs_type);
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   base::SimpleTestTickClock* now_src() { return now_src_.get(); }
 
   // As this function contains EXPECT macros, to allow debugging it should be
   // called inside EXPECT_SCOPED like so;
   //   EXPECT_SCOPED(
   //       client.InitializeCompositorFrameSinkAndFirstCommit(scheduler));
   void InitializeCompositorFrameSinkAndFirstCommit() {
@@ skipping 105 matching lines @@
     return args;
   }
 
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
     return fake_external_begin_frame_source_.get();
   }
 
   void CheckMainFrameSkippedAfterLateCommit(bool expect_send_begin_main_frame);
   void ImplFrameSkippedAfterLateSwapAck(bool swap_ack_before_deadline);
   void ImplFrameNotSkippedAfterLateSwapAck();
-  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 BeginFramesNotFromClient(BeginFrameSourceType bfs_type);
+  void BeginFramesNotFromClient_SwapThrottled(BeginFrameSourceType bfs_type);
   bool BeginMainFrameOnCriticalPath(TreePriority tree_priority,
                                     ScrollHandlerState scroll_handler_state,
                                     base::TimeDelta durations);
 
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   std::unique_ptr<FakeExternalBeginFrameSource>
       fake_external_begin_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> synthetic_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> unthrottled_frame_source_;
   SchedulerSettings scheduler_settings_;
   std::unique_ptr<FakeSchedulerClient> client_;
   std::unique_ptr<TestScheduler> scheduler_;
   FakeCompositorTimingHistory* fake_compositor_timing_history_;
 };
 
 TEST_F(SchedulerTest, InitializeCompositorFrameSinkDoesNotBeginImplFrame) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(false);
+  SetUpSchedulerWithNoCompositorFrameSink(EXTERNAL_BFS);
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
                        client_);
   client_->Reset();
   scheduler_->DidCreateAndInitializeCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, VideoNeedsBeginFrames) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetVideoNeedsBeginFrames(true);
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   // WillBeginImplFrame is responsible for sending BeginFrames to video.
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 
   client_->Reset();
   scheduler_->SetVideoNeedsBeginFrames(false);
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 }
 
 TEST_F(SchedulerTest, RequestCommit) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 41 matching lines @@
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, RequestCommitAfterSetDeferCommit) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetDeferCommits(true);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   task_runner().RunPendingTasks();
   // There are no pending tasks or actions.
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   scheduler_->SetDeferCommits(false);
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   // Start new BeginMainFrame after defer commit is off.
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 }
 
 TEST_F(SchedulerTest, DeferCommitWithRedraw) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetDeferCommits(true);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
 
   // The SetNeedsRedraw will override the SetDeferCommits(true), to allow a
   // begin frame to be needed.
   client_->Reset();
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   AdvanceFrame();
   // BeginMainFrame is not sent during the defer commit is on.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 }
 
 TEST_F(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 85 matching lines @@
   bool request_redraws_;
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST_F(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
   client->SetRequestRedrawsInsideDraw(true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client->num_draws());
@@ skipping 14 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client->num_draws());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(client->needs_begin_frames());
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST_F(SchedulerTest, RequestRedrawInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   client->SetRequestRedrawsInsideDraw(true);
   client->SetDrawWillHappen(false);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Fail the draw.
@@ skipping 53 matching lines @@
 
  private:
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsBeginMainFrame requests
 // that happen inside a ScheduledActionDrawAndSwap
 TEST_F(SchedulerTest, RequestCommitInsideDraw) {
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw* client =
       new SchedulerClientThatSetNeedsBeginMainFrameInsideDraw;
-
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   EXPECT_FALSE(client->needs_begin_frames());
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_EQ(0, client->num_draws());
   EXPECT_TRUE(client->needs_begin_frames());
 
   client->SetNeedsBeginMainFrameOnNextDraw();
   EXPECT_SCOPED(AdvanceFrame());
   client->SetNeedsBeginMainFrameOnNextDraw();
@@ skipping 20 matching lines @@
   EXPECT_EQ(2, client->num_draws());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->CommitPending());
   EXPECT_FALSE(client->needs_begin_frames());
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST_F(SchedulerTest, RequestCommitInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   client->SetDrawWillHappen(false);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Fail the draw.
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 21 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(3, client->num_draws());
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
 }
 
 TEST_F(SchedulerTest, NoSwapWhenDrawFails) {
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw* client =
       new SchedulerClientThatSetNeedsBeginMainFrameInsideDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Draw successfully, this starts a new frame.
   client->SetNeedsBeginMainFrameOnNextDraw();
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
@@ skipping 16 matching lines @@
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 // Test prepare tiles is independant of draws.
 TEST_F(SchedulerTest, PrepareTiles) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   // Request both draw and prepare tiles. PrepareTiles shouldn't
   // be trigged until BeginImplFrame.
   client->Reset();
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
@@ skipping 78 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(0, client->num_draws());
   EXPECT_FALSE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 }
 
 // Test that PrepareTiles only happens once per frame.  If an external caller
 // initiates it, then the state machine should not PrepareTiles on that frame.
 TEST_F(SchedulerTest, PrepareTilesOncePerFrame) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // If DidPrepareTiles during a frame, then PrepareTiles should not occur
   // again.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
@@ skipping 91 matching lines @@
   EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 }
 
 TEST_F(SchedulerTest, PrepareTilesFunnelResetOnVisibilityChange) {
   std::unique_ptr<SchedulerClientNeedsPrepareTilesInDraw> client =
       base::WrapUnique(new SchedulerClientNeedsPrepareTilesInDraw);
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(std::move(client), true);
+  SetUpScheduler(EXTERNAL_BFS, std::move(client));
 
   // Simulate a few visibility changes and associated PrepareTiles.
   for (int i = 0; i < 10; i++) {
     scheduler_->SetVisible(false);
     scheduler_->WillPrepareTiles();
     scheduler_->DidPrepareTiles();
 
     scheduler_->SetVisible(true);
     scheduler_->WillPrepareTiles();
     scheduler_->DidPrepareTiles();
@@ skipping 11 matching lines @@
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
 
   // The deadline should be zero since there is no work other than drawing
   // pending.
   EXPECT_EQ(base::TimeTicks(), client->posted_begin_impl_frame_deadline());
 }
 
 TEST_F(SchedulerTest, WaitForReadyToDrawDoNotPostDeadline) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.commit_to_active_tree = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Begin new frame.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 17 matching lines @@
   scheduler_->NotifyReadyToDraw();
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
 }
 
 TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostCompositorFrameSink) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
-  scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.commit_to_active_tree = true;
-  SetUpScheduler(base::WrapUnique(client), true);
+  SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Begin new frame.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 51 matching lines @@
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_EQ(expect_send_begin_main_frame,
             scheduler_->MainThreadMissedLastDeadline());
   EXPECT_TRUE(client_->HasAction("WillBeginImplFrame"));
   EXPECT_EQ(expect_send_begin_main_frame,
             client_->HasAction("ScheduledActionSendBeginMainFrame"));
 }
 
 TEST_F(SchedulerTest, MainFrameSkippedAfterLateCommit) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool expect_send_begin_main_frame = false;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 // Response times of BeginMainFrame's without the critical path flag set
 // should not affect whether we recover latency or not.
 TEST_F(SchedulerTest,
        MainFrameSkippedAfterLateCommit_LongMainFrameQueueDurationNotCritical) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = false;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 // Response times of BeginMainFrame's with the critical path flag set
 // should affect whether we recover latency or not.
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_LongMainFrameQueueDurationCritical) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationCriticalEstimate(kSlowDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommitInPreferImplLatencyMode) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   scheduler_->SetTreePrioritiesAndScrollState(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_CommitEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameStartToCommitDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_ReadyToActivateEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
       kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_ActivateEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetActivateDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest, MainFrameNotSkippedAfterLateCommit_DrawEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 // If the BeginMainFrame aborts, it doesn't actually insert a frame into the
 // queue, which means there is no latency to recover.
 TEST_F(SchedulerTest, MainFrameNotSkippedAfterLateBeginMainFrameAbort) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // Use fast estimates so we think we can recover latency if needed.
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   // Impl thread hits deadline before BeginMainFrame aborts.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("AddObserver(this)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
@@ skipping 15 matching lines @@
   EXPECT_TRUE(client_->HasAction("WillBeginImplFrame"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 }
 
 // If the BeginMainFrame aborts, it doesn't actually insert a frame into the
 // queue, which means there is no latency to recover.
 TEST_F(SchedulerTest, MainFrameNotSkippedAfterCanDrawChanges) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // Use fast estimates so we think we can recover latency if needed.
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   // Impl thread hits deadline before BeginMainFrame aborts.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("AddObserver(this)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
@@ skipping 100 matching lines @@
     scheduler_->NotifyReadyToActivate();
     task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
     EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
     EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
   }
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_FastEstimates_SwapAckThenDeadline) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool swap_ack_before_deadline = true;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_FastEstimates_DeadlineThenSwapAck) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_LongMainFrameQueueDurationNotCritical) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_ImplLatencyTakesPriority) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if the draw is fast and we
   // are in impl latency takes priority.
   scheduler_->SetTreePrioritiesAndScrollState(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_OnlyImplSideUpdatesExpected) {
   // This tests that we recover impl thread latency when there are no commits.
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // To get into a high latency state, this test disables automatic swap acks.
   client_->SetAutomaticSwapAck(false);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if there are no commits from
   // the main thread.
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
@@ skipping 93 matching lines @@
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 4);
     EXPECT_ACTION("ScheduledActionCommit", client_, 1, 4);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 2, 4);
     EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
   }
 }
 
 TEST_F(
     SchedulerTest,
     ImplFrameNotSkippedAfterLateSwapAck_MainFrameQueueDurationCriticalTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationCriticalEstimate(kSlowDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameNotSkippedAfterLateSwapAck_CommitEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameStartToCommitDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameNotSkippedAfterLateSwapAck_ReadyToActivateEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
       kSlowDuration);
   EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameNotSkippedAfterLateSwapAck_ActivateEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetActivateDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest, ImplFrameNotSkippedAfterLateSwapAck_DrawEstimateTooLong) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        MainFrameThenImplFrameSkippedAfterLateCommitAndLateSwapAck) {
   // Set up client with custom estimates.
   // This test starts off with expensive estimates to prevent latency recovery
   // initially, then lowers the estimates to enable it once both the main
   // and impl threads are in a high latency mode.
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
   // To get into a high latency state, this test disables automatic swap acks.
   client_->SetAutomaticSwapAck(false);
 
   // Impl thread hits deadline before commit finishes to make
   // MainThreadMissedLastDeadline true
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
@@ skipping 100 matching lines @@
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 5);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 4, 5);
 }
 
 TEST_F(
     SchedulerTest,
     Deadlock_CommitMakesProgressWhileSwapTrottledAndActiveTreeNeedsFirstDraw) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
-  scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
   client_->SetAutomaticSwapAck(false);
 
   // Get a new active tree in main-thread high latency mode and put us
   // in a swap throttled state.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
@@ skipping 41 matching lines @@
 }
 
 TEST_F(
     SchedulerTest,
     CommitMakesProgressWhenIdleAndHasPendingTreeAndActiveTreeNeedsFirstDraw) {
   // This verifies we don't block commits longer than we need to
   // for performance reasons - not deadlock reasons.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
   client_->SetAutomaticSwapAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
@@ skipping 36 matching lines @@
 
   // Activate the pending tree, which also unblocks the commit immediately
   // while we are in an idle state.
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionCommit", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, BeginRetroFrame) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
@@ skipping 52 matching lines @@
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, RetroFrameDoesNotExpireTooEarly) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 37 matching lines @@
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   // This is an immediate deadline case.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
 }
 
 TEST_F(SchedulerTest, RetroFrameExpiresOnTime) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 30 matching lines @@
 
   // Let's advance sufficiently past the retro frame's deadline.
   now_src()->Advance(retro_frame_args.deadline - now_src()->NowTicks() +
                      base::TimeDelta::FromMicroseconds(1));
 
   // The retro frame should've expired.
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, MissedFrameDoesNotExpireTooEarly) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   BeginFrameArgs missed_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
   missed_frame_args.type = BeginFrameArgs::MISSED;
 
   // Advance to the deadline.
   now_src()->Advance(missed_frame_args.deadline - now_src()->NowTicks());
 
   // Missed frame is handled because it's on time.
   client_->Reset();
   fake_external_begin_frame_source_->TestOnBeginFrame(missed_frame_args);
   EXPECT_TRUE(
       task_runner().RunTasksWhile(client_->InsideBeginImplFrame(false)));
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 }
 
 TEST_F(SchedulerTest, MissedFrameExpiresOnTime) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   BeginFrameArgs missed_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
   missed_frame_args.type = BeginFrameArgs::MISSED;
 
   // Advance sufficiently past the deadline.
   now_src()->Advance(missed_frame_args.deadline - now_src()->NowTicks() +
                      base::TimeDelta::FromMicroseconds(1));
 
   // Missed frame is dropped because it's too late.
   client_->Reset();
   fake_external_begin_frame_source_->TestOnBeginFrame(missed_frame_args);
   EXPECT_FALSE(
       task_runner().RunTasksWhile(client_->InsideBeginImplFrame(false)));
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 }
 
-void SchedulerTest::BeginFramesNotFromClient(
-    bool use_external_begin_frame_source,
-    bool throttle_frame_production) {
-  scheduler_settings_.use_external_begin_frame_source =
-      use_external_begin_frame_source;
-  scheduler_settings_.throttle_frame_production = throttle_frame_production;
-  SetUpScheduler(true);
+void SchedulerTest::BeginFramesNotFromClient(BeginFrameSourceType bfs_type) {
+  SetUpScheduler(bfs_type);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame
   // without calling SetNeedsBeginFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   // When the client-driven BeginFrame are disabled, the scheduler posts it's
   // own BeginFrame tasks.
   task_runner().RunPendingTasks();  // Run posted BeginFrame.
@@ skipping 39 matching lines @@
   client_->Reset();
 
   // Make sure SetNeedsBeginFrame isn't called on the client
   // when the BeginFrame is no longer needed.
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SendBeginMainFrameNotExpectedSoon", client_);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SyntheticBeginFrames) {
-  bool use_external_begin_frame_source = false;
-  bool throttle_frame_production = true;
-  BeginFramesNotFromClient(use_external_begin_frame_source,
-                           throttle_frame_production);
+  BeginFramesNotFromClient(THROTTLED_BFS);
 }
 
-TEST_F(SchedulerTest, VSyncThrottlingDisabled) {
-  bool use_external_begin_frame_source = true;
-  bool throttle_frame_production = false;
-  BeginFramesNotFromClient(use_external_begin_frame_source,
-                           throttle_frame_production);
-}
-
-TEST_F(SchedulerTest, SyntheticBeginFrames_And_VSyncThrottlingDisabled) {
-  bool use_external_begin_frame_source = false;
-  bool throttle_frame_production = false;
-  BeginFramesNotFromClient(use_external_begin_frame_source,
-                           throttle_frame_production);
+TEST_F(SchedulerTest, UnthrottledBeginFrames) {
+  BeginFramesNotFromClient(UNTHROTTLED_BFS);
 }
 
 void SchedulerTest::BeginFramesNotFromClient_SwapThrottled(
-    bool use_external_begin_frame_source,
-    bool throttle_frame_production) {
-  scheduler_settings_.use_external_begin_frame_source =
-      use_external_begin_frame_source;
-  scheduler_settings_.throttle_frame_production = throttle_frame_production;
-  SetUpScheduler(true);
+    BeginFrameSourceType bfs_type) {
+  SetUpScheduler(bfs_type);
 
   scheduler_->SetEstimatedParentDrawTime(
       BeginFrameArgs::DefaultEstimatedParentDrawTime());
 
   // Set the draw duration estimate to zero so that deadlines are accurate.
   fake_compositor_timing_history_->SetDrawDurationEstimate(base::TimeDelta());
 
   // To test swap ack throttling, this test disables automatic swap acks.
   client_->SetAutomaticSwapAck(false);
 
@@ skipping 69 matching lines @@
   // We can't do an equality comparison here because the scheduler uses a fudge
   // factor that's an internal implementation detail.
   EXPECT_GT(after_deadline, before_deadline);
   EXPECT_LT(after_deadline,
             before_deadline + BeginFrameArgs::DefaultInterval());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SyntheticBeginFrames_SwapThrottled) {
-  bool use_external_begin_frame_source = false;
-  bool throttle_frame_production = true;
-  BeginFramesNotFromClient_SwapThrottled(use_external_begin_frame_source,
-                                         throttle_frame_production);
+  BeginFramesNotFromClient_SwapThrottled(THROTTLED_BFS);
 }
 
-TEST_F(SchedulerTest, VSyncThrottlingDisabled_SwapThrottled) {
-  bool use_external_begin_frame_source = true;
-  bool throttle_frame_production = false;
-  BeginFramesNotFromClient_SwapThrottled(use_external_begin_frame_source,
-                                         throttle_frame_production);
-}
-
-TEST_F(SchedulerTest,
-       SyntheticBeginFrames_And_VSyncThrottlingDisabled_SwapThrottled) {
-  bool use_external_begin_frame_source = false;
-  bool throttle_frame_production = false;
-  BeginFramesNotFromClient_SwapThrottled(use_external_begin_frame_source,
-                                         throttle_frame_production);
+TEST_F(SchedulerTest, UnthrottledBeginFrames_SwapThrottled) {
+  BeginFramesNotFromClient_SwapThrottled(UNTHROTTLED_BFS);
 }
 
 TEST_F(SchedulerTest,
        DidLoseCompositorFrameSinkAfterCompositorFrameSinkIsInitialized) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(false);
+  SetUpSchedulerWithNoCompositorFrameSink(EXTERNAL_BFS);
 
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
                        client_);
   client_->Reset();
   scheduler_->DidCreateAndInitializeCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
 
   scheduler_->DidLoseCompositorFrameSink();
   EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
                        client_);
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterBeginFrameStarted) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 12 matching lines @@
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
                 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest,
        DidLoseCompositorFrameSinkAfterBeginFrameStartedWithHighLatency) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 24 matching lines @@
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 2,
                 3);
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterReadyToCommit) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 11 matching lines @@
   // RemoveObserver(this) is not called until the end of the frame.
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
                 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterSetNeedsPrepareTiles) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->DidLoseCompositorFrameSink();
   // RemoveObserver(this) is not called until the end of the frame.
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 0, 4);
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 1,
                 4);
   EXPECT_ACTION("RemoveObserver(this)", client_, 2, 4);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 3, 4);
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterBeginRetroFramePosted) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   client_->Reset();
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
@@ skipping 39 matching lines @@
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_TRUE(scheduler_->IsBeginRetroFrameArgsEmpty());
 
   // Posted BeginRetroFrame is aborted.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkDuringBeginRetroFrameRunning) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   client_->Reset();
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
@@ skipping 54 matching lines @@
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 
   // No more BeginRetroFrame because BeginRetroFrame queue is cleared.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest,
        DidLoseCompositorFrameSinkWithDelayBasedBeginFrameSource) {
-  SetUpScheduler(true);
+  SetUpScheduler(THROTTLED_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
@@ skipping 21 matching lines @@
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
                 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 }
 
 TEST_F(SchedulerTest, DidLoseCompositorFrameSinkWhenIdle) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 14 matching lines @@
   // Idle time between BeginFrames.
   client_->Reset();
   scheduler_->DidLoseCompositorFrameSink();
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
                 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest, ScheduledActionActivateAfterBecomingInvisible) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->SetVisible(false);
   task_runner().RunPendingTasks();  // Run posted deadline.
 
   // Sync tree should be forced to activate.
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest, ScheduledActionActivateAfterBeginFrameSourcePaused) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   fake_external_begin_frame_source_->SetPaused(true);
   task_runner().RunPendingTasks();  // Run posted deadline.
 
   // Sync tree should be forced to activate.
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
 }
 
 // Tests to ensure frame sources can be successfully changed while drawing.
 TEST_F(SchedulerTest, SwitchFrameSourceToUnthrottled) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsRedraw should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
@@ skipping 15 matching lines @@
   // If we don't swap on the deadline, we wait for the next BeginFrame.
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 // Tests to ensure frame sources can be successfully changed while a frame
 // deadline is pending.
 TEST_F(SchedulerTest, SwitchFrameSourceToUnthrottledBeforeDeadline) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsRedraw should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 
   // Switch to an unthrottled frame source before the frame deadline is hit.
@@ skipping 13 matching lines @@
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 // Tests to ensure that the active frame source can successfully be changed from
 // unthrottled to throttled.
 TEST_F(SchedulerTest, SwitchFrameSourceToThrottled) {
-  scheduler_settings_.throttle_frame_production = false;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(UNTHROTTLED_BFS);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
@@ skipping 15 matching lines @@
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
 }
 
 TEST_F(SchedulerTest, SwitchFrameSourceToNullInsideDeadline) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   client_->Reset();
 
   // Switch to a null frame source.
@@ skipping 31 matching lines @@
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
 }
 
 // This test maskes sure that switching a frame source when not observing
 // such as when not visible also works.
 TEST_F(SchedulerTest, SwitchFrameSourceWhenNotObserving) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Begin new frame.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 33 matching lines @@
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 }
 
 // Tests to ensure that we send a BeginMainFrameNotExpectedSoon when expected.
 TEST_F(SchedulerTest, SendBeginMainFrameNotExpectedSoon) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Trigger a frame draw.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
@@ skipping 14 matching lines @@
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorAnimation) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsOneBeginImplFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Testing the case where animation ticks a fling scroll.
   client_->SetWillBeginImplFrameCausesRedraw(true);
   // The animation isn't done so it'll cause another tick in the future.
   client_->SetWillBeginImplFrameRequestsOneBeginImplFrame(true);
 
@@ skipping 34 matching lines @@
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorOnDrawDuringIdle) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_ACTION("AddObserver(this)", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Idle on next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SetNeedsOneBeginImplFrame) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 
   // Request a frame, should kick the source.
   scheduler_->SetNeedsOneBeginImplFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // The incoming WillBeginImplFrame will request another one.
   client_->SetWillBeginImplFrameRequestsOneBeginImplFrame(true);
@@ skipping 17 matching lines @@
   task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Scheduler shuts down the source now that no begin frame is requested.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorCommit) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ skipping 35 matching lines @@
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorDoubleCommitWithoutDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ skipping 35 matching lines @@
 
  protected:
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 TEST_F(SchedulerTest, SynchronousCompositorPrepareTilesOnDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
 
   std::unique_ptr<FakeSchedulerClient> client =
       base::WrapUnique(new SchedulerClientSetNeedsPrepareTilesOnDraw);
-  SetUpScheduler(std::move(client), true);
+  SetUpScheduler(EXTERNAL_BFS, std::move(client));
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
@@ skipping 22 matching lines @@
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorSendBeginMainFrameWhileIdle) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
@@ skipping 36 matching lines @@
   client_->Reset();
 
   // Simulate SetNeedsBeginMainFrame due to input event.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorResourcelessOnDrawWhenInvisible) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetVisible(false);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = true;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   // SynchronousCompositor has to draw regardless of visibility.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, AuthoritativeVSyncInterval) {
-  SetUpScheduler(true);
+  SetUpScheduler(THROTTLED_BFS);
   base::TimeDelta initial_interval = scheduler_->BeginImplFrameInterval();
   base::TimeDelta authoritative_interval =
       base::TimeDelta::FromMilliseconds(33);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SCOPED(AdvanceFrame());
 
   EXPECT_EQ(initial_interval, scheduler_->BeginImplFrameInterval());
 
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
 
   // Test changing the interval on the frame source external to the scheduler.
   synthetic_frame_source_->OnUpdateVSyncParameters(now_src_->NowTicks(),
                                                    authoritative_interval);
 
   EXPECT_SCOPED(AdvanceFrame());
 
   // At the next BeginFrame, authoritative interval is used instead of previous
   // interval.
   EXPECT_NE(initial_interval, scheduler_->BeginImplFrameInterval());
   EXPECT_EQ(authoritative_interval, scheduler_->BeginImplFrameInterval());
 }
 
 TEST_F(SchedulerTest, ImplLatencyTakesPriority) {
-  SetUpScheduler(true);
+  SetUpScheduler(THROTTLED_BFS);
 
   scheduler_->SetTreePrioritiesAndScrollState(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
   EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
   EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
 
   scheduler_->SetTreePrioritiesAndScrollState(
@@ skipping 15 matching lines @@
   scheduler_->SetTreePrioritiesAndScrollState(
       SAME_PRIORITY_FOR_BOTH_TREES,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER);
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
 }
 
 TEST_F(SchedulerTest, NoCompositorFrameSinkCreationWhileCommitPending) {
-  SetUpScheduler(true);
+  SetUpScheduler(THROTTLED_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
   // Lose the CompositorFrameSink and trigger the deadline.
   client_->Reset();
@@ skipping 12 matching lines @@
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks::Now());
   scheduler_->BeginMainFrameAborted(
       CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST);
   EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
                        client_);
 }
 
 TEST_F(SchedulerTest, CompositorFrameSinkCreationWhileCommitPending) {
   scheduler_settings_.abort_commit_before_compositor_frame_sink_creation =
       false;
-  SetUpScheduler(true);
+  SetUpScheduler(THROTTLED_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
   // Lose the CompositorFrameSink and trigger the deadline.
   client_->Reset();
@@ skipping 13 matching lines @@
 
 // The three letters appeneded to each version of this test mean the following:s
 // tree_priority: B = both trees same priority; A = active tree priority;
 // scroll_handler_state: H = affects scroll handler; N = does not affect scroll
 // handler;
 // durations: F = fast durations; S = slow durations
 bool SchedulerTest::BeginMainFrameOnCriticalPath(
     TreePriority tree_priority,
     ScrollHandlerState scroll_handler_state,
     base::TimeDelta durations) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+  SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(durations);
   client_->Reset();
   scheduler_->SetTreePrioritiesAndScrollState(tree_priority,
                                               scroll_handler_state);
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(client_->last_begin_main_frame_args().IsValid());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->last_begin_main_frame_args().IsValid());
   return client_->last_begin_main_frame_args().on_critical_path;
 }
@@ skipping 45 matching lines @@
 }
 
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc