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::checkOutputSurfaceStatusOnImplThread, base::Unretained(this)));

[jamesr, 2012/12/18 21:24:01]

this is crashy - there's no promises that the ThreadProxy will still be alive
when the task runs.  when posting main->impl we can use base::Unretained(this)
since shutdown blocks the main thread.

I think we should keep a WeakPtr usable on the impl thread and have all tasks
posted to the impl thread use that as the target.

[danakj, 2012/12/18 21:26:59]

Ok, great plan! Thanks. I'll get to this..

First I'm yak shaving layer_tree_host_unittests a bit so I can have a sane
environment to write these layout-test-replacing-unit-tests.

+}
+
+void ThreadProxy::checkOutputSurfaceStatusOnImplThread()
+{
+    DCHECK(isImplThread());
+    TRACE_EVENT0("cc", "ThreadProxy::checkOutputSurfaceStatusOnImplThread");
+    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)
+        checkOutputSurfaceStatusOnImplThread();
+
     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 158 matching lines @@
 
 size_t ThreadProxy::maxPartialTextureUpdates() const
 {
     return ResourceUpdateController::maxPartialTextureUpdates();
 }
 
 void ThreadProxy::recreateOutputSurfaceOnImplThread(CompletionEvent* completion, scoped_ptr<OutputSurface> outputSurface, bool* recreateSucceeded, RendererCapabilities* capabilities)
 {
     TRACE_EVENT0("cc", "ThreadProxy::recreateOutputSurfaceOnImplThread");
     DCHECK(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());

[ccameron, 2012/12/18 19:24:01]

I'd prefer to do

if (m_layerTreeHostImpl->resourceProvider())
  m_layerTreeHost->deleteContentsTextures()...

Because the PRM assumes assumes that the resourceProvider passed in is non-NULL
and the same as the resourceProvider that created resources.

     *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
     if (*recreateSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->didRecreateOutputSurface();
     }
     completion->signal();
 }
 
 void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
 {
@@ skipping 24 matching lines @@
 }
 
 void ThreadProxy::commitPendingOnImplThreadForTesting(CommitPendingRequest* request)
 {
     DCHECK(isImplThread());
     request->commitPending = m_schedulerOnImplThread->commitPending();
     request->completion.signal();
 }
 
 }  // namespace cc