cc: Add BeginFrameArgs

cc/scheduler/scheduler_state_machine_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_state_machine.h"
 
 #include "cc/scheduler/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ skipping 38 matching lines @@
     state.DidCreateAndInitializeOutputSurface();
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
 
     EXPECT_FALSE(state.BeginFrameNeededToDrawByImplThread());
 
     state.DidLeaveBeginFrame();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
     EXPECT_FALSE(state.BeginFrameNeededToDrawByImplThread());
-    state.DidEnterBeginFrame();
+    state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   }
 
   // If commit requested but can_start is still false, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
 
     EXPECT_FALSE(state.BeginFrameNeededToDrawByImplThread());
 
     state.DidLeaveBeginFrame();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
     EXPECT_FALSE(state.BeginFrameNeededToDrawByImplThread());
-    state.DidEnterBeginFrame();
+    state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   }
 
   // If commit requested, begin a main frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
     state.SetCanStart();
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
@@ skipping 30 matching lines @@
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.RedrawPending());
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
   // We're drawing now.
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   EXPECT_FALSE(state.RedrawPending());
   EXPECT_FALSE(state.CommitPending());
 
   // Failing the draw makes us require a commit.
   state.DidDrawIfPossibleCompleted(false);
@@ skipping 11 matching lines @@
   SchedulerStateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
 
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.RedrawPending());
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
   // We're drawing now.
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   EXPECT_FALSE(state.RedrawPending());
   EXPECT_FALSE(state.CommitPending());
 
   // While still in the same begin frame callback on the main thread,
   // set needs redraw again. This should not redraw.
@@ skipping 21 matching lines @@
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(
       SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD);
   EXPECT_TRUE(state.CommitPending());
 
   // Then initiate a draw.
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   EXPECT_TRUE(state.RedrawPending());
 
   // Fail the draw.
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.DidDrawIfPossibleCompleted(false);
   EXPECT_TRUE(state.RedrawPending());
   // But the commit is ongoing.
   EXPECT_TRUE(state.CommitPending());
@@ skipping 22 matching lines @@
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(
       SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD);
   EXPECT_TRUE(state.CommitPending());
 
   // Then initiate a draw.
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   EXPECT_TRUE(state.RedrawPending());
 
   // Fail the draw.
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.DidDrawIfPossibleCompleted(false);
   EXPECT_TRUE(state.RedrawPending());
   // But the commit is ongoing.
   EXPECT_TRUE(state.CommitPending());
@@ skipping 34 matching lines @@
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(
       SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD);
   EXPECT_TRUE(state.CommitPending());
 
   // Then initiate a draw.
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   EXPECT_TRUE(state.RedrawPending());
 
   // Fail the draw.
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.DidDrawIfPossibleCompleted(false);
   EXPECT_TRUE(state.RedrawPending());
   // But the commit is ongoing.
   EXPECT_TRUE(state.CommitPending());
@@ skipping 15 matching lines @@
   SchedulerStateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Start a draw.
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   EXPECT_TRUE(state.RedrawPending());
 
   // Fail the draw.
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.DidDrawIfPossibleCompleted(false);
   EXPECT_TRUE(state.RedrawPending());
 
   // We should not be trying to draw again now, but we have a commit pending.
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
 
   state.DidLeaveBeginFrame();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
   // We should try to draw again in the next begin frame on the impl thread.
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
 }
 
 TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsRedraw();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 
   // While still in the same begin frame for the impl thread, set needs redraw
   // again. This should not redraw.
   state.SetNeedsRedraw();
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Move to another frame. This should now draw.
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
   EXPECT_TRUE(state.BeginFrameNeededToDrawByImplThread());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
   EXPECT_FALSE(state.BeginFrameNeededToDrawByImplThread());
 }
 
 TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginFrame) {
   SchedulerSettings default_scheduler_settings;
 
   // When not in BeginFrame, or in BeginFrame but not visible,
   // don't draw.
   size_t num_commit_states =
       sizeof(all_commit_states) / sizeof(SchedulerStateMachine::CommitState);
   for (size_t i = 0; i < num_commit_states; ++i) {
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
       state.UpdateState(state.NextAction());
       state.DidCreateAndInitializeOutputSurface();
       state.SetCommitState(all_commit_states[i]);
       bool visible = j;
       if (!visible) {
-        state.DidEnterBeginFrame();
+        state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
         state.SetVisible(false);
       } else {
         state.SetVisible(true);
       }
 
       // Case 1: needs_commit=false
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
       // Case 2: needs_commit=true
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 
   // When in BeginFrame, or not in BeginFrame but needs_forced_dedraw
   // set, should always draw except if you're ready to commit, in which case
   // commit.
   for (size_t i = 0; i < num_commit_states; ++i) {
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
       state.UpdateState(state.NextAction());
       state.DidCreateAndInitializeOutputSurface();
       state.SetCanDraw(true);
       state.SetCommitState(all_commit_states[i]);
       bool forced_draw = j;
       if (!forced_draw) {
-        state.DidEnterBeginFrame();
+        state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
         state.SetNeedsRedraw(true);
         state.SetVisible(true);
       } else {
         state.SetNeedsForcedRedraw(true);
       }
 
       SchedulerStateMachine::Action expected_action;
       if (all_commit_states[i] !=
           SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT) {
         expected_action =
@@ skipping 25 matching lines @@
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
       state.UpdateState(state.NextAction());
       state.DidCreateAndInitializeOutputSurface();
       state.SetCommitState(all_commit_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       state.SetNeedsForcedRedraw(false);
       if (j == 1)
-        state.DidEnterBeginFrame();
+        state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
       // Case 1: needs_commit=false.
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
       // Case 2: needs_commit=true.
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
@@ skipping 10 matching lines @@
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
       state.UpdateState(state.NextAction());
       state.DidCreateAndInitializeOutputSurface();
       state.SetCommitState(all_commit_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       state.SetNeedsForcedRedraw(false);
       if (j == 1)
-        state.DidEnterBeginFrame();
+        state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
 
       state.SetCanDraw(false);
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 }
 
 TEST(SchedulerStateMachineTest,
      TestCanRedrawWithWaitingForFirstDrawMakesProgress) {
@@ skipping 34 matching lines @@
   EXPECT_TRUE(state.NeedsCommit());
 
   // Let the frame finish.
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
 
   // Expect to commit regardless of BeginFrame state.
   state.DidLeaveBeginFrame();
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
 
   // Commit and make sure we draw on next BeginFrame
   state.UpdateState(SchedulerStateMachine::ACTION_COMMIT);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
 
@@ skipping 34 matching lines @@
   // Commit.
   state.UpdateState(SchedulerStateMachine::ACTION_COMMIT);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
   EXPECT_TRUE(state.NeedsRedraw());
 
   // Expect to do nothing until BeginFrame.
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // At BeginFrame, draw.
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
   EXPECT_FALSE(state.NeedsRedraw());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 }
@@ skipping 33 matching lines @@
   // Commit.
   state.UpdateState(SchedulerStateMachine::ACTION_COMMIT);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
   EXPECT_TRUE(state.NeedsRedraw());
 
   // Expect to do nothing until BeginFrame.
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // At BeginFrame, draw.
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
   EXPECT_FALSE(state.NeedsRedraw());
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
@@ skipping 133 matching lines @@
   state.DidCreateAndInitializeOutputSurface();
 
   // When the context is recreated, we should begin a commit
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Once the context is recreated, whether we draw should be based on
   // SetCanDraw.
   state.SetNeedsRedraw(true);
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.SetCanDraw(false);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetCanDraw(true);
   state.DidLeaveBeginFrame();
 }
 
 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Get a commit in flight.
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Set damage and expect a draw.
   state.SetNeedsRedraw(true);
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidLeaveBeginFrame();
 
   // Cause a lost context while the begin frame is in flight
   // for the main thread.
   state.DidLoseOutputSurface();
 
   // Ask for another draw. Expect nothing happens.
   state.SetNeedsRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Finish the frame, and commit.
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Expect to be told to begin context recreation, independent of
   // BeginFrame state.
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.DidLeaveBeginFrame();
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
 }
 
 TEST(SchedulerStateMachineTest,
      TestContextLostWhileCommitInProgressAndAnotherCommitRequested) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Get a commit in flight.
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Set damage and expect a draw.
   state.SetNeedsRedraw(true);
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidLeaveBeginFrame();
 
   // Cause a lost context while the begin frame is in flight
   // for the main thread.
   state.DidLoseOutputSurface();
 
   // Ask for another draw and also set needs commit. Expect nothing happens.
   state.SetNeedsRedraw(true);
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Finish the frame, and commit.
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Expect to be told to begin context recreation, independent of
   // BeginFrame state
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.DidLeaveBeginFrame();
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
 }
 
 TEST(SchedulerStateMachineTest, TestFinishAllRenderingWhileContextLost) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Cause a lost context lost.
   state.DidLoseOutputSurface();
 
   // Ask a forced redraw and verify it ocurrs.
   state.SetNeedsForcedRedraw(true);
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.DidLeaveBeginFrame();
 
   // Clear the forced redraw bit.
   state.SetNeedsForcedRedraw(false);
 
   // Expect to be told to begin context recreation, independent of
   // BeginFrame state
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Ask a forced redraw and verify it ocurrs.
   state.SetNeedsForcedRedraw(true);
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.DidLeaveBeginFrame();
 }
 
 TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.DidCreateAndInitializeOutputSurface();
@@ skipping 113 matching lines @@
   state.UpdateState(state.NextAction());
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW,
             state.CommitState());
 
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetNeedsForcedRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 
   // Should be waiting for the normal begin frame from the main thread.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
             state.CommitState());
@@ skipping 18 matching lines @@
   state.UpdateState(state.NextAction());
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW,
             state.CommitState());
 
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetNeedsForcedRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 
   // Should be waiting for the normal begin frame from the main thread.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
             state.CommitState()) << state.ToString();
@@ skipping 18 matching lines @@
   state.FinishCommit();
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW,
             state.CommitState());
 
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetNeedsForcedRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 
   // Should be waiting for the main thread's begin frame.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
             state.CommitState()) << state.ToString();
@@ skipping 25 matching lines @@
   state.FinishCommit();
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
   state.UpdateState(state.NextAction());
 
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW,
             state.CommitState());
 
-  state.DidEnterBeginFrame();
+  state.DidEnterBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetNeedsForcedRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveBeginFrame();
 }
 
 TEST(SchedulerStateMachineTest, ReportIfNotDrawing) {
   SchedulerSettings default_scheduler_settings;
@@ skipping 49 matching lines @@
   EXPECT_TRUE(state.DrawSuspendedUntilCommit());
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
 
   state.UpdateState(state.NextAction());
   EXPECT_FALSE(state.DrawSuspendedUntilCommit());
 }
 
 }  // namespace
 }  // namespace cc