cc: Unify context losing machinery

cc/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/thread_proxy.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/delay_based_time_source.h"
 #include "cc/draw_quad.h"
 #include "cc/frame_rate_controller.h"
 #include "cc/input_handler.h"
 #include "cc/layer_tree_host.h"
 #include "cc/output_surface.h"
+#include "cc/resource_provider.h"
 #include "cc/scheduler.h"
 #include "cc/scoped_thread_proxy.h"
 #include "cc/thread.h"
-#include <public/WebSharedGraphicsContext3D.h>
+#include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebSharedGraphicsContext3D.h"
 
 using WebKit::WebSharedGraphicsContext3D;
 
 namespace {
 
 // Measured in seconds.
 const double contextRecreationTickRate = 0.03;
 
 }  // namespace
 
@@ skipping 229 matching lines @@
 }
 
 const RendererCapabilities& ThreadProxy::rendererCapabilities() const
 {
     DCHECK(m_rendererInitialized);
     return m_RendererCapabilitiesMainThreadCopy;
 }
 
 void ThreadProxy::loseOutputSurface()
 {
-    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::didLoseOutputSurfaceOnImplThread, base::Unretained(this)));
+    DCHECK(isMainThread());
+    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::loseOutputSurfaceOnImplThread, base::Unretained(this)));
+}
+
+void ThreadProxy::loseOutputSurfaceOnImplThread()
+{
+    DCHECK(isImplThread());
+    m_layerTreeHostImpl->resourceProvider()->loseOutputSurface();
 }
 
 void ThreadProxy::setNeedsAnimate()
 {
     DCHECK(isMainThread());
     if (m_animateRequested)
         return;
 
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsAnimate");
     m_animateRequested = true;
@@ skipping 15 matching lines @@
     if (m_commitRequestSentToImplThread)
         return;
     m_commitRequestSentToImplThread = true;
     Proxy::implThread()->postTask(base::Bind(&ThreadProxy::setNeedsCommitOnImplThread, base::Unretained(this)));
 }
 
 void ThreadProxy::didLoseOutputSurfaceOnImplThread()
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::didLoseOutputSurfaceOnImplThread");
+    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::checkLostOutputSurfaceOnImplThread, base::Unretained(this)));

[jamesr, 2012/12/18 05:44:41]

hmmm - how is this base::Unretained(this) safe? i.e. how do you know 'this' will
exist when the task runs?

the calls from the main thread to the impl thread that do postTask(...,
base::Unretained(this)) are (i think) safe because when we shut down the proxy
we do it by posting a task from the main thread to the impl thread and then
blocking the main thread until that task runs, which will be after all other
tasks already posted from main->impl thread can run.  if you're already on the
impl thread, however, you have no idea what tasks may be in the queue - perhaps
the main thread has already posted the stop task and it's sitting on the impl
thread queue.

the other postTask calls in this file from the impl thread to ThreadProxy are
probably also all unsafe as well :(.  

+}
+
+void ThreadProxy::checkLostOutputSurfaceOnImplThread()
+{
+    DCHECK(isImplThread());
+    TRACE_EVENT0("cc", "ThreadProxy::checkLostContextOnImplThread");
+    if (!m_layerTreeHostImpl->isContextLost())
+        return;
     m_schedulerOnImplThread->didLoseOutputSurface();
 }
 
 void ThreadProxy::onSwapBuffersCompleteOnImplThread()
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::onSwapBuffersCompleteOnImplThread");
     m_schedulerOnImplThread->didSwapBuffersComplete();
     m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::didCompleteSwapBuffers, base::Unretained(this)));
 }
@@ skipping 459 matching lines @@
         m_readbackRequestOnImplThread = 0;
     } else if (drawFrame)
         result.didSwap = m_layerTreeHostImpl->swapBuffers();
 
     // Tell the main thread that the the newly-commited frame was drawn.
     if (m_nextFrameIsNewlyCommittedFrameOnImplThread) {
         m_nextFrameIsNewlyCommittedFrameOnImplThread = false;
         m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::didCommitAndDrawFrame, base::Unretained(this)));
     }
 
+    if (drawFrame)
+        checkLostOutputSurfaceOnImplThread();
+
     return result;
 }
 
 void ThreadProxy::acquireLayerTextures()
 {
     // Called when the main thread needs to modify a layer texture that is used
     // directly by the compositor.
     // This method will block until the next compositor draw if there is a
     // previously committed frame that is still undrawn. This is necessary to
     // ensure that the main thread does not monopolize access to the textures.
@@ skipping 203 matching lines @@
 }
 
 void ThreadProxy::commitPendingOnImplThreadForTesting(CommitPendingRequest* request)
 {
     DCHECK(isImplThread());
     request->commitPending = m_schedulerOnImplThread->commitPending();
     request->completion.signal();
 }
 
 }  // namespace cc