Remove cc::LayerTreeHostImpl::IsContextLost

cc/trees/single_thread_proxy.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 296 matching lines @@
 
 void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
   DCHECK(IsImplThread());
   renderer_capabilities_for_main_thread_ =
       layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
 }
 
 void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
   // Cause a commit so we can notice the lost context.
   SetNeedsCommitOnImplThread();

[danakj, 2014/08/15 17:45:15]

Should this move to STP::DidLoseOutputSurface (ie happen at the same time we
tell the LTH)?

[dneto, 2014/08/15 18:17:17]

Actually we might just remove this, since LTH::DidLoseOutputSurface calls
LTH::SetNeedsCommit which then comes back into proxy_->SetNeedsCommit which then
calls client_->ScheduleComposite

That's the same effect as SetNeedsCommitOnImplThread.
I'll see if that works without too much mayhem.

[danakj, 2014/08/15 18:18:10]

Oh good SGTM

   client_->DidAbortSwapBuffers();
+  // Tell the LayerTreeHost, but not right away.
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeHost::DidLoseOutputSurface,

[danakj, 2014/08/15 17:45:15]

Can you add a SingleThreadProxy::DidLoseOutputSurface() and post that instead,
then have that call LTH?

You'll also want to add a "base::WeakPtrFactory<SingleThreadProxy>
weak_factory_;" to this class and post the task with that weak factory. You can
steal that from
https://codereview.chromium.org/134623005/diff/2230001/cc/trees/single_thread...

[dneto, 2014/08/15 17:58:20]

Good point.  Yes, I can do this.

+                 base::Unretained(layer_tree_host_)));
 }
 
 void SingleThreadProxy::DidSwapBuffersOnImplThread() {
   client_->DidPostSwapBuffers();
 }
 
 void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
   client_->DidCompleteSwapBuffers();
 }
@@ skipping 97 matching lines @@
     // CanDraw() as well.
     if (!ShouldComposite()) {
       UpdateBackgroundAnimateTicking();
       return false;
     }
 
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentFrameTimeTicks());
     UpdateBackgroundAnimateTicking();
 
-    if (!layer_tree_host_impl_->IsContextLost()) {
-      layer_tree_host_impl_->PrepareToDraw(frame);
+    DrawResult draw_result = layer_tree_host_impl_->PrepareToDraw(frame);
+    if (draw_result == DRAW_ABORTED_CONTEXT_LOST) {
+      lost_output_surface = true;
+    } else {
       layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
       layer_tree_host_impl_->DidDrawAllLayers(*frame);
     }
-    lost_output_surface = layer_tree_host_impl_->IsContextLost();
 
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
 
   if (lost_output_surface) {
-    layer_tree_host_->DidLoseOutputSurface();
     return false;
   }
 
   return true;
 }
 
 void SingleThreadProxy::DidSwapFrame() {
   if (next_frame_is_newly_committed_frame_) {
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
 bool SingleThreadProxy::MainFrameWillHappenForTesting() {
   return false;
 }
 
 }  // namespace cc