Fixing and enhancing OrderedSimpleTaskRunner to allow 100% deterministic tests.

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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
   } while (false)
 
 #define EXPECT_NO_ACTION(client) EXPECT_ACTION("", client, -1, 0)
 
 #define EXPECT_SINGLE_ACTION(action, client) \
   EXPECT_ACTION(action, client, 0, 1)
 
 namespace cc {
 namespace {
 
+class RunWhileImplFrameDeadlinePending
+    : public OrderedSimpleTaskRunner::RunCheck {
+ public:
+  explicit RunWhileImplFrameDeadlinePending(Scheduler* scheduler, bool state)
+      : scheduler_(scheduler), state_(state) {}
+
+  virtual bool Check() OVERRIDE {
+    return scheduler_->BeginImplFrameDeadlinePending() != state_;
+  }
+
+ private:
+  Scheduler* scheduler_;
+  bool state_;
+};
+
 class FakeSchedulerClient;
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler,
                                            FakeSchedulerClient* client);
 
-class TestScheduler : public Scheduler {
- public:
-  static scoped_ptr<TestScheduler> Create(
-      SchedulerClient* client,
-      const SchedulerSettings& scheduler_settings,
-      int layer_tree_host_id,
-      const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner) {
-    return make_scoped_ptr(new TestScheduler(
-        client, scheduler_settings, layer_tree_host_id, impl_task_runner));
-  }
-
-  virtual ~TestScheduler() {}
-
-  bool IsBeginRetroFrameArgsEmpty() const {
-    return begin_retro_frame_args_.empty();
-  }
-
-  bool IsSyntheticBeginFrameSourceActive() const {
-    return synthetic_begin_frame_source_->IsActive();
-  }
-
- private:
-  TestScheduler(
-      SchedulerClient* client,
-      const SchedulerSettings& scheduler_settings,
-      int layer_tree_host_id,
-      const scoped_refptr<base::SingleThreadTaskRunner> & impl_task_runner)
-          : Scheduler(client,
-                      scheduler_settings,
-                      layer_tree_host_id,
-                      impl_task_runner) {
-  }
-};
-
 class FakeSchedulerClient : public SchedulerClient {
  public:
   FakeSchedulerClient()
       : needs_begin_frame_(false),
         automatic_swap_ack_(true),
         swap_contains_incomplete_tile_(false),
-        redraw_will_happen_if_update_visible_tiles_happens_(false) {
+        redraw_will_happen_if_update_visible_tiles_happens_(false),
+        now_src_(TestNowSource::Create()) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
     log_anticipated_draw_time_change_ = false;
   }
 
   TestScheduler* CreateScheduler(const SchedulerSettings& settings) {
-    task_runner_ = new OrderedSimpleTaskRunner;
-    scheduler_ = TestScheduler::Create(this, settings, 0, task_runner_);
+    scheduler_ = TestScheduler::Create(now_src_, this, settings, 0);
+    // Fail if we need to run 100 tasks in a row.
+    task_runner().SetTimeout(100);

[Sami, 2014/08/29 13:13:51]

Please call this something that makes it clear 100 refers to the number of tasks
and not a time duration, e.g., SetTaskCountLimit().

[mithro-old, 2014/09/01 06:19:46]

Done.

I went with "SetRunTaskLimit".

     return scheduler_.get();
   }
 
   // Most tests don't care about DidAnticipatedDrawTimeChange, so only record it
   // for tests that do.
   void set_log_anticipated_draw_time_change(bool log) {
     log_anticipated_draw_time_change_ = log;
   }
   bool needs_begin_frame() { return needs_begin_frame_; }
   int num_draws() const { return num_draws_; }
   int num_actions_() const { return static_cast<int>(actions_.size()); }
   const char* Action(int i) const { return actions_[i]; }
   std::string StateForAction(int i) const { return states_[i]->ToString(); }
   base::TimeTicks posted_begin_impl_frame_deadline() const {
     return posted_begin_impl_frame_deadline_;
   }
 
-  OrderedSimpleTaskRunner& task_runner() { return *task_runner_.get(); }
+  void AdvanceFrame() {
+    bool external_begin_frame =
+        scheduler_->settings().begin_frame_scheduling_enabled &&
+        scheduler_->settings().throttle_frame_production;
+
+    if (external_begin_frame) {
+      TRACE_EVENT1("cc",
+                   "SchedulerUnitTest::AdvanceFrame",
+                   "external_begin_frame",
+                   external_begin_frame);

[Sami, 2014/08/29 13:13:51]

Having |external_begin_frame| here is redundant because of the if-statement.
Should this trace be a the top level?

[mithro-old, 2014/09/01 06:19:46]

Removed.

This trace only existed to make the indentation of the trace output match
between the scheduler_->BeginFrame and task_runner() traces.

+      scheduler_->BeginFrame(CreateBeginFrameArgsForTesting(now_src_));
+    }
+
+    EXPECT_TRUE(task_runner().RunTasksUntil(
+        RunWhileImplFrameDeadlinePending(scheduler_.get(), true)));
+    EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
+  }
+
+  OrderedSimpleTaskRunner& task_runner() { return scheduler_->task_runner(); }
+  scoped_refptr<TestNowSource> now_src() { return now_src_; }

[Sami, 2014/08/29 13:13:51]

Could this be a raw pointer? Nobody needs to hang on to the returned reference,
right?

[mithro-old, 2014/09/01 06:19:46]

Done.

 
   int ActionIndex(const char* action) const {
     for (size_t i = 0; i < actions_.size(); i++)
       if (!strcmp(actions_[i], action))
         return i;
     return -1;
   }
 
   void SetSwapContainsIncompleteTile(bool contain) {
     swap_contains_incomplete_tile_ = contain;
@@ skipping 104 matching lines @@
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   bool log_anticipated_draw_time_change_;
   bool swap_contains_incomplete_tile_;
   bool redraw_will_happen_if_update_visible_tiles_happens_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat> > states_;
   scoped_ptr<TestScheduler> scheduler_;
-  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
+  scoped_refptr<TestNowSource> now_src_;

[Sami, 2014/08/29 13:13:51]

scoped_ptr?

[mithro-old, 2014/09/01 06:19:46]

now_src is currently ref-counted. The fact that the now_src has to be given to
many different locations (scheduler, task runner, anything else which is used)
tends to point towards ref counting?

[Sami, 2014/09/01 11:35:32]

Right, I was just wondering if the the scheduler's life time is enough to keep
it valid for all clients automatically. If there's a risk that some of those
things outlive the scheduler (which they really shouldn't as far as I can see),
then we need ref counting. No need to change that in this patch though.

 };
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler,
                                            FakeSchedulerClient* client) {
-  bool client_initiates_begin_frame =
-      scheduler->settings().begin_frame_scheduling_enabled &&
-      scheduler->settings().throttle_frame_production;
+  TRACE_EVENT0("cc",
+               "SchedulerUnitTest::InitializeOutputSurfaceAndFirstCommit");
 
   scheduler->DidCreateAndInitializeOutputSurface();
   scheduler->SetNeedsCommit();
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   if (scheduler->settings().impl_side_painting)
     scheduler->NotifyReadyToActivate();
+
   // Go through the motions to draw the commit.
-  if (client_initiates_begin_frame)
-    scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
-  else
-    client->task_runner().RunPendingTasks();  // Run posted BeginFrame.
+  client->AdvanceFrame();
 
   // Run the posted deadline task.
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-  client->task_runner().RunPendingTasks();
+  client->task_runner().RunTasksUntil(

[Sami, 2014/08/29 13:13:51]

This reads a bit oddly -- "Run tasks until while impl frame deadline pending =
false". How about:

  RunTasksUntil(CheckImplFrameDeadlinePending(scheduler, false))

(or HasImplFrameDeadlinePending)

[mithro-old, 2014/09/01 06:19:46]

With the other changes this now reads as;
 RunTasks(WhileImplFrameDeadlinePending(false));

+      RunWhileImplFrameDeadlinePending(scheduler, false));
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // We need another BeginImplFrame so Scheduler calls
   // SetNeedsBeginFrame(false).
-  if (client_initiates_begin_frame)
-    scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
-  else
-    client->task_runner().RunPendingTasks();  // Run posted BeginFrame.
+  client->AdvanceFrame();
 
   // Run the posted deadline task.
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-  client->task_runner().RunPendingTasks();
+  client->task_runner().RunTasksUntil(
+      RunWhileImplFrameDeadlinePending(scheduler, false));
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 }
 
 TEST(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
@@ skipping 15 matching lines @@
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   client.Reset();
 
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // If we don't swap on the deadline, we wait for the next BeginFrame.
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // NotifyReadyToCommit should trigger the commit.
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // BeginImplFrame should prepare the draw.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // BeginImplFrame deadline should draw.
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
 
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
 TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   // SetNeedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Now SetNeedsCommit again. Calling here means we need a second commit.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(client.num_actions_(), 0);
   client.Reset();
 
   // Finish the first commit.
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // Because we just swapped, the Scheduler should also request the next
   // BeginImplFrame from the OutputSurface.
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
   // Since another commit is needed, the next BeginImplFrame should initiate
   // the second commit.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
 
   // Finishing the commit before the deadline should post a new deadline task
   // to trigger the deadline early.
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // On the next BeginImplFrame, verify we go back to a quiescent state and
   // no longer request BeginImplFrames.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
@@ skipping 25 matching lines @@
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // We stop requesting BeginImplFrames after a BeginImplFrame where we don't
   // swap.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(client.needs_begin_frame());
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the redraw
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail the draw again.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.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_frame());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatSetNeedsCommitInsideDraw()
@@ skipping 37 matching lines @@
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   EXPECT_FALSE(client.needs_begin_frame());
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_EQ(0, client.num_draws());
   EXPECT_TRUE(client.needs_begin_frame());
 
   client.SetNeedsCommitOnNextDraw();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.SetNeedsCommitOnNextDraw();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(client.needs_begin_frame());
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
 
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
 
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->CommitPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // We stop requesting BeginImplFrames after a BeginImplFrame where we don't
   // swap.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->CommitPending());
   EXPECT_FALSE(client.needs_begin_frame());
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the commit
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail the draw again.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
 
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.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_frame());
 }
 
 TEST(SchedulerTest, NoSwapWhenDrawFails) {
   SchedulerClientThatSetNeedsCommitInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   client.Reset();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Draw successfully, this starts a new frame.
   client.SetNeedsCommitOnNextDraw();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail to draw, this should not start a frame.
   client.SetDrawWillHappen(false);
   client.SetNeedsCommitOnNextDraw();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client.num_draws());
 }
 
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
@@ skipping 18 matching lines @@
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(scheduler->ManageTilesPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
 
   // We have no immediate actions to perform, so the BeginImplFrame should post
   // the deadline task.
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   // On the deadline, he actions should have occured in the right order.
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client.ActionIndex("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->ManageTilesPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // Request a draw. We don't need a ManageTiles yet.
   client.Reset();
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->ManageTilesPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // We have no immediate actions to perform, so the BeginImplFrame should post
   // the deadline task.
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   // Draw. The draw will trigger SetNeedsManageTiles, and
   // then the ManageTiles action will be triggered after the Draw.
   // Afterwards, neither a draw nor ManageTiles are pending.
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client.ActionIndex("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->ManageTilesPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // We need a BeginImplFrame where we don't swap to go idle.
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   EXPECT_FALSE(client.needs_begin_frame());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_EQ(0, client.num_draws());
 
   // Now trigger a ManageTiles outside of a draw. We will then need
   // a begin-frame for the ManageTiles, but we don't need a draw.
   client.Reset();
   EXPECT_FALSE(client.needs_begin_frame());
   scheduler->SetNeedsManageTiles();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_TRUE(scheduler->ManageTilesPending());
   EXPECT_FALSE(scheduler->RedrawPending());
 
   // BeginImplFrame. There will be no draw, only ManageTiles.
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(0, client.num_draws());
   EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 }
 
 // Test that ManageTiles only happens once per frame.  If an external caller
 // initiates it, then the state machine should not ManageTiles on that frame.
 TEST(SchedulerTest, ManageTilesOncePerFrame) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // If DidManageTiles during a frame, then ManageTiles should not occur again.
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(scheduler->ManageTilesPending());
   scheduler->DidManageTiles();  // An explicit ManageTiles.
   EXPECT_FALSE(scheduler->ManageTilesPending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->ManageTilesPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // Next frame without DidManageTiles should ManageTiles with draw.
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client.ActionIndex("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->ManageTilesPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   scheduler->DidManageTiles();  // Corresponds to ScheduledActionManageTiles
 
   // If we get another DidManageTiles within the same frame, we should
   // not ManageTiles on the next frame.
   scheduler->DidManageTiles();  // An explicit ManageTiles.
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(scheduler->ManageTilesPending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // If we get another DidManageTiles, we should not ManageTiles on the next
   // frame. This verifies we don't alternate calling ManageTiles once and twice.
   EXPECT_TRUE(scheduler->ManageTilesPending());
   scheduler->DidManageTiles();  // An explicit ManageTiles.
   EXPECT_FALSE(scheduler->ManageTilesPending());
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(scheduler->ManageTilesPending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   // Next frame without DidManageTiles should ManageTiles with draw.
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
@@ skipping 15 matching lines @@
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   client.SetRedrawWillHappenIfUpdateVisibleTilesHappens(true);
 
   // SetNeedsCommit should begin the frame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
 
   client.Reset();
   scheduler->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client);
 
   client.Reset();
   client.SetSwapContainsIncompleteTile(true);
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
   EXPECT_FALSE(scheduler->RedrawPending());
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionUpdateVisibleTiles", client, 0, 3);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 3);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 2, 3);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   // No more UpdateVisibleTiles().
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   EXPECT_FALSE(client.needs_begin_frame());
 }
 
 TEST(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsManageTilesInDraw client;
   SchedulerSettings default_scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   client.Reset();
   scheduler->SetNeedsRedraw();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.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());
 }
 
 class SchedulerClientWithFixedEstimates : public FakeSchedulerClient {
  public:
   SchedulerClientWithFixedEstimates(
       base::TimeDelta draw_duration,
@@ skipping 35 matching lines @@
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   scheduler->SetSmoothnessTakesPriority(smoothness_takes_priority);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // Impl thread hits deadline before commit finishes.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_FALSE(scheduler->MainThreadIsInHighLatencyMode());
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_FALSE(scheduler->MainThreadIsInHighLatencyMode());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
 
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(scheduler->MainThreadIsInHighLatencyMode(),
             should_send_begin_main_frame);
   EXPECT_EQ(client.HasAction("ScheduledActionSendBeginMainFrame"),
             should_send_begin_main_frame);
 }
 
 TEST(SchedulerTest,
     SkipMainFrameIfHighLatencyAndCanCommitAndActivateBeforeDeadline) {
@@ skipping 36 matching lines @@
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(scheduler->CommitPending());
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   scheduler->SetNeedsRedraw();
 
-  BeginFrameArgs frame_args = CreateBeginFrameArgsForTesting();
+  BeginFrameArgs frame_args = CreateBeginFrameArgsForTesting(client.now_src());
   frame_args.interval = base::TimeDelta::FromMilliseconds(1000);
-  scheduler->BeginFrame(frame_args);
+  {
+    TRACE_EVENT1("cc",
+                 "SchedulerTest::PollForCommitCompletion",
+                 "frame_args",
+                 frame_args.AsValue());
+    scheduler->BeginFrame(frame_args);
+  }
 
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   scheduler->DidSwapBuffers();
   scheduler->DidSwapBuffersComplete();
 
   // At this point, we've drawn a frame. Start another commit, but hold off on
   // the NotifyReadyToCommit for now.
   EXPECT_FALSE(scheduler->CommitPending());
   scheduler->SetNeedsCommit();
-  scheduler->BeginFrame(frame_args);
+  {
+    TRACE_EVENT1("cc",
+                 "SchedulerTest::PollForCommitCompletion",
+                 "frame_args",
+                 frame_args.AsValue());
+    scheduler->BeginFrame(frame_args);
+  }
   EXPECT_TRUE(scheduler->CommitPending());
 
   // Draw and swap the frame, but don't ack the swap to simulate the Browser
   // blocking on the renderer.
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   scheduler->DidSwapBuffers();
 
   // Spin the event loop a few times and make sure we get more
   // DidAnticipateDrawTimeChange calls every time.
   int actions_so_far = client.num_actions_();
 
   // Does three iterations to make sure that the timer is properly repeating.
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
-              client.task_runner().NextPendingTaskDelay().InMicroseconds())
+              client.task_runner().DelayToNextPendingTask().InMicroseconds())
         << scheduler->AsValue()->ToString();
     client.task_runner().RunPendingTasks();
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 
   // Do the same thing after BeginMainFrame starts but still before activation.
   scheduler->NotifyBeginMainFrameStarted();
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
-              client.task_runner().NextPendingTaskDelay().InMicroseconds())
+              client.task_runner().DelayToNextPendingTask().InMicroseconds())
         << scheduler->AsValue()->ToString();
     client.task_runner().RunPendingTasks();
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 }
 
 TEST(SchedulerTest, BeginRetroFrame) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", 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();
+  BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
   args.deadline += base::TimeDelta::FromHours(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc", "SchedulerTest::BeginRetroFrame", "frame_args", args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Queue BeginFrames while we are still handling the previous BeginFrame.
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc", "SchedulerTest::BeginRetroFrame", "frame_args", args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc", "SchedulerTest::BeginRetroFrame", "frame_args", args.AsValue());
+    scheduler->BeginFrame(args);
+  }
 
   // If we don't swap on the deadline, we wait for the next BeginImplFrame.
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // NotifyReadyToCommit should trigger the commit.
   scheduler->NotifyBeginMainFrameStarted();
@@ skipping 45 matching lines @@
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", 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();
+  BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
   args.deadline += base::TimeDelta::FromHours(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1("cc",
+                 "SchedulerTest::BeginRetroFrame_SwapThrottled",
+                 "frame_args",
+                 args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Queue BeginFrame while we are still handling the previous BeginFrame.
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1("cc",
+                 "SchedulerTest::BeginRetroFrame_SwapThrottled",
+                 "frame_args",
+                 args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_NO_ACTION(client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
 
   // NotifyReadyToCommit should trigger the pending commit and draw.
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
@@ skipping 10 matching lines @@
   // but not a BeginMainFrame or draw.
   scheduler->SetNeedsCommit();
   client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Queue BeginFrame while we are still handling the previous BeginFrame.
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1("cc",
+                 "SchedulerTest::BeginRetroFrame_SwapThrottled",
+                 "frame_args",
+                 args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_NO_ACTION(client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Take us out of a swap throttled state.
   scheduler->DidSwapBuffersComplete();
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 1);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // BeginImplFrame deadline should draw.
   scheduler->SetNeedsRedraw();
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
+
+  EXPECT_TRUE(client.task_runner().RunTasksUntil(
+      RunWhileImplFrameDeadlinePending(scheduler, false)));
+
   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 }
 
 void BeginFramesNotFromClient(bool begin_frame_scheduling_enabled,
                               bool throttle_frame_production) {
   FakeSchedulerClient client;
@@ skipping 40 matching lines @@
 
   // BeginImplFrame should prepare the draw.
   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 
   // BeginImplFrame deadline should draw.
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
+  client.task_runner().RunTasksUntil(
+      RunWhileImplFrameDeadlinePending(scheduler, false));
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
 
   // Make sure SetNeedsBeginFrame isn't called on the client
   // when the BeginFrame is no longer needed.
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
-// See: http://crbug.com/380889
-TEST(SchedulerTest, DISABLED_SyntheticBeginFrames) {
+TEST(SchedulerTest, SyntheticBeginFrames) {
   bool begin_frame_scheduling_enabled = false;
   bool throttle_frame_production = true;
   BeginFramesNotFromClient(begin_frame_scheduling_enabled,
                            throttle_frame_production);
 }
 
 TEST(SchedulerTest, VSyncThrottlingDisabled) {
   bool begin_frame_scheduling_enabled = true;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient(begin_frame_scheduling_enabled,
                            throttle_frame_production);
 }
 
-// See: http://crbug.com/380889
-TEST(SchedulerTest, DISABLED_SyntheticBeginFrames_And_VSyncThrottlingDisabled) {
+TEST(SchedulerTest, SyntheticBeginFrames_And_VSyncThrottlingDisabled) {
   bool begin_frame_scheduling_enabled = false;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient(begin_frame_scheduling_enabled,
                            throttle_frame_production);
 }
 
 void BeginFramesNotFromClient_SwapThrottled(bool begin_frame_scheduling_enabled,
                                             bool throttle_frame_production) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
@@ skipping 59 matching lines @@
   // BeginImplFrame deadline should draw.
   scheduler->SetNeedsRedraw();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
-// See: http://crbug.com/380889
-TEST(SchedulerTest, DISABLED_SyntheticBeginFrames_SwapThrottled) {
+TEST(SchedulerTest, SyntheticBeginFrames_SwapThrottled) {
   bool begin_frame_scheduling_enabled = false;
   bool throttle_frame_production = true;
   BeginFramesNotFromClient_SwapThrottled(begin_frame_scheduling_enabled,
                                          throttle_frame_production);
 }
 
 TEST(SchedulerTest, VSyncThrottlingDisabled_SwapThrottled) {
   bool begin_frame_scheduling_enabled = true;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient_SwapThrottled(begin_frame_scheduling_enabled,
                                          throttle_frame_production);
 }
 
-// See: http://crbug.com/380889
 TEST(SchedulerTest,
-     DISABLED_SyntheticBeginFrames_And_VSyncThrottlingDisabled_SwapThrottled) {
+     SyntheticBeginFrames_And_VSyncThrottlingDisabled_SwapThrottled) {
   bool begin_frame_scheduling_enabled = false;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient_SwapThrottled(begin_frame_scheduling_enabled,
                                          throttle_frame_production);
 }
 
 TEST(SchedulerTest, DidLoseOutputSurfaceAfterOutputSurfaceIsInitialized) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
@@ skipping 19 matching lines @@
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
   // SetNeedsCommit should begin the frame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->DidLoseOutputSurface();
   // Do nothing when impl frame is in deadine pending state.
   EXPECT_NO_ACTION(client);
 
   client.Reset();
@@ skipping 18 matching lines @@
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->DidLoseOutputSurface();
   // Do nothing when impl frame is in deadine pending state.
   EXPECT_NO_ACTION(client);
 
   client.Reset();
-  client.task_runner().RunPendingTasks();  // Run posted deadline.
+  // Run posted deadline.
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.task_runner().RunTasksUntil(
+      RunWhileImplFrameDeadlinePending(scheduler, false));
   // OnBeginImplFrameDeadline didn't schedule any actions because main frame is
   // not yet completed.
   EXPECT_NO_ACTION(client);
 
   // BeginImplFrame is not started.
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.task_runner().RunUntilTime(client.now_src()->Now() +
+                                    base::TimeDelta::FromMilliseconds(10));
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   if (impl_side_painting) {
     EXPECT_ACTION("ScheduledActionCommit", client, 0, 3);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client, 1, 3);
     EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client, 2, 3);
@@ skipping 25 matching lines @@
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
 
   client.Reset();
@@ skipping 28 matching lines @@
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   client.Reset();
   scheduler->SetNeedsManageTiles();
   scheduler->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   EXPECT_TRUE(client.needs_begin_frame());
 
   client.Reset();
-  scheduler->BeginFrame(CreateBeginFrameArgsForTesting());
+  client.AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
 
   client.Reset();
   scheduler->DidLoseOutputSurface();
   EXPECT_NO_ACTION(client);
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
@@ skipping 12 matching lines @@
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", 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();
+  BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
   args.deadline += base::TimeDelta::FromHours(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceAfterBeginRetroFramePosted",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Queue BeginFrames while we are still handling the previous BeginFrame.
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceAfterBeginRetroFramePosted",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceAfterBeginRetroFramePosted",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
 
   // If we don't swap on the deadline, we wait for the next BeginImplFrame.
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // NotifyReadyToCommit should trigger the commit.
   client.Reset();
@@ skipping 26 matching lines @@
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", 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();
+  BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
   args.deadline += base::TimeDelta::FromHours(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceDuringBeginRetroFrameRunning",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Queue BeginFrames while we are still handling the previous BeginFrame.
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceDuringBeginRetroFrameRunning",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
   args.frame_time += base::TimeDelta::FromSeconds(1);
-  scheduler->BeginFrame(args);
+  {
+    TRACE_EVENT1(
+        "cc",
+        "SchedulerTest::DidLoseOutputSurfaceDuringBeginRetroFrameRunning",
+        "frame_args",
+        args.AsValue());
+    scheduler->BeginFrame(args);
+  }
 
   // If we don't swap on the deadline, we wait for the next BeginImplFrame.
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_NO_ACTION(client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // NotifyReadyToCommit should trigger the commit.
   client.Reset();
@@ skipping 22 matching lines @@
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // No more BeginRetroFrame because BeginRetroFrame queue is cleared.
   client.Reset();
   client.task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client);
 }
 
-// See: http://crbug.com/380889
-TEST(
-    SchedulerTest,
-    DISABLED_StopBeginFrameAfterDidLoseOutputSurfaceWithSyntheticBeginFrameSource) {
+TEST(SchedulerTest,
+     StopBeginFrameAfterDidLoseOutputSurfaceWithSyntheticBeginFrameSource) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   scheduler_settings.begin_frame_scheduling_enabled = false;
   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
@@ skipping 22 matching lines @@
   EXPECT_FALSE(scheduler->IsSyntheticBeginFrameSourceActive());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   EXPECT_FALSE(scheduler->IsSyntheticBeginFrameSourceActive());
 }
 
 }  // namespace
 }  // namespace cc