Merge cc initialization paths

Code path between first initialization and recreate on context
lost are merged. Do this by changing the first initialization
behavior to match recreate. Now both are kicked off by the
scheduler and blocks the main thread on the impl thread.

The scheduler is started in output surface lost state and
immediately schedules recreation. This means the first
initialization in thread mode is no longer synchronous.

BUG=233664, 230197
This has been tried many many times.
NOTRY=true

Reverted twice due to breaking WebGLInfobarTest:
Committed in r196480. Reverted in r196509.
Committed in r196708. Reverted in r196790.
Fix for WebGLInfobarTest landed in r197235.

WebViewTest.Shim became flaky on chromeos but was already
flaky without this. Disabled it in r197497.

Review URL: https://chromiumcodereview.appspot.com/12544032

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@197550 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 225 insertions, 80 deletions

diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index b088a0f..fb078e9 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -25,8 +25,8 @@ Scheduler::Scheduler(SchedulerClient* client,
 
 Scheduler::~Scheduler() { frame_rate_controller_->SetActive(false); }
 
-void Scheduler::SetCanBeginFrame(bool can) {
-  state_machine_.SetCanBeginFrame(can);
+void Scheduler::SetCanStart() {
+  state_machine_.SetCanStart();
   ProcessScheduledActions();
 }
 
@@ -111,10 +111,10 @@ void Scheduler::DidLoseOutputSurface() {
   ProcessScheduledActions();
 }
 
-void Scheduler::DidRecreateOutputSurface() {
-  TRACE_EVENT0("cc", "Scheduler::DidRecreateOutputSurface");
+void Scheduler::DidCreateAndInitializeOutputSurface() {
+  TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   frame_rate_controller_->DidAbortAllPendingFrames();
-  state_machine_.DidRecreateOutputSurface();
+  state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
 }
 
@@ -184,8 +184,8 @@ void Scheduler::ProcessScheduledActions() {
           frame_rate_controller_->DidBeginFrame();
         break;
       }
-      case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION:
-        client_->ScheduledActionBeginContextRecreation();
+      case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
+        client_->ScheduledActionBeginOutputSurfaceCreation();
         break;
       case SchedulerStateMachine::ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
         client_->ScheduledActionAcquireLayerTexturesForMainThread();
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 08da4ad..548fdcc 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -39,7 +39,7 @@ class SchedulerClient {
   virtual void ScheduledActionCommit() = 0;
   virtual void ScheduledActionCheckForCompletedTileUploads() = 0;
   virtual void ScheduledActionActivatePendingTreeIfNeeded() = 0;
-  virtual void ScheduledActionBeginContextRecreation() = 0;
+  virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() = 0;
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
 
@@ -59,7 +59,7 @@ class CC_EXPORT Scheduler : FrameRateControllerClient {
 
   virtual ~Scheduler();
 
-  void SetCanBeginFrame(bool can);
+  void SetCanStart();
 
   void SetVisible(bool visible);
   void SetCanDraw(bool can_draw);
@@ -91,7 +91,10 @@ class CC_EXPORT Scheduler : FrameRateControllerClient {
   void DidSwapBuffersComplete();
 
   void DidLoseOutputSurface();
-  void DidRecreateOutputSurface();
+  void DidCreateAndInitializeOutputSurface();
+  bool HasInitializedOutputSurface() const {
+    return state_machine_.HasInitializedOutputSurface();
+  }
 
   bool CommitPending() const { return state_machine_.CommitPending(); }
   bool RedrawPending() const { return state_machine_.RedrawPending(); }
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index c55631d..df935aa 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -28,12 +28,13 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       main_thread_needs_layer_textures_(false),
       inside_vsync_(false),
       visible_(false),
-      can_begin_frame_(false),
+      can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       draw_if_possible_failed_(false),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
-      output_surface_state_(OUTPUT_SURFACE_ACTIVE) {}
+      output_surface_state_(OUTPUT_SURFACE_LOST),
+      did_create_and_initialize_first_output_surface_(false) {}
 
 std::string SchedulerStateMachine::ToString() {
   std::string str;
@@ -79,7 +80,7 @@ std::string SchedulerStateMachine::ToString() {
                       main_thread_needs_layer_textures_);
   base::StringAppendF(&str, "inside_vsync_ = %d; ", inside_vsync_);
   base::StringAppendF(&str, "visible_ = %d; ", visible_);
-  base::StringAppendF(&str, "can_begin_frame_ = %d; ", can_begin_frame_);
+  base::StringAppendF(&str, "can_start_ = %d; ", can_start_);
   base::StringAppendF(&str, "can_draw_ = %d; ", can_draw_);
   base::StringAppendF(
       &str, "draw_if_possible_failed_ = %d; ", draw_if_possible_failed_);
@@ -180,9 +181,9 @@ SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
           needs_forced_commit_)
         // TODO(enne): Should probably drop the active tree on force commit.
         return has_pending_tree_ ? ACTION_NONE : ACTION_BEGIN_FRAME;
-      if (output_surface_state_ == OUTPUT_SURFACE_LOST)
-        return ACTION_BEGIN_OUTPUT_SURFACE_RECREATION;
-      if (output_surface_state_ == OUTPUT_SURFACE_RECREATING)
+      if (output_surface_state_ == OUTPUT_SURFACE_LOST && can_start_)
+        return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
+      if (output_surface_state_ == OUTPUT_SURFACE_CREATING)
         return ACTION_NONE;
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
@@ -193,7 +194,8 @@ SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
       if (needs_commit_ &&
-          ((visible_ && can_begin_frame_) || needs_forced_commit_))
+          ((visible_ && output_surface_state_ == OUTPUT_SURFACE_ACTIVE)
+           || needs_forced_commit_))
         // TODO(enne): Should probably drop the active tree on force commit.
         return has_pending_tree_ ? ACTION_NONE : ACTION_BEGIN_FRAME;
       return ACTION_NONE;
@@ -304,10 +306,10 @@ void SchedulerStateMachine::UpdateState(Action action) {
         texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
       return;
 
-    case ACTION_BEGIN_OUTPUT_SURFACE_RECREATION:
+    case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       DCHECK_EQ(commit_state_, COMMIT_STATE_IDLE);
       DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST);
-      output_surface_state_ = OUTPUT_SURFACE_RECREATING;
+      output_surface_state_ = OUTPUT_SURFACE_CREATING;
       return;
 
     case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
@@ -409,7 +411,7 @@ void SchedulerStateMachine::BeginFrameAborted() {
 
 void SchedulerStateMachine::DidLoseOutputSurface() {
   if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
-      output_surface_state_ == OUTPUT_SURFACE_RECREATING)
+      output_surface_state_ == OUTPUT_SURFACE_CREATING)
     return;
   output_surface_state_ = OUTPUT_SURFACE_LOST;
 }
@@ -420,10 +422,20 @@ void SchedulerStateMachine::SetHasPendingTree(bool has_pending_tree) {
 
 void SchedulerStateMachine::SetCanDraw(bool can) { can_draw_ = can; }
 
-void SchedulerStateMachine::DidRecreateOutputSurface() {
-  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_RECREATING);
+void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() {
+  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING);
   output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
-  SetNeedsCommit();
+
+  if (did_create_and_initialize_first_output_surface_) {
+    // TODO(boliu): See if we can remove this when impl-side painting is always
+    // on. Does anything on the main thread need to update after recreate?
+    SetNeedsCommit();
+  }
+  did_create_and_initialize_first_output_surface_ = true;
+}
+
+bool SchedulerStateMachine::HasInitializedOutputSurface() const {
+  return output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 55581a4..fb3908b 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -46,7 +46,7 @@ class CC_EXPORT SchedulerStateMachine {
   enum OutputSurfaceState {
     OUTPUT_SURFACE_ACTIVE,
     OUTPUT_SURFACE_LOST,
-    OUTPUT_SURFACE_RECREATING,
+    OUTPUT_SURFACE_CREATING,
   };
 
   bool CommitPending() const {
@@ -64,7 +64,7 @@ class CC_EXPORT SchedulerStateMachine {
     ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED,
     ACTION_DRAW_IF_POSSIBLE,
     ACTION_DRAW_FORCED,
-    ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+    ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
     ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD,
   };
   Action NextAction() const;
@@ -122,8 +122,8 @@ class CC_EXPORT SchedulerStateMachine {
   // textures to the impl thread by committing the layers.
   void SetMainThreadNeedsLayerTextures();
 
-  // Indicates whether we can successfully begin a frame at this time.
-  void SetCanBeginFrame(bool can) { can_begin_frame_ = can; }
+  // Set that we can create the first OutputSurface and start the scheduler.
+  void SetCanStart() { can_start_ = true; }
 
   // Indicates whether drawing would, at this time, make sense.
   // CanDraw can be used to supress flashes or checkerboarding
@@ -139,7 +139,8 @@ class CC_EXPORT SchedulerStateMachine {
   bool has_pending_tree() const { return has_pending_tree_; }
 
   void DidLoseOutputSurface();
-  void DidRecreateOutputSurface();
+  void DidCreateAndInitializeOutputSurface();
+  bool HasInitializedOutputSurface() const;
 
   // Exposed for testing purposes.
   void SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(int num_draws);
@@ -181,12 +182,13 @@ class CC_EXPORT SchedulerStateMachine {
   bool main_thread_needs_layer_textures_;
   bool inside_vsync_;
   bool visible_;
-  bool can_begin_frame_;
+  bool can_start_;
   bool can_draw_;
   bool has_pending_tree_;
   bool draw_if_possible_failed_;
   TextureState texture_state_;
   OutputSurfaceState output_surface_state_;
+  bool did_create_and_initialize_first_output_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerStateMachine);
 };
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index 6111b76..c4cdd84 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -45,8 +45,10 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded) {
   // If no commit needed, do nothing.
   {
     StateMachine state(default_scheduler_settings);
+    state.SetCanStart();
+    state.UpdateState(state.NextAction());
+    state.DidCreateAndInitializeOutputSurface();
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
-    state.SetCanBeginFrame(true);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
 
@@ -79,7 +81,7 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded) {
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
-    state.SetCanBeginFrame(true);
+    state.SetCanStart();
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
     EXPECT_FALSE(state.VSyncCallbackNeeded());
@@ -88,7 +90,9 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded) {
   // Begin the frame, make sure needs_commit and commit_state update correctly.
   {
     StateMachine state(default_scheduler_settings);
-    state.SetCanBeginFrame(true);
+    state.SetCanStart();
+    state.UpdateState(state.NextAction());
+    state.DidCreateAndInitializeOutputSurface();
     state.SetVisible(true);
     state.UpdateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
@@ -111,7 +115,9 @@ TEST(SchedulerStateMachineTest,
      TestFailedDrawSetsNeedsCommitAndDoesNotDrawAgain) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsRedraw();
@@ -138,7 +144,10 @@ TEST(SchedulerStateMachineTest,
      TestsetNeedsRedrawDuringFailedDrawDoesNotRemoveNeedsRedraw) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
+
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsRedraw();
@@ -168,7 +177,9 @@ TEST(SchedulerStateMachineTest,
      TestCommitAfterFailedDrawAllowsDrawInSameFrame) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -207,7 +218,9 @@ TEST(SchedulerStateMachineTest,
      TestCommitAfterFailedAndSuccessfulDrawDoesNotAllowDrawInSameFrame) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -257,7 +270,9 @@ TEST(SchedulerStateMachineTest,
      TestFailedDrawsWillEventuallyForceADrawAfterTheNextCommit) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(1);
@@ -297,7 +312,9 @@ TEST(SchedulerStateMachineTest,
 TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedNextVSync) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -328,6 +345,9 @@ TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedNextVSync) {
 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();
@@ -362,6 +382,9 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnVSync) {
   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) {
@@ -387,6 +410,9 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnVSync) {
   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;
@@ -429,6 +455,9 @@ TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible) {
     // There shouldn't be any drawing regardless of vsync.
     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);
@@ -457,6 +486,9 @@ TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw) {
     // There shouldn't be any drawing regardless of vsync.
     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);
@@ -475,9 +507,11 @@ TEST(SchedulerStateMachineTest,
      TestCanRedrawWithWaitingForFirstDrawMakesProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetCommitState(
       SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
-  state.SetCanBeginFrame(true);
   state.SetNeedsCommit();
   state.SetNeedsRedraw(true);
   state.SetVisible(true);
@@ -488,7 +522,9 @@ TEST(SchedulerStateMachineTest,
 TEST(SchedulerStateMachineTest, TestsetNeedsCommitIsNotLost) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetNeedsCommit();
   state.SetVisible(true);
   state.SetCanDraw(true);
@@ -530,7 +566,9 @@ TEST(SchedulerStateMachineTest, TestsetNeedsCommitIsNotLost) {
 TEST(SchedulerStateMachineTest, TestFullCycle) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -576,7 +614,9 @@ TEST(SchedulerStateMachineTest, TestFullCycle) {
 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -626,6 +666,9 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 }
@@ -633,7 +676,9 @@ TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
 TEST(SchedulerStateMachineTest, TestGoesInvisibleBeforeBeginFrameCompletes) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -672,16 +717,39 @@ TEST(SchedulerStateMachineTest, TestGoesInvisibleBeforeBeginFrameCompletes) {
             state.CommitState());
 }
 
+TEST(SchedulerStateMachineTest, TestFirstContextCreation) {
+  SchedulerSettings default_scheduler_settings;
+  StateMachine state(default_scheduler_settings);
+  state.SetCanStart();
+  state.SetVisible(true);
+  state.SetCanDraw(true);
+
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
+            state.NextAction());
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
+  EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
+
+  // Check that the first init does not SetNeedsCommit.
+  state.SetNeedsCommit();
+  EXPECT_NE(SchedulerStateMachine::ACTION_NONE, state.NextAction());
+}
+
 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
+
   state.SetVisible(true);
   state.SetCanDraw(true);
 
+  EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
+            state.NextAction());
   state.DidLoseOutputSurface();
 
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
@@ -689,7 +757,7 @@ TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Recreate the context.
-  state.DidRecreateOutputSurface();
+  state.DidCreateAndInitializeOutputSurface();
 
   // When the context is recreated, we should begin a commit.
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.NextAction());
@@ -700,13 +768,17 @@ TEST(SchedulerStateMachineTest,
      TestContextLostWhenIdleAndCommitRequestedWhileRecreating) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
+  EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
+            state.NextAction());
   state.DidLoseOutputSurface();
 
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
@@ -718,7 +790,7 @@ TEST(SchedulerStateMachineTest,
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Recreate the context
-  state.DidRecreateOutputSurface();
+  state.DidCreateAndInitializeOutputSurface();
 
   // When the context is recreated, we should begin a commit
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.NextAction());
@@ -738,7 +810,9 @@ TEST(SchedulerStateMachineTest,
 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -774,10 +848,10 @@ TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
 
   // Expect to be told to begin context recreation, independent of vsync state.
   state.DidEnterVSync();
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.DidLeaveVSync();
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
 }
 
@@ -785,7 +859,9 @@ TEST(SchedulerStateMachineTest,
      TestContextLostWhileCommitInProgressAndAnotherCommitRequested) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -822,16 +898,19 @@ TEST(SchedulerStateMachineTest,
 
   // Expect to be told to begin context recreation, independent of vsync state
   state.DidEnterVSync();
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.DidLeaveVSync();
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  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);
 
@@ -848,7 +927,7 @@ TEST(SchedulerStateMachineTest, TestFinishAllRenderingWhileContextLost) {
   state.SetNeedsForcedRedraw(false);
 
   // Expect to be told to begin context recreation, independent of vsync state
-  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION,
+  EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.UpdateState(state.NextAction());
 
@@ -862,7 +941,9 @@ TEST(SchedulerStateMachineTest, TestFinishAllRenderingWhileContextLost) {
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenInvisibleAndForceCommit) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(false);
   state.SetNeedsCommit();
   state.SetNeedsForcedCommit();
@@ -873,6 +954,9 @@ TEST(SchedulerStateMachineTest,
      TestBeginFrameWhenCanBeginFrameFalseAndForceCommit) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsCommit();
@@ -883,7 +967,9 @@ TEST(SchedulerStateMachineTest,
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(false);
   state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
   state.SetNeedsCommit();
@@ -901,7 +987,9 @@ TEST(SchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress) {
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenForcedCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(false);
   state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
   state.SetNeedsCommit();
@@ -922,7 +1010,9 @@ TEST(SchedulerStateMachineTest, TestBeginFrameWhenForcedCommitInProgress) {
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenContextLost) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
   state.SetNeedsCommit();
@@ -934,7 +1024,9 @@ TEST(SchedulerStateMachineTest, TestBeginFrameWhenContextLost) {
 TEST(SchedulerStateMachineTest, TestImmediateBeginFrame) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -967,7 +1059,9 @@ TEST(SchedulerStateMachineTest, TestImmediateBeginFrame) {
 TEST(SchedulerStateMachineTest, TestImmediateBeginFrameDuringCommit) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -1004,7 +1098,9 @@ TEST(SchedulerStateMachineTest, TestImmediateBeginFrameDuringCommit) {
 TEST(SchedulerStateMachineTest, ImmediateBeginFrameWhileInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
@@ -1048,7 +1144,9 @@ TEST(SchedulerStateMachineTest, ImmediateBeginFrameWhileInvisible) {
 TEST(SchedulerStateMachineTest, ImmediateBeginFrameWhileCantDraw) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(false);
 
@@ -1105,7 +1203,9 @@ TEST(SchedulerStateMachineTest, ReportIfNotDrawing) {
 TEST(SchedulerStateMachineTest, ReportIfNotDrawingFromAcquiredTextures) {
   SchedulerSettings default_scheduler_settings;
   SchedulerStateMachine state(default_scheduler_settings);
-  state.SetCanBeginFrame(true);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.DidCreateAndInitializeOutputSurface();
   state.SetCanDraw(true);
   state.SetVisible(true);
   EXPECT_FALSE(state.DrawSuspendedUntilCommit());
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index a2c968c..3a8e8e3 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -69,8 +69,8 @@ class FakeSchedulerClient : public SchedulerClient {
   virtual void ScheduledActionActivatePendingTreeIfNeeded() OVERRIDE {
     actions_.push_back("ScheduledActionActivatePendingTreeIfNeeded");
   }
-  virtual void ScheduledActionBeginContextRecreation() OVERRIDE {
-    actions_.push_back("ScheduledActionBeginContextRecreation");
+  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
+    actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
   }
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE {
     actions_.push_back("ScheduledActionAcquireLayerTexturesForMainThread");
@@ -92,10 +92,15 @@ TEST(SchedulerTest, RequestCommit) {
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
+  EXPECT_EQ(1, client.num_actions_());
+  EXPECT_STREQ("ScheduledActionBeginOutputSurfaceCreation", client.Action(0));
+  client.Reset();
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   // SetNeedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(1, client.num_actions_());
@@ -129,10 +134,15 @@ TEST(SchedulerTest, RequestCommitAfterBeginFrame) {
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
+  EXPECT_EQ(1, client.num_actions_());
+  EXPECT_STREQ("ScheduledActionBeginOutputSurfaceCreation", client.Action(0));
+  client.Reset();
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   // SetNedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(1, client.num_actions_());
@@ -166,10 +176,15 @@ TEST(SchedulerTest, TextureAcquisitionCollision) {
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
+  EXPECT_EQ(1, client.num_actions_());
+  EXPECT_STREQ("ScheduledActionBeginOutputSurfaceCreation", client.Action(0));
+  client.Reset();
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   scheduler->SetNeedsCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(2, client.num_actions_());
@@ -210,10 +225,15 @@ TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
+  EXPECT_EQ(1, client.num_actions_());
+  EXPECT_STREQ("ScheduledActionBeginOutputSurfaceCreation", client.Action(0));
+  client.Reset();
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   scheduler->SetNeedsCommit();
   scheduler->BeginFrameComplete();
   scheduler->SetMainThreadNeedsLayerTextures();
@@ -257,7 +277,7 @@ class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
-  virtual void ScheduledActionBeginContextRecreation() OVERRIDE {}
+  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 
  protected:
@@ -277,9 +297,10 @@ TEST(SchedulerTest, RequestRedrawInsideDraw) {
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -307,9 +328,11 @@ TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
@@ -365,7 +388,7 @@ class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient {
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
-  virtual void ScheduledActionBeginContextRecreation() OVERRIDE {}
+  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 
  protected:
@@ -383,9 +406,10 @@ TEST(SchedulerTest, RequestCommitInsideDraw) {
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -414,9 +438,11 @@ TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
+
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
@@ -462,9 +488,10 @@ TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
                         controller.PassAs<FrameRateController>(),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
 
   EXPECT_EQ(0, controller_ptr->NumFramesPending());
 
@@ -530,9 +557,10 @@ TEST(SchedulerTest, RecreateOutputSurfaceClearsPendingDrawCount) {
                         controller.PassAs<FrameRateController>(),
                         default_scheduler_settings);
 
-  scheduler->SetCanBeginFrame(true);
+  scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
+  scheduler->DidCreateAndInitializeOutputSurface();
 
   // Draw successfully, this starts a new frame.
   scheduler->SetNeedsRedraw();
@@ -543,7 +571,7 @@ TEST(SchedulerTest, RecreateOutputSurfaceClearsPendingDrawCount) {
   // Verifying that it's 1 so that we know that it's reset on recreate.
   EXPECT_EQ(1, controller_ptr->NumFramesPending());
 
-  scheduler->DidRecreateOutputSurface();
+  scheduler->DidCreateAndInitializeOutputSurface();
   EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }