Revert 196708 "Merge cc initialization paths"

[Reason for revert: WebGLInfobarTest.ContextLossInfobarReload
was failing on the Linux Tests bot with high probability]

> 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 is no longer synchronous.
> 
> BUG=233664, 230197
> 
> First commited in r196480. Reverted in r196509 due to exposing
> WebGLInfobarTest that should never have passed on asan. Disable
> them on asan: https://codereview.chromium.org/14499007/
> 
> Review URL: https://chromiumcodereview.appspot.com/12544032

TBR=boliu@chromium.org

Review URL: https://codereview.chromium.org/14386008

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

6 files changed, 80 insertions, 225 deletions

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