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

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

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

23 files changed, 729 insertions, 480 deletions

diff --git a/cc/layers/nine_patch_layer_unittest.cc b/cc/layers/nine_patch_layer_unittest.cc
index f120e51..cf3b5a37 100644
--- a/cc/layers/nine_patch_layer_unittest.cc
+++ b/cc/layers/nine_patch_layer_unittest.cc
@@ -65,7 +65,7 @@ TEST_F(NinePatchLayerTest, TriggerFullUploadOnceWhenChangingBitmap) {
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   EXPECT_EQ(test_layer->layer_tree_host(), layer_tree_host_.get());
 
-  layer_tree_host_->InitializeRendererIfNeeded();
+  layer_tree_host_->InitializeOutputSurfaceIfNeeded();
 
   PriorityCalculator calculator;
   ResourceUpdateQueue queue;
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 148a202..780be5e 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -287,8 +287,6 @@ class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
   void SetScrollbarBounds(gfx::Size bounds) { bounds_ = bounds; }
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->InitializeRendererIfNeeded();
-
     scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
     scrollbar_layer_ =
         ScrollbarLayer::Create(scrollbar.Pass(),
@@ -370,7 +368,7 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
-    layer_tree_host_->InitializeRendererIfNeeded();
+    layer_tree_host_->InitializeOutputSurfaceIfNeeded();
     layer_tree_host_->contents_texture_manager()->
         SetMaxMemoryLimitBytes(1024 * 1024);
     layer_tree_host_->SetRootLayer(layer_tree_root);
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 6283bcb..7209ea8 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -60,7 +60,7 @@ class TiledLayerTest : public testing::Test {
                                              scoped_ptr<Thread>(NULL));
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
-    layer_tree_host_->InitializeRendererIfNeeded();
+    layer_tree_host_->InitializeOutputSurfaceIfNeeded();
     layer_tree_host_->SetRootLayer(Layer::Create());
 
     DebugScopedSetImplThreadAndMainThreadBlocked
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());
 }
 
diff --git a/cc/test/fake_proxy.cc b/cc/test/fake_proxy.cc
index 0ec3ab2..9a3fc9d 100644
--- a/cc/test/fake_proxy.cc
+++ b/cc/test/fake_proxy.cc
@@ -6,17 +6,20 @@
 
 namespace cc {
 
+void FakeProxy::SetLayerTreeHost(LayerTreeHost* host) {
+  layer_tree_host_ = host;
+}
+
 bool FakeProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
   return true;
 }
 
 bool FakeProxy::IsStarted() const { return true; }
 
-bool FakeProxy::InitializeOutputSurface() { return true; }
-
-bool FakeProxy::InitializeRenderer() { return true; }
-
-bool FakeProxy::RecreateOutputSurface() { return true; }
+void FakeProxy::CreateAndInitializeOutputSurface() {
+  DCHECK(layer_tree_host_);
+  layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(true);
+}
 
 const RendererCapabilities& FakeProxy::GetRendererCapabilities() const {
   return capabilities_;
diff --git a/cc/test/fake_proxy.h b/cc/test/fake_proxy.h
index d94092f..712a70e 100644
--- a/cc/test/fake_proxy.h
+++ b/cc/test/fake_proxy.h
@@ -14,16 +14,17 @@ namespace cc {
 class FakeProxy : public Proxy {
  public:
   explicit FakeProxy(scoped_ptr<Thread> impl_thread)
-      : Proxy(impl_thread.Pass()) {}
+      : Proxy(impl_thread.Pass()),
+        layer_tree_host_(NULL) {}
+
+  void SetLayerTreeHost(LayerTreeHost* host);
 
   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
   virtual void FinishAllRendering() OVERRIDE {}
   virtual bool IsStarted() const OVERRIDE;
-  virtual bool InitializeOutputSurface() OVERRIDE;
   virtual void SetSurfaceReady() OVERRIDE {}
   virtual void SetVisible(bool visible) OVERRIDE {}
-  virtual bool InitializeRenderer() OVERRIDE;
-  virtual bool RecreateOutputSurface() OVERRIDE;
+  virtual void CreateAndInitializeOutputSurface() OVERRIDE;
   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
   virtual void SetNeedsAnimate() OVERRIDE {}
   virtual void SetNeedsCommit() OVERRIDE {}
@@ -31,7 +32,7 @@ class FakeProxy : public Proxy {
   virtual void SetDeferCommits(bool defer_commits) OVERRIDE {}
   virtual void MainThreadHasStoppedFlinging() OVERRIDE {}
   virtual bool CommitRequested() const OVERRIDE;
-  virtual void Start() OVERRIDE {}
+  virtual void Start(scoped_ptr<OutputSurface> first_output_surface) OVERRIDE {}
   virtual void Stop() OVERRIDE {}
   virtual void ForceSerializeOnSwapBuffers() OVERRIDE {}
   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
@@ -46,6 +47,7 @@ class FakeProxy : public Proxy {
  private:
   RendererCapabilities capabilities_;
   size_t max_partial_texture_updates_;
+  LayerTreeHost* layer_tree_host_;
 };
 
 }  // namespace cc
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 96c4b7b..626e2b6 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -256,8 +256,8 @@ class LayerTreeHostClientForTesting : public LayerTreeHostClient {
     test_hooks_->DidRecreateOutputSurface(succeeded);
   }
 
-  virtual void WillRetryRecreateOutputSurface() OVERRIDE {
-    test_hooks_->WillRetryRecreateOutputSurface();
+  virtual void DidFailToInitializeOutputSurface() OVERRIDE {
+    test_hooks_->DidFailToInitializeOutputSurface();
   }
 
   virtual scoped_ptr<InputHandler> CreateInputHandler() OVERRIDE {
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index c1a4b67..be865c3 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -53,7 +53,7 @@ class TestHooks : public WebKit::WebAnimationDelegate {
   virtual void Animate(base::TimeTicks monotonic_time) {}
   virtual void Layout() {}
   virtual void DidRecreateOutputSurface(bool succeeded) {}
-  virtual void WillRetryRecreateOutputSurface() {}
+  virtual void DidFailToInitializeOutputSurface() {}
   virtual void DidAddAnimation() {}
   virtual void DidCommit() {}
   virtual void DidCommitAndDrawFrame() {}
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 2a4c932..8eaf6e5 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -84,9 +84,8 @@ LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client,
       client_(client),
       commit_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
-      renderer_can_be_initialized_(true),
-      renderer_initialized_(false),
-      output_surface_lost_(false),
+      output_surface_can_be_initialized_(true),
+      output_surface_lost_(true),
       num_failed_recreate_attempts_(0),
       settings_(settings),
       debug_state_(settings.initial_debug_state),
@@ -123,18 +122,25 @@ bool LayerTreeHost::InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing) {
 bool LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 
+  scoped_ptr<OutputSurface> output_surface(CreateOutputSurface());
+  if (!output_surface)
+    return false;
+
   proxy_ = proxy.Pass();
-  proxy_->Start();
-  return proxy_->InitializeOutputSurface();
+  proxy_->Start(output_surface.Pass());
+  return true;
 }
 
 LayerTreeHost::~LayerTreeHost() {
+  TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
   if (root_layer_)
     root_layer_->SetLayerTreeHost(NULL);
-  DCHECK(proxy_);
-  DCHECK(proxy_->IsMainThread());
-  TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
-  proxy_->Stop();
+
+  if (proxy_) {
+    DCHECK(proxy_->IsMainThread());
+    proxy_->Stop();
+  }
+
   s_num_layer_tree_instances--;
   RateLimiterMap::iterator it = rate_limiters_.begin();
   if (it != rate_limiters_.end())
@@ -152,72 +158,65 @@ void LayerTreeHost::SetSurfaceReady() {
   proxy_->SetSurfaceReady();
 }
 
-void LayerTreeHost::InitializeRenderer() {
-  TRACE_EVENT0("cc", "LayerTreeHost::InitializeRenderer");
-  if (!proxy_->InitializeRenderer()) {
-    // Uh oh, better tell the client that we can't do anything with this output
-    // surface.
-    renderer_can_be_initialized_ = false;
-    client_->DidRecreateOutputSurface(false);
-    return;
-  }
-
-  // Update settings_ based on capabilities that we got back from the renderer.
-  settings_.accelerate_painting =
-      proxy_->GetRendererCapabilities().using_accelerated_painting;
-
-  // Update settings_ based on partial update capability.
-  size_t max_partial_texture_updates = 0;
-  if (proxy_->GetRendererCapabilities().allow_partial_texture_updates &&
-      !settings_.impl_side_painting) {
-    max_partial_texture_updates = std::min(
-        settings_.max_partial_texture_updates,
-        proxy_->MaxPartialTextureUpdates());
-  }
-  settings_.max_partial_texture_updates = max_partial_texture_updates;
+LayerTreeHost::CreateResult
+LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(bool success) {
+  TRACE_EVENT1("cc",
+               "LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted",
+               "success",
+               success);
 
-  contents_texture_manager_ = PrioritizedResourceManager::Create(proxy_.get());
-  surface_memory_placeholder_ =
-      contents_texture_manager_->CreateTexture(gfx::Size(), GL_RGBA);
+  DCHECK(output_surface_lost_);
+  if (success) {
+    output_surface_lost_ = false;
 
-  renderer_initialized_ = true;
-}
+    // Update settings_ based on capabilities that we got back from the
+    // renderer.
+    settings_.accelerate_painting =
+        proxy_->GetRendererCapabilities().using_accelerated_painting;
+
+    // Update settings_ based on partial update capability.
+    size_t max_partial_texture_updates = 0;
+    if (proxy_->GetRendererCapabilities().allow_partial_texture_updates &&
+        !settings_.impl_side_painting) {
+      max_partial_texture_updates = std::min(
+          settings_.max_partial_texture_updates,
+          proxy_->MaxPartialTextureUpdates());
+    }
+    settings_.max_partial_texture_updates = max_partial_texture_updates;
 
-LayerTreeHost::RecreateResult LayerTreeHost::RecreateOutputSurface() {
-  TRACE_EVENT0("cc", "LayerTreeHost::RecreateOutputSurface");
-  DCHECK(output_surface_lost_);
+    if (!contents_texture_manager_) {
+      contents_texture_manager_ =
+          PrioritizedResourceManager::Create(proxy_.get());
+      surface_memory_placeholder_ =
+          contents_texture_manager_->CreateTexture(gfx::Size(), GL_RGBA);
+    }
 
-  if (proxy_->RecreateOutputSurface()) {
     client_->DidRecreateOutputSurface(true);
-    output_surface_lost_ = false;
-    return RecreateSucceeded;
+    return CreateSucceeded;
   }
 
-  client_->WillRetryRecreateOutputSurface();
+  // Failure path.
+
+  client_->DidFailToInitializeOutputSurface();
 
   // Tolerate a certain number of recreation failures to work around races
   // in the output-surface-lost machinery.
-  num_failed_recreate_attempts_++;
-  if (num_failed_recreate_attempts_ < 5) {
-    // FIXME: The single thread does not self-schedule output surface
-    // recreation. So force another recreation attempt to happen by requesting
-    // another commit.
-    if (!proxy_->HasImplThread())
-      SetNeedsCommit();
-    return RecreateFailedButTryAgain;
+  ++num_failed_recreate_attempts_;
+  if (num_failed_recreate_attempts_ >= 5) {
+    // We have tried too many times to recreate the output surface. Tell the
+    // host to fall back to software rendering.
+    output_surface_can_be_initialized_ = false;
+    client_->DidRecreateOutputSurface(false);
+    return CreateFailedAndGaveUp;
   }
 
-  // We have tried too many times to recreate the output surface. Tell the
-  // host to fall back to software rendering.
-  renderer_can_be_initialized_ = false;
-  client_->DidRecreateOutputSurface(false);
-  return RecreateFailedAndGaveUp;
+  return CreateFailedButTryAgain;
 }
 
 void LayerTreeHost::DeleteContentsTexturesOnImplThread(
     ResourceProvider* resource_provider) {
   DCHECK(proxy_->IsImplThread());
-  if (renderer_initialized_)
+  if (contents_texture_manager_)
     contents_texture_manager_->ClearAllMemory(resource_provider);
 }
 
@@ -499,8 +498,12 @@ scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(proxy_->IsMainThread());
-  output_surface_lost_ = true;
+
+  if (output_surface_lost_)
+    return;
+
   num_failed_recreate_attempts_ = 0;
+  output_surface_lost_ = true;
   SetNeedsCommit();
 }
 
@@ -513,8 +516,6 @@ bool LayerTreeHost::CompositeAndReadback(void* pixels,
 }
 
 void LayerTreeHost::FinishAllRendering() {
-  if (!renderer_initialized_)
-    return;
   proxy_->FinishAllRendering();
 }
 
@@ -720,27 +721,18 @@ void LayerTreeHost::ScheduleComposite() {
   client_->ScheduleComposite();
 }
 
-bool LayerTreeHost::InitializeRendererIfNeeded() {
-  if (!renderer_can_be_initialized_)
+bool LayerTreeHost::InitializeOutputSurfaceIfNeeded() {
+  if (!output_surface_can_be_initialized_)
     return false;
 
-  if (!renderer_initialized_) {
-    InitializeRenderer();
-    // If we couldn't initialize, then bail since we're returning to software
-    // mode.
-    if (!renderer_initialized_)
-      return false;
-  }
-  if (output_surface_lost_) {
-    if (RecreateOutputSurface() != RecreateSucceeded)
-      return false;
-  }
-  return true;
+  if (output_surface_lost_)
+    proxy_->CreateAndInitializeOutputSurface();
+  return !output_surface_lost_;
 }
 
 void LayerTreeHost::UpdateLayers(ResourceUpdateQueue* queue,
                                  size_t memory_allocation_limit_bytes) {
-  DCHECK(renderer_initialized_);
+  DCHECK(!output_surface_lost_);
 
   if (!root_layer())
     return;
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index f94066d..13e03d2 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -88,6 +88,7 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
                                           scoped_ptr<Thread> impl_thread);
   virtual ~LayerTreeHost();
 
+  // TODO(boliu): Rename to SetLayerTreeHostClientReady.
   void SetSurfaceReady();
 
   // Returns true if any LayerTreeHost is alive.
@@ -117,18 +118,19 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
   virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* client);
   void DidLoseOutputSurface();
-  enum RecreateResult {
-    RecreateSucceeded,
-    RecreateFailedButTryAgain,
-    RecreateFailedAndGaveUp,
+  bool output_surface_lost() const { return output_surface_lost_; }
+  enum CreateResult {
+    CreateSucceeded,
+    CreateFailedButTryAgain,
+    CreateFailedAndGaveUp,
   };
-  RecreateResult RecreateOutputSurface();
+  CreateResult OnCreateAndInitializeOutputSurfaceAttempted(bool success);
   void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); }
   void DidCompleteSwapBuffers() { client_->DidCompleteSwapBuffers(); }
   void DeleteContentsTexturesOnImplThread(ResourceProvider* resource_provider);
   virtual void AcquireLayerTextures();
   // Returns false if we should abort this frame due to initialization failure.
-  bool InitializeRendererIfNeeded();
+  bool InitializeOutputSurfaceIfNeeded();
   void UpdateLayers(ResourceUpdateQueue* queue,
                     size_t contents_memory_limit_bytes);
 
@@ -259,7 +261,6 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
 
  private:
   bool InitializeProxy(scoped_ptr<Proxy> proxy);
-  void InitializeRenderer();
 
   bool PaintLayerContents(const LayerList& render_surface_layer_list,
                           ResourceUpdateQueue* quue);
@@ -292,8 +293,7 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
   int commit_number_;
   scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
 
-  bool renderer_can_be_initialized_;
-  bool renderer_initialized_;
+  bool output_surface_can_be_initialized_;
   bool output_surface_lost_;
   int num_failed_recreate_attempts_;
 
diff --git a/cc/trees/layer_tree_host_client.h b/cc/trees/layer_tree_host_client.h
index 4bc913c..df68e47 100644
--- a/cc/trees/layer_tree_host_client.h
+++ b/cc/trees/layer_tree_host_client.h
@@ -28,6 +28,7 @@ class LayerTreeHostClient {
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float page_scale) = 0;
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() = 0;
+  // TODO(boliu): Rename to DidInitializeOutputSurface.
   virtual void DidRecreateOutputSurface(bool success) = 0;
   virtual scoped_ptr<InputHandler> CreateInputHandler() = 0;
   virtual void WillCommit() = 0;
@@ -46,7 +47,7 @@ class LayerTreeHostClient {
       OffscreenContextProviderForCompositorThread() = 0;
 
   // This hook is for testing.
-  virtual void WillRetryRecreateOutputSurface() {}
+  virtual void DidFailToInitializeOutputSurface() {}
 
  protected:
   virtual ~LayerTreeHostClient() {}
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index b81bd047..ae7f1a0 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -795,9 +795,6 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
 
     layer_tree_host()->SetRootLayer(root_layer_);
 
-    ASSERT_TRUE(layer_tree_host()->InitializeRendererIfNeeded());
-    ResourceUpdateQueue queue;
-    layer_tree_host()->UpdateLayers(&queue, std::numeric_limits<size_t>::max());
     PostSetNeedsCommitToMainThread();
   }
 
@@ -1228,8 +1225,6 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFinishAllRendering);
 
 class LayerTreeHostTestCompositeAndReadbackCleanup : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestCompositeAndReadbackCleanup() {}
-
   virtual void BeginTest() OVERRIDE {
     Layer* root_layer = layer_tree_host()->root_layer();
 
@@ -1700,9 +1695,10 @@ class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
                          const LayerTreeSettings& settings,
-                         scoped_ptr<Proxy> proxy)
+                         scoped_ptr<FakeProxy> proxy)
       : LayerTreeHost(client, settings) {
-    EXPECT_TRUE(InitializeForTesting(proxy.Pass()));
+        proxy->SetLayerTreeHost(this);
+    EXPECT_TRUE(InitializeForTesting(proxy.PassAs<Proxy>()));
   }
 };
 
@@ -1719,8 +1715,8 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.PassAs<Proxy>());
-    EXPECT_TRUE(host.InitializeRendererIfNeeded());
+    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(0u, host.settings().max_partial_texture_updates);
   }
@@ -1738,8 +1734,8 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.PassAs<Proxy>());
-    EXPECT_TRUE(host.InitializeRendererIfNeeded());
+    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(5u, host.settings().max_partial_texture_updates);
   }
@@ -1757,8 +1753,8 @@ TEST(LayerTreeHostTest, LimitPartialUpdates) {
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
-    LayerTreeHostWithProxy host(&client, settings, proxy.PassAs<Proxy>());
-    EXPECT_TRUE(host.InitializeRendererIfNeeded());
+    LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
+    EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(10u, host.settings().max_partial_texture_updates);
   }
@@ -1772,7 +1768,7 @@ TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
 
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
-  EXPECT_TRUE(host->InitializeRendererIfNeeded());
+  EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
@@ -1784,7 +1780,7 @@ TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
 
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
-  EXPECT_TRUE(host->InitializeRendererIfNeeded());
+  EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
@@ -1796,7 +1792,7 @@ TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
 
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
-  EXPECT_TRUE(host->InitializeRendererIfNeeded());
+  EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
 }
 
@@ -1809,7 +1805,7 @@ TEST(LayerTreeHostTest,
 
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
-  EXPECT_TRUE(host->InitializeRendererIfNeeded());
+  EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
 }
 
@@ -1847,7 +1843,6 @@ class LayerTreeHostTestCapturePicture : public LayerTreeHostTest {
     layer_tree_host()->SetViewportSize(bounds_);
     layer_tree_host()->SetRootLayer(layer_);
 
-    EXPECT_TRUE(layer_tree_host()->InitializeRendererIfNeeded());
     PostSetNeedsCommitToMainThread();
   }
 
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 20f5114..1658dea 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -5,6 +5,7 @@
 #include "cc/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
+#include "cc/base/thread_impl.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/io_surface_layer.h"
@@ -20,6 +21,7 @@
 #include "cc/test/fake_context_provider.h"
 #include "cc/test/fake_delegated_renderer_layer.h"
 #include "cc/test/fake_delegated_renderer_layer_impl.h"
+#include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_scrollbar_layer.h"
 #include "cc/test/fake_scrollbar_theme_painter.h"
@@ -58,10 +60,11 @@ class LayerTreeHostContextTest : public LayerTreeTest {
         times_to_lose_on_recreate_(0),
         times_to_fail_create_offscreen_(0),
         times_to_fail_recreate_offscreen_(0),
-        times_to_expect_recreate_retried_(0),
-        times_recreate_retried_(0),
+        times_to_expect_create_failed_(0),
+        times_create_failed_(0),
         times_offscreen_created_(0),
-        committed_at_least_once_(false) {
+        committed_at_least_once_(false),
+        context_should_support_io_surface_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
@@ -78,24 +81,29 @@ class LayerTreeHostContextTest : public LayerTreeTest {
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
-      ExpectRecreateToRetry();
+      ExpectCreateToFail();
       return scoped_ptr<OutputSurface>();
     }
 
     scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
+    if (context_should_support_io_surface_) {
+      context3d_->set_have_extension_io_surface(true);
+      context3d_->set_have_extension_egl_image(true);
+    }
+
     if (times_to_fail_initialize_) {
       --times_to_fail_initialize_;
       // Make the context get lost during reinitialization.
       // The number of times MakeCurrent succeeds is not important, and
       // can be changed if needed to make this pass with future changes.
       context3d_->set_times_make_current_succeeds(2);
-      ExpectRecreateToRetry();
+      ExpectCreateToFail();
     } else if (times_to_lose_on_create_) {
       --times_to_lose_on_create_;
       LoseContext();
-      ExpectRecreateToRetry();
+      ExpectCreateToFail();
     }
 
     return FakeOutputSurface::Create3d(
@@ -110,7 +118,7 @@ class LayerTreeHostContextTest : public LayerTreeTest {
 
     if (times_to_fail_create_offscreen_) {
       --times_to_fail_create_offscreen_;
-      ExpectRecreateToRetry();
+      ExpectCreateToFail();
       return scoped_ptr<TestWebGraphicsContext3D>();
     }
 
@@ -153,10 +161,8 @@ class LayerTreeHostContextTest : public LayerTreeTest {
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame,
-                                     bool result)
-      OVERRIDE {
-    bool expect_success = !frame->has_no_damage;
-    EXPECT_EQ(expect_success, result);
+                                     bool result) OVERRIDE {
+    EXPECT_TRUE(result);
     if (!times_to_lose_during_draw_)
       return result;
 
@@ -193,18 +199,17 @@ class LayerTreeHostContextTest : public LayerTreeTest {
     times_to_fail_recreate_offscreen_ = 0;
   }
 
-  virtual void WillRetryRecreateOutputSurface() OVERRIDE {
-    ++times_recreate_retried_;
+  virtual void DidFailToInitializeOutputSurface() OVERRIDE {
+    ++times_create_failed_;
   }
 
   virtual void TearDown() OVERRIDE {
     LayerTreeTest::TearDown();
-    EXPECT_EQ(times_to_expect_recreate_retried_, times_recreate_retried_);
+    EXPECT_EQ(times_to_expect_create_failed_, times_create_failed_);
   }
 
-  void ExpectRecreateToRetry() {
-    if (committed_at_least_once_)
-      ++times_to_expect_recreate_retried_;
+  void ExpectCreateToFail() {
+    ++times_to_expect_create_failed_;
   }
 
  protected:
@@ -219,10 +224,11 @@ class LayerTreeHostContextTest : public LayerTreeTest {
   int times_to_lose_on_recreate_;
   int times_to_fail_create_offscreen_;
   int times_to_fail_recreate_offscreen_;
-  int times_to_expect_recreate_retried_;
-  int times_recreate_retried_;
+  int times_to_expect_create_failed_;
+  int times_create_failed_;
   int times_offscreen_created_;
   bool committed_at_least_once_;
+  bool context_should_support_io_surface_;
 
   scoped_refptr<FakeContextProvider> offscreen_contexts_main_thread_;
   scoped_refptr<FakeContextProvider> offscreen_contexts_compositor_thread_;
@@ -235,7 +241,8 @@ class LayerTreeHostContextTestLostContextSucceeds
       : LayerTreeHostContextTest(),
         test_case_(0),
         num_losses_(0),
-        recovered_context_(true) {}
+        recovered_context_(true),
+        first_initialized_(false) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
@@ -243,7 +250,12 @@ class LayerTreeHostContextTestLostContextSucceeds
 
   virtual void DidRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
-    ++num_losses_;
+
+    if (first_initialized_)
+      ++num_losses_;
+    else
+      first_initialized_ = true;
+
     recovered_context_ = true;
   }
 
@@ -381,6 +393,7 @@ class LayerTreeHostContextTestLostContextSucceeds
   size_t test_case_;
   int num_losses_;
   bool recovered_context_;
+  bool first_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLostContextSucceeds);
@@ -524,6 +537,9 @@ class LayerTreeHostContextTestOffscreenContextFails
     cc::ContextProvider* contexts =
         host_impl->resource_provider()->offscreen_context_provider();
     EXPECT_FALSE(contexts);
+
+    // This did not lead to create failure.
+    times_to_expect_create_failed_ = 0;
     EndTest();
   }
 
@@ -542,7 +558,8 @@ class LayerTreeHostContextTestLostContextFails
  public:
   LayerTreeHostContextTestLostContextFails()
       : LayerTreeHostContextTest(),
-        num_commits_(0) {
+        num_commits_(0),
+        first_initialized_(false) {
     times_to_lose_during_commit_ = 1;
   }
 
@@ -551,8 +568,12 @@ class LayerTreeHostContextTestLostContextFails
   }
 
   virtual void DidRecreateOutputSurface(bool succeeded) OVERRIDE {
-    EXPECT_FALSE(succeeded);
-    EndTest();
+    if (first_initialized_) {
+      EXPECT_FALSE(succeeded);
+      EndTest();
+    } else {
+      first_initialized_ = true;
+    }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -577,6 +598,7 @@ class LayerTreeHostContextTestLostContextFails
 
  private:
   int num_commits_;
+  bool first_initialized_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
@@ -632,18 +654,26 @@ class LayerTreeHostContextTestFinishAllRenderingAfterLoss
  public:
   virtual void BeginTest() OVERRIDE {
     // Lose the context until the compositor gives up on it.
+    first_initialized_ = false;
     times_to_lose_during_commit_ = 1;
     times_to_fail_reinitialize_ = 10;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidRecreateOutputSurface(bool succeeded) OVERRIDE {
-    EXPECT_FALSE(succeeded);
-    layer_tree_host()->FinishAllRendering();
-    EndTest();
+    if (first_initialized_) {
+      EXPECT_FALSE(succeeded);
+      layer_tree_host()->FinishAllRendering();
+      EndTest();
+    } else {
+      first_initialized_ = true;
+    }
   }
 
   virtual void AfterTest() OVERRIDE {}
+
+ private:
+  bool first_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ -890,9 +920,6 @@ class LayerTreeHostContextTestDontUseLostResources
     : public LayerTreeHostContextTest {
  public:
   virtual void SetupTree() OVERRIDE {
-    context3d_->set_have_extension_io_surface(true);
-    context3d_->set_have_extension_egl_image(true);
-
     scoped_refptr<Layer> root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetAnchorPoint(gfx::PointF());
@@ -982,6 +1009,7 @@ class LayerTreeHostContextTestDontUseLostResources
   }
 
   virtual void BeginTest() OVERRIDE {
+    context_should_support_io_surface_ = true;
     PostSetNeedsCommitToMainThread();
   }
 
@@ -1101,13 +1129,13 @@ class LayerTreeHostContextTestDontUseLostResources
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestDontUseLostResources);
 
-class LayerTreeHostContextTestFailsImmediately
+class LayerTreeHostContextTestLosesFirstOutputSurface
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostContextTestFailsImmediately()
-      : LayerTreeHostContextTest() {}
-
-  virtual ~LayerTreeHostContextTestFailsImmediately() {}
+  LayerTreeHostContextTestLosesFirstOutputSurface() {
+    // Always fail. This needs to be set before LayerTreeHost is created.
+    times_to_lose_on_create_ = 1000;
+  }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
@@ -1115,22 +1143,98 @@ class LayerTreeHostContextTestFailsImmediately
 
   virtual void AfterTest() OVERRIDE {}
 
-  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() OVERRIDE {
-    scoped_ptr<TestWebGraphicsContext3D> context =
-        LayerTreeHostContextTest::CreateContext3d();
-    context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
-                                 GL_INNOCENT_CONTEXT_RESET_ARB);
-    return context.Pass();
-  }
-
   virtual void DidRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_FALSE(succeeded);
+
     // If we make it this far without crashing, we pass!
     EndTest();
   }
+
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    EXPECT_TRUE(false);
+  }
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestFailsImmediately);
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostContextTestLosesFirstOutputSurface);
+
+class LayerTreeHostContextTestRetriesFirstInitializationAndSucceeds
+    : public LayerTreeHostContextTest {
+ public:
+  virtual void AfterTest() OVERRIDE {}
+
+  virtual void BeginTest() OVERRIDE {
+    times_to_fail_initialize_ = 2;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    EndTest();
+  }
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostContextTestRetriesFirstInitializationAndSucceeds);
+
+class LayerTreeHostContextTestRetryWorksWithForcedInit
+    : public LayerTreeHostContextTestRetriesFirstInitializationAndSucceeds {
+ public:
+  virtual void DidFailToInitializeOutputSurface() OVERRIDE {
+    LayerTreeHostContextTestRetriesFirstInitializationAndSucceeds
+        ::DidFailToInitializeOutputSurface();
+
+    if (times_create_failed_ == 1) {
+      // CompositeAndReadback force recreates the output surface, which should
+      // fail.
+      char pixels[4];
+      EXPECT_FALSE(layer_tree_host()->CompositeAndReadback(
+            &pixels, gfx::Rect(1, 1)));
+    }
+  }
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostContextTestRetryWorksWithForcedInit);
+
+class LayerTreeHostContextTestCompositeAndReadbackBeforeOutputSurfaceInit
+    : public LayerTreeHostContextTest {
+ public:
+  virtual void BeginTest() OVERRIDE {
+    // This must be called immediately after creating LTH, before the first
+    // OutputSurface is initialized.
+    ASSERT_TRUE(layer_tree_host()->output_surface_lost());
+
+    times_output_surface_created_ = 0;
+
+    char pixels[4];
+    EXPECT_TRUE(layer_tree_host()->CompositeAndReadback(
+          &pixels, gfx::Rect(1, 1)));
+    EXPECT_EQ(1, times_output_surface_created_);
+
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidRecreateOutputSurface(bool succeeded) OVERRIDE {
+    EXPECT_TRUE(succeeded);
+    ++times_output_surface_created_;
+  }
+
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    EndTest();
+  }
+
+  virtual void AfterTest() OVERRIDE {
+    // Should not try to create output surface again after successfully
+    // created by CompositeAndReadback.
+    EXPECT_EQ(1, times_output_surface_created_);
+  }
+
+ private:
+  int times_output_surface_created_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostContextTestCompositeAndReadbackBeforeOutputSurfaceInit);
 
 class ImplSidePaintingLayerTreeHostContextTest
     : public LayerTreeHostContextTest {
@@ -1261,5 +1365,38 @@ class LayerTreeHostContextTestFailsToCreateSurface
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestFailsToCreateSurface);
 
+// Not reusing LayerTreeTest because it expects creating LTH to always succeed.
+class LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface
+    : public testing::Test,
+      public FakeLayerTreeHostClient {
+ public:
+  LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface()
+      : FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D) {}
+
+  // FakeLayerTreeHostClient
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface() {
+    return scoped_ptr<OutputSurface>();
+  }
+
+  void RunTest(bool threaded) {
+    scoped_ptr<base::Thread> impl_thread;
+    scoped_ptr<cc::Thread> impl_ccthread(NULL);
+    if (threaded) {
+      impl_thread.reset(new base::Thread("LayerTreeTest"));
+      impl_ccthread = cc::ThreadImpl::CreateForDifferentThread(
+          impl_thread->message_loop_proxy());
+      ASSERT_TRUE(impl_ccthread);
+    }
+
+    LayerTreeSettings settings;
+    scoped_ptr<LayerTreeHost> layer_tree_host =
+        LayerTreeHost::Create(this, settings, impl_ccthread.Pass());
+    EXPECT_FALSE(layer_tree_host);
+  }
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface);
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/trees/proxy.h b/cc/trees/proxy.h
index 14c6f80..d2d678f 100644
--- a/cc/trees/proxy.h
+++ b/cc/trees/proxy.h
@@ -21,6 +21,7 @@ class Vector2d;
 
 namespace cc {
 
+class OutputSurface;
 class Thread;
 struct RendererCapabilities;
 
@@ -53,24 +54,16 @@ class CC_EXPORT Proxy {
 
   virtual bool IsStarted() const = 0;
 
-  // Attempts to initialize a context to use for rendering. Returns false if
-  // the context could not be created.  The context will not be used and no
-  // frames may be produced until InitializeRenderer() is called.
-  virtual bool InitializeOutputSurface() = 0;
-
   // Indicates that the compositing surface associated with our context is
   // ready to use.
   virtual void SetSurfaceReady() = 0;
 
   virtual void SetVisible(bool visible) = 0;
 
-  // Attempts to initialize the layer renderer. Returns false if the context
-  // isn't usable for compositing.
-  virtual bool InitializeRenderer() = 0;
-
-  // Attempts to recreate the context and layer renderer after a context lost.
-  // Returns false if the renderer couldn't be reinitialized.
-  virtual bool RecreateOutputSurface() = 0;
+  // Attempts to recreate the context and renderer synchronously after the
+  // output surface is lost. Calls
+  // LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted with the result.
+  virtual void CreateAndInitializeOutputSurface() = 0;
 
   virtual const RendererCapabilities& GetRendererCapabilities() const = 0;
 
@@ -87,7 +80,8 @@ class CC_EXPORT Proxy {
 
   virtual bool CommitRequested() const = 0;
 
-  virtual void Start() = 0;  // Must be called before using the proxy.
+  // Must be called before using the proxy.
+  virtual void Start(scoped_ptr<OutputSurface> first_output_surface) = 0;
   virtual void Stop() = 0;   // Must be called before deleting the proxy.
 
   // Forces 3D commands on all contexts to wait for all previous SwapBuffers
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 7534b4d..d66905c 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -25,9 +25,7 @@ scoped_ptr<Proxy> SingleThreadProxy::Create(LayerTreeHost* layer_tree_host) {
 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host)
     : Proxy(scoped_ptr<Thread>(NULL)),
       layer_tree_host_(layer_tree_host),
-      output_surface_lost_(false),
       created_offscreen_context_provider_(false),
-      renderer_initialized_(false),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
@@ -39,16 +37,18 @@ SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host)
       << "Threaded compositing must be enabled to use impl-side painting.";
 }
 
-void SingleThreadProxy::Start() {
+void SingleThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
+  DCHECK(first_output_surface);
   DebugScopedSetImplThread impl(this);
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
+  first_output_surface_ = first_output_surface.Pass();
 }
 
 SingleThreadProxy::~SingleThreadProxy() {
   TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy");
   DCHECK(Proxy::IsMainThread());
-  DCHECK(!layer_tree_host_impl_.get() &&
-         !layer_tree_host_);  // make sure Stop() got called.
+  // Make sure Stop() got called or never Started.
+  DCHECK(!layer_tree_host_impl_);
 }
 
 bool SingleThreadProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
@@ -90,16 +90,6 @@ bool SingleThreadProxy::IsStarted() const {
   return layer_tree_host_impl_;
 }
 
-bool SingleThreadProxy::InitializeOutputSurface() {
-  DCHECK(Proxy::IsMainThread());
-  scoped_ptr<OutputSurface> output_surface =
-      layer_tree_host_->CreateOutputSurface();
-  if (!output_surface)
-    return false;
-  output_surface_before_initialization_ = output_surface.Pass();
-  return true;
-}
-
 void SingleThreadProxy::SetSurfaceReady() {
   // Scheduling is controlled by the embedder in the single thread case, so
   // nothing to do.
@@ -110,51 +100,47 @@ void SingleThreadProxy::SetVisible(bool visible) {
   layer_tree_host_impl_->SetVisible(visible);
 }
 
-bool SingleThreadProxy::InitializeRenderer() {
+void SingleThreadProxy::CreateAndInitializeOutputSurface() {
+  TRACE_EVENT0(
+      "cc", "SingleThreadProxy::CreateAndInitializeOutputSurface");
   DCHECK(Proxy::IsMainThread());
-  DCHECK(output_surface_before_initialization_.get());
-  {
-    DebugScopedSetImplThread impl(this);
-    bool ok = layer_tree_host_impl_->InitializeRenderer(
-        output_surface_before_initialization_.Pass());
-    if (ok) {
-      renderer_initialized_ = true;
-      renderer_capabilities_for_main_thread_ =
-          layer_tree_host_impl_->GetRendererCapabilities();
-    }
 
-    return ok;
+  scoped_ptr<OutputSurface> output_surface = first_output_surface_.Pass();
+  if (!output_surface)
+    output_surface = layer_tree_host_->CreateOutputSurface();
+  if (!output_surface) {
+    OnOutputSurfaceInitializeAttempted(false);
+    return;
   }
-}
-
-bool SingleThreadProxy::RecreateOutputSurface() {
-  TRACE_EVENT0("cc", "SingleThreadProxy::RecreateContext");
-  DCHECK(Proxy::IsMainThread());
-  DCHECK(output_surface_lost_);
 
-  scoped_ptr<OutputSurface> output_surface =
-      layer_tree_host_->CreateOutputSurface();
-  if (!output_surface)
-    return false;
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (created_offscreen_context_provider_) {
     offscreen_context_provider =
         layer_tree_host_->client()->OffscreenContextProviderForMainThread();
-    if (!offscreen_context_provider)
-      return false;
+    if (!offscreen_context_provider) {
+      OnOutputSurfaceInitializeAttempted(false);
+      return;
+    }
   }
 
-  bool initialized;
   {
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
-    initialized =
-        layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
+  }
+
+  bool initialized;
+  {
+    DebugScopedSetImplThread impl(this);
+
+    DCHECK(output_surface);
+    initialized = layer_tree_host_impl_->InitializeRenderer(
+        output_surface.Pass());
     if (initialized) {
       renderer_capabilities_for_main_thread_ =
           layer_tree_host_impl_->GetRendererCapabilities();
+
       layer_tree_host_impl_->resource_provider()->
           set_offscreen_context_provider(offscreen_context_provider);
     } else if (offscreen_context_provider) {
@@ -162,15 +148,21 @@ bool SingleThreadProxy::RecreateOutputSurface() {
     }
   }
 
-  if (initialized)
-    output_surface_lost_ = false;
+  OnOutputSurfaceInitializeAttempted(initialized);
+}
 
-  return initialized;
+void SingleThreadProxy::OnOutputSurfaceInitializeAttempted(bool success) {
+  LayerTreeHost::CreateResult result =
+      layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
+  if (result == LayerTreeHost::CreateFailedButTryAgain) {
+    // Force another recreation attempt to happen by requesting another commit.
+    SetNeedsCommit();
+  }
 }
 
 const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
-  DCHECK(renderer_initialized_);
-  // Note: this gets called during the commit by the "impl" thread.
+  DCHECK(Proxy::IsMainThread());
+  DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_for_main_thread_;
 }
 
@@ -364,8 +356,10 @@ scoped_ptr<base::Value> SingleThreadProxy::AsValue() const {
 void SingleThreadProxy::ForceSerializeOnSwapBuffers() {
   {
     DebugScopedSetImplThread impl(this);
-    if (renderer_initialized_)
+    if (layer_tree_host_impl_->renderer()) {
+      DCHECK(!layer_tree_host_->output_surface_lost());
       layer_tree_host_impl_->renderer()->DoNoOp();
+    }
   }
 }
 
@@ -375,7 +369,7 @@ bool SingleThreadProxy::CommitAndComposite(
     LayerTreeHostImpl::FrameData* frame) {
   DCHECK(Proxy::IsMainThread());
 
-  if (!layer_tree_host_->InitializeRendererIfNeeded())
+  if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded())
     return false;
 
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
@@ -415,7 +409,9 @@ bool SingleThreadProxy::DoComposite(
     base::TimeTicks frame_begin_time,
     gfx::Rect device_viewport_damage_rect,
     LayerTreeHostImpl::FrameData* frame) {
-  DCHECK(!output_surface_lost_);
+  DCHECK(!layer_tree_host_->output_surface_lost());
+
+  bool lost_output_surface = false;
   {
     DebugScopedSetImplThread impl(this);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
@@ -440,7 +436,7 @@ bool SingleThreadProxy::DoComposite(
     layer_tree_host_impl_->PrepareToDraw(frame, device_viewport_damage_rect);
     layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
     layer_tree_host_impl_->DidDrawAllLayers(*frame);
-    output_surface_lost_ = layer_tree_host_impl_->IsContextLost();
+    lost_output_surface = layer_tree_host_impl_->IsContextLost();
 
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
@@ -448,7 +444,7 @@ bool SingleThreadProxy::DoComposite(
     layer_tree_host_impl_->BeginNextFrame();
   }
 
-  if (output_surface_lost_) {
+  if (lost_output_surface) {
     cc::ContextProvider* offscreen_contexts = layer_tree_host_impl_->
         resource_provider()->offscreen_context_provider();
     if (offscreen_contexts)
diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h
index d345a15..7e9b4ad 100644
--- a/cc/trees/single_thread_proxy.h
+++ b/cc/trees/single_thread_proxy.h
@@ -26,11 +26,9 @@ class SingleThreadProxy : public Proxy, LayerTreeHostImplClient {
   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
   virtual void FinishAllRendering() OVERRIDE;
   virtual bool IsStarted() const OVERRIDE;
-  virtual bool InitializeOutputSurface() OVERRIDE;
   virtual void SetSurfaceReady() OVERRIDE;
   virtual void SetVisible(bool visible) OVERRIDE;
-  virtual bool InitializeRenderer() OVERRIDE;
-  virtual bool RecreateOutputSurface() OVERRIDE;
+  virtual void CreateAndInitializeOutputSurface() OVERRIDE;
   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
   virtual void SetNeedsAnimate() OVERRIDE;
   virtual void SetNeedsCommit() OVERRIDE;
@@ -38,7 +36,7 @@ class SingleThreadProxy : public Proxy, LayerTreeHostImplClient {
   virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
   virtual bool CommitRequested() const OVERRIDE;
   virtual void MainThreadHasStoppedFlinging() OVERRIDE {}
-  virtual void Start() OVERRIDE;
+  virtual void Start(scoped_ptr<OutputSurface> first_output_surface) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
   virtual void AcquireLayerTextures() OVERRIDE {}
@@ -80,6 +78,7 @@ class SingleThreadProxy : public Proxy, LayerTreeHostImplClient {
  private:
   explicit SingleThreadProxy(LayerTreeHost* layer_tree_host);
 
+  void OnOutputSurfaceInitializeAttempted(bool success);
   bool CommitAndComposite(base::TimeTicks frame_begin_time,
                           gfx::Rect device_viewport_damage_rect,
                           LayerTreeHostImpl::FrameData* frame);
@@ -95,17 +94,15 @@ class SingleThreadProxy : public Proxy, LayerTreeHostImplClient {
 
   // Accessed on main thread only.
   LayerTreeHost* layer_tree_host_;
-  bool output_surface_lost_;
   bool created_offscreen_context_provider_;
 
-  // Holds on to the context between initializeContext() and
-  // InitializeRenderer() calls. Shouldn't be used for anything else.
-  scoped_ptr<OutputSurface> output_surface_before_initialization_;
+  // Holds the first output surface passed from Start. Should not be used for
+  // anything else.
+  scoped_ptr<OutputSurface> first_output_surface_;
 
   // Used on the Thread, but checked on main thread during
   // initialization/shutdown.
   scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl_;
-  bool renderer_initialized_;
   RendererCapabilities renderer_capabilities_for_main_thread_;
 
   bool next_frame_is_newly_committed_frame_;
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 587baac..628360f 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -46,7 +46,6 @@ ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
-      renderer_initialized_(false),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
@@ -68,6 +67,7 @@ ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
+  DCHECK(layer_tree_host_);
 }
 
 ThreadProxy::~ThreadProxy() {
@@ -82,7 +82,7 @@ bool ThreadProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
   DCHECK(layer_tree_host_);
   DCHECK(!defer_commits_);
 
-  if (!layer_tree_host_->InitializeRendererIfNeeded()) {
+  if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded()) {
     TRACE_EVENT0("cc", "CompositeAndReadback_EarlyOut_LR_Uninitialized");
     return false;
   }
@@ -149,19 +149,6 @@ bool ThreadProxy::IsStarted() const {
   return started_;
 }
 
-bool ThreadProxy::InitializeOutputSurface() {
-  TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurface");
-  scoped_ptr<OutputSurface> context = layer_tree_host_->CreateOutputSurface();
-  if (!context)
-    return false;
-
-  Proxy::ImplThread()->PostTask(
-      base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
-                 impl_thread_weak_ptr_,
-                 base::Passed(&context)));
-  return true;
-}
-
 void ThreadProxy::SetSurfaceReady() {
   TRACE_EVENT0("cc", "ThreadProxy::SetSurfaceReady");
   Proxy::ImplThread()->PostTask(base::Bind(
@@ -170,7 +157,7 @@ void ThreadProxy::SetSurfaceReady() {
 
 void ThreadProxy::SetSurfaceReadyOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::SetSurfaceReadyOnImplThread");
-  scheduler_on_impl_thread_->SetCanBeginFrame(true);
+  scheduler_on_impl_thread_->SetCanStart();
 }
 
 void ThreadProxy::SetVisible(bool visible) {
@@ -192,71 +179,79 @@ void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
   completion->Signal();
 }
 
-bool ThreadProxy::InitializeRenderer() {
-  TRACE_EVENT0("cc", "ThreadProxy::InitializeRenderer");
-  // Make a blocking call to InitializeRendererOnImplThread. The results of that
-  // call are pushed into the initialize_succeeded and capabilities local
-  // variables.
-  CompletionEvent completion;
-  bool initialize_succeeded = false;
-  RendererCapabilities capabilities;
-  DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-  Proxy::ImplThread()->PostTask(
-      base::Bind(&ThreadProxy::InitializeRendererOnImplThread,
-                 impl_thread_weak_ptr_,
-                 &completion,
-                 &initialize_succeeded,
-                 &capabilities));
-  completion.Wait();
-
-  if (initialize_succeeded) {
-    renderer_initialized_ = true;
-    renderer_capabilities_main_thread_copy_ = capabilities;
-  }
-  return initialize_succeeded;
-}
-
-bool ThreadProxy::RecreateOutputSurface() {
-  TRACE_EVENT0("cc", "ThreadProxy::RecreateOutputSurface");
+void ThreadProxy::DoCreateAndInitializeOutputSurface() {
+  TRACE_EVENT0("cc", "ThreadProxy::DoCreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
-  // Try to create the surface.
-  scoped_ptr<OutputSurface> output_surface =
-      layer_tree_host_->CreateOutputSurface();
+  scoped_ptr<OutputSurface> output_surface = first_output_surface_.Pass();
   if (!output_surface)
-    return false;
-  scoped_refptr<cc::ContextProvider> offscreen_context_provider;
+    output_surface = layer_tree_host_->CreateOutputSurface();
+
+  RendererCapabilities capabilities;
+  bool success = !!output_surface;
+  if (!success) {
+    OnOutputSurfaceInitializeAttempted(false, capabilities);
+    return;
+  }
+
+  scoped_refptr<ContextProvider> offscreen_context_provider;
   if (created_offscreen_context_provider_) {
     offscreen_context_provider = layer_tree_host_->client()->
         OffscreenContextProviderForCompositorThread();
-    if (!offscreen_context_provider)
-      return false;
+    success = !!offscreen_context_provider;
+    if (!success) {
+      OnOutputSurfaceInitializeAttempted(false, capabilities);
+      return;
+    }
   }
 
-  // Make a blocking call to RecreateOutputSurfaceOnImplThread. The results of
-  // that call are pushed into the recreate_succeeded and capabilities local
-  // variables.
-  CompletionEvent completion;
-  bool recreate_succeeded = false;
-  RendererCapabilities capabilities;
-  DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-  Proxy::ImplThread()->PostTask(
-      base::Bind(&ThreadProxy::RecreateOutputSurfaceOnImplThread,
-                 impl_thread_weak_ptr_,
-                 &completion,
-                 base::Passed(&output_surface),
-                 offscreen_context_provider,
-                 &recreate_succeeded,
-                 &capabilities));
-  completion.Wait();
+  success = false;
+  {
+    // Make a blocking call to InitializeOutputSurfaceOnImplThread. The results
+    // of that call are pushed into the success and capabilities local
+    // variables.
+    CompletionEvent completion;
+    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+
+    Proxy::ImplThread()->PostTask(
+        base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
+                   impl_thread_weak_ptr_,
+                   &completion,
+                   base::Passed(&output_surface),
+                   offscreen_context_provider,
+                   &success,
+                   &capabilities));
+    completion.Wait();
+  }
+
+  OnOutputSurfaceInitializeAttempted(success, capabilities);
+}
+
+void ThreadProxy::OnOutputSurfaceInitializeAttempted(
+    bool success,
+    const RendererCapabilities& capabilities) {
+  DCHECK(IsMainThread());
+  DCHECK(layer_tree_host_);
 
-  if (recreate_succeeded)
+  if (success) {
     renderer_capabilities_main_thread_copy_ = capabilities;
-  return recreate_succeeded;
+  }
+
+  LayerTreeHost::CreateResult result =
+      layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
+  if (result == LayerTreeHost::CreateFailedButTryAgain) {
+    if (!output_surface_creation_callback_.callback().is_null()) {
+      Proxy::MainThread()->PostTask(
+          output_surface_creation_callback_.callback());
+    }
+  } else {
+    output_surface_creation_callback_.Cancel();
+  }
 }
 
 const RendererCapabilities& ThreadProxy::GetRendererCapabilities() const {
-  DCHECK(renderer_initialized_);
+  DCHECK(IsMainThread());
+  DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_main_thread_copy_;
 }
 
@@ -510,9 +505,10 @@ void ThreadProxy::MainThreadHasStoppedFlinging() {
     input_handler_on_impl_thread_->MainThreadHasStoppedFlinging();
 }
 
-void ThreadProxy::Start() {
+void ThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
   DCHECK(IsMainThread());
   DCHECK(Proxy::ImplThread());
+  DCHECK(first_output_surface);
   // Create LayerTreeHostImpl.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
@@ -525,6 +521,7 @@ void ThreadProxy::Start() {
   completion.Wait();
 
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
+  first_output_surface_ = first_output_surface.Pass();
 
   started_ = true;
 }
@@ -565,7 +562,7 @@ void ThreadProxy::ForceSerializeOnSwapBuffers() {
 
 void ThreadProxy::ForceSerializeOnSwapBuffersOnImplThread(
     CompletionEvent* completion) {
-  if (renderer_initialized_)
+  if (layer_tree_host_impl_->renderer())
     layer_tree_host_impl_->renderer()->DoNoOp();
   completion->Signal();
 }
@@ -675,11 +672,6 @@ void ThreadProxy::BeginFrame(
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
 
-  if (!layer_tree_host_->InitializeRendererIfNeeded()) {
-    TRACE_EVENT0("cc", "EarlyOut_InitializeFailed");
-    return;
-  }
-
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
   layer_tree_host_->UpdateLayers(
@@ -849,10 +841,11 @@ void ThreadProxy::ScheduledActionActivatePendingTreeIfNeeded() {
   layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
 }
 
-void ThreadProxy::ScheduledActionBeginContextRecreation() {
+void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   DCHECK(IsImplThread());
   Proxy::MainThread()->PostTask(
-      base::Bind(&ThreadProxy::BeginContextRecreation, main_thread_weak_ptr_));
+      base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
+                 main_thread_weak_ptr_));
 }
 
 ScheduledActionDrawAndSwapResult
@@ -1053,25 +1046,39 @@ void ThreadProxy::SetAnimationEvents(scoped_ptr<AnimationEventsVector> events,
   layer_tree_host_->SetAnimationEvents(events.Pass(), wall_clock_time);
 }
 
-void ThreadProxy::BeginContextRecreation() {
-  TRACE_EVENT0("cc", "ThreadProxy::BeginContextRecreation");
+void ThreadProxy::CreateAndInitializeOutputSurface() {
+  TRACE_EVENT0("cc", "ThreadProxy::CreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
+
+  // Check that output surface has not been recreated by CompositeAndReadback
+  // after this task is posted but before it is run.
+  bool has_initialized_output_surface_on_impl_thread = true;
+  {
+    CompletionEvent completion;
+    Proxy::ImplThread()->PostTask(
+        base::Bind(&ThreadProxy::HasInitializedOutputSurfaceOnImplThread,
+                   impl_thread_weak_ptr_,
+                   &completion,
+                   &has_initialized_output_surface_on_impl_thread));
+    completion.Wait();
+  }
+  if (has_initialized_output_surface_on_impl_thread)
+    return;
+
   layer_tree_host_->DidLoseOutputSurface();
-  output_surface_recreation_callback_.Reset(base::Bind(
-      &ThreadProxy::TryToRecreateOutputSurface, base::Unretained(this)));
-  Proxy::MainThread()->PostTask(output_surface_recreation_callback_.callback());
+  output_surface_creation_callback_.Reset(base::Bind(
+      &ThreadProxy::DoCreateAndInitializeOutputSurface,
+      base::Unretained(this)));
+  output_surface_creation_callback_.callback().Run();
 }
 
-void ThreadProxy::TryToRecreateOutputSurface() {
-  DCHECK(IsMainThread());
-  DCHECK(layer_tree_host_);
-  LayerTreeHost::RecreateResult result =
-      layer_tree_host_->RecreateOutputSurface();
-  if (result == LayerTreeHost::RecreateFailedButTryAgain)
-    Proxy::MainThread()->PostTask(
-        output_surface_recreation_callback_.callback());
-  else if (result == LayerTreeHost::RecreateSucceeded)
-    output_surface_recreation_callback_.Cancel();
+void ThreadProxy::HasInitializedOutputSurfaceOnImplThread(
+    CompletionEvent* completion,
+    bool* has_initialized_output_surface) {
+  DCHECK(IsImplThread());
+  *has_initialized_output_surface =
+      scheduler_on_impl_thread_->HasInitializedOutputSurface();
+  completion->Signal();
 }
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion,
@@ -1115,34 +1122,47 @@ void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion,
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
-    scoped_ptr<OutputSurface> output_surface) {
-  TRACE_EVENT0("cc", "ThreadProxy::InitializeContextOnImplThread");
-  DCHECK(IsImplThread());
-  output_surface_before_initialization_on_impl_thread_ = output_surface.Pass();
-}
-
-void ThreadProxy::InitializeRendererOnImplThread(
     CompletionEvent* completion,
-    bool* initialize_succeeded,
+    scoped_ptr<OutputSurface> output_surface,
+    scoped_refptr<ContextProvider> offscreen_context_provider,
+    bool* success,
     RendererCapabilities* capabilities) {
-  TRACE_EVENT0("cc", "ThreadProxy::InitializeRendererOnImplThread");
+  TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
-  DCHECK(output_surface_before_initialization_on_impl_thread_.get());
-  *initialize_succeeded = layer_tree_host_impl_->InitializeRenderer(
-      output_surface_before_initialization_on_impl_thread_.Pass());
-  if (*initialize_succeeded) {
+  DCHECK(IsMainThreadBlocked());
+  DCHECK(success);
+  DCHECK(capabilities);
+
+  layer_tree_host_->DeleteContentsTexturesOnImplThread(
+      layer_tree_host_impl_->resource_provider());
+
+  *success = layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
+
+  if (offscreen_context_provider)
+    offscreen_context_provider->BindToCurrentThread();
+
+  if (*success) {
     *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
     scheduler_on_impl_thread_->SetSwapBuffersCompleteSupported(
         capabilities->using_swap_complete_callback);
 
-    int max_frames_pending = layer_tree_host_impl_->output_surface()->
-        capabilities().max_frames_pending;
+    OutputSurface* output_surface_ptr = layer_tree_host_impl_->output_surface();
+    DCHECK(output_surface_ptr);
+    int max_frames_pending =
+        output_surface_ptr->capabilities().max_frames_pending;
     if (max_frames_pending <= 0)
       max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
-    if (layer_tree_host_impl_->output_surface()->capabilities().
-            has_parent_compositor)
+    if (output_surface_ptr->capabilities().has_parent_compositor)
       max_frames_pending = 1;
+
     scheduler_on_impl_thread_->SetMaxFramesPending(max_frames_pending);
+
+    layer_tree_host_impl_->resource_provider()->
+        set_offscreen_context_provider(offscreen_context_provider);
+
+    scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
+  } else if (offscreen_context_provider) {
+    offscreen_context_provider->VerifyContexts();
   }
 
   completion->Signal();
@@ -1171,33 +1191,6 @@ size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
 
-void ThreadProxy::RecreateOutputSurfaceOnImplThread(
-    CompletionEvent* completion,
-    scoped_ptr<OutputSurface> output_surface,
-    scoped_refptr<cc::ContextProvider> offscreen_context_provider,
-    bool* recreate_succeeded,
-    RendererCapabilities* capabilities) {
-  TRACE_EVENT0("cc", "ThreadProxy::RecreateOutputSurfaceOnImplThread");
-  DCHECK(IsImplThread());
-
-  layer_tree_host_->DeleteContentsTexturesOnImplThread(
-      layer_tree_host_impl_->resource_provider());
-  *recreate_succeeded =
-      layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
-  if (offscreen_context_provider)
-      offscreen_context_provider->BindToCurrentThread();
-
-  if (*recreate_succeeded) {
-    *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
-    layer_tree_host_impl_->resource_provider()->
-        set_offscreen_context_provider(offscreen_context_provider);
-    scheduler_on_impl_thread_->DidRecreateOutputSurface();
-  } else if (offscreen_context_provider) {
-    offscreen_context_provider->VerifyContexts();
-  }
-  completion->Signal();
-}
-
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : memory_allocation_limit_bytes(0) {}
 
diff --git a/cc/trees/thread_proxy.h b/cc/trees/thread_proxy.h
index d466228..df0a39c 100644
--- a/cc/trees/thread_proxy.h
+++ b/cc/trees/thread_proxy.h
@@ -41,11 +41,9 @@ class ThreadProxy : public Proxy,
   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
   virtual void FinishAllRendering() OVERRIDE;
   virtual bool IsStarted() const OVERRIDE;
-  virtual bool InitializeOutputSurface() OVERRIDE;
   virtual void SetSurfaceReady() OVERRIDE;
   virtual void SetVisible(bool visible) OVERRIDE;
-  virtual bool InitializeRenderer() OVERRIDE;
-  virtual bool RecreateOutputSurface() OVERRIDE;
+  virtual void CreateAndInitializeOutputSurface() OVERRIDE;
   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
   virtual void SetNeedsAnimate() OVERRIDE;
   virtual void SetNeedsCommit() OVERRIDE;
@@ -53,7 +51,7 @@ class ThreadProxy : public Proxy,
   virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
   virtual bool CommitRequested() const OVERRIDE;
   virtual void MainThreadHasStoppedFlinging() OVERRIDE;
-  virtual void Start() OVERRIDE;
+  virtual void Start(scoped_ptr<OutputSurface> first_output_surface) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
   virtual void AcquireLayerTextures() OVERRIDE;
@@ -98,7 +96,7 @@ class ThreadProxy : public Proxy,
   virtual void ScheduledActionCommit() OVERRIDE;
   virtual void ScheduledActionCheckForCompletedTileUploads() OVERRIDE;
   virtual void ScheduledActionActivatePendingTreeIfNeeded() OVERRIDE;
-  virtual void ScheduledActionBeginContextRecreation() OVERRIDE;
+  virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
 
@@ -131,8 +129,11 @@ class ThreadProxy : public Proxy,
   void DidCompleteSwapBuffers();
   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue,
                           base::Time wall_clock_time);
-  void BeginContextRecreation();
-  void TryToRecreateOutputSurface();
+  void DoCreateAndInitializeOutputSurface();
+  // |capabilities| is set only when |success| is true.
+  void OnOutputSurfaceInitializeAttempted(
+      bool success,
+      const RendererCapabilities& capabilities);
 
   // Called on impl thread.
   struct ReadbackRequest {
@@ -157,22 +158,20 @@ class ThreadProxy : public Proxy,
                                   InputHandler* input_handler);
   void SetSurfaceReadyOnImplThread();
   void SetVisibleOnImplThread(CompletionEvent* completion, bool visible);
+  void HasInitializedOutputSurfaceOnImplThread(
+      CompletionEvent* completion,
+      bool* has_initialized_output_surface);
   void InitializeOutputSurfaceOnImplThread(
-      scoped_ptr<OutputSurface> output_surface);
-  void InitializeRendererOnImplThread(CompletionEvent* completion,
-                                      bool* initialize_succeeded,
-                                      RendererCapabilities* capabilities);
+      CompletionEvent* completion,
+      scoped_ptr<OutputSurface> output_surface,
+      scoped_refptr<ContextProvider> offscreen_context_provider,
+      bool* success,
+      RendererCapabilities* capabilities);
   void LayerTreeHostClosedOnImplThread(CompletionEvent* completion);
   void ManageTilesOnImplThread();
   void SetViewportDamageOnImplThread(gfx::Rect damage_rect);
   void AcquireLayerTexturesForMainThreadOnImplThread(
       CompletionEvent* completion);
-  void RecreateOutputSurfaceOnImplThread(
-      CompletionEvent* completion,
-      scoped_ptr<OutputSurface> output_surface,
-      scoped_refptr<cc::ContextProvider> offscreen_context_provider,
-      bool* recreate_succeeded,
-      RendererCapabilities* capabilities);
   ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapInternal(
       bool forced_draw);
   void ForceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion);
@@ -197,9 +196,8 @@ class ThreadProxy : public Proxy,
   bool commit_request_sent_to_impl_thread_;
   // Set by BeginFrame
   bool created_offscreen_context_provider_;
-  base::CancelableClosure output_surface_recreation_callback_;
+  base::CancelableClosure output_surface_creation_callback_;
   LayerTreeHost* layer_tree_host_;
-  bool renderer_initialized_;
   RendererCapabilities renderer_capabilities_main_thread_copy_;
   bool started_;
   bool textures_acquired_;
@@ -207,6 +205,9 @@ class ThreadProxy : public Proxy,
   bool manage_tiles_pending_;
   // Weak pointer to use when posting tasks to the impl thread.
   base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_;
+  // Holds the first output surface passed from Start. Should not be used for
+  // anything else.
+  scoped_ptr<OutputSurface> first_output_surface_;
 
   base::WeakPtrFactory<ThreadProxy> weak_factory_on_impl_thread_;
 
@@ -219,11 +220,6 @@ class ThreadProxy : public Proxy,
 
   scoped_ptr<Scheduler> scheduler_on_impl_thread_;
 
-  // Holds on to the context we might use for compositing in between
-  // InitializeContext() and InitializeRenderer() calls.
-  scoped_ptr<OutputSurface>
-      output_surface_before_initialization_on_impl_thread_;
-
   // Set when the main thread is waiting on a ScheduledActionBeginFrame to be
   // issued.
   CompletionEvent* begin_frame_completion_event_on_impl_thread_;