Rolls cc and webkit_compositor up to 127340

cc/CCThreadProxy.cpp

 // 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 "config.h"
 
 #include "CCThreadProxy.h"
 
 #include "CCDelayBasedTimeSource.h"
 #include "CCDrawQuad.h"
@@ skipping 71 matching lines @@
     ASSERT(isMainThread());
     ASSERT(m_layerTreeHost);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
         return false;
     }
 
 
     // Perform a synchronous commit.
-    CCCompletionEvent beginFrameCompletion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
-    beginFrameCompletion.wait();
+    {
+        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        CCCompletionEvent beginFrameCompletion;
+        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
+        beginFrameCompletion.wait();
+    }
     m_inCompositeAndReadback = true;
     beginFrame();
     m_inCompositeAndReadback = false;
 
     // Perform a synchronous readback.
     ReadbackRequest request;
     request.rect = rect;
     request.pixels = pixels;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestReadbackOnImplThread, &request));
-    request.completion.wait();
+    {
+        DebugScopedSetMainThreadBlocked mainThreadBlocked;
+        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestReadbackOnImplThread, &request));
+        request.completion.wait();
+    }
     return request.success;
 }
 
 void CCThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
 {
     ASSERT(CCProxy::isImplThread());
     ASSERT(!m_readbackRequestOnImplThread);
     if (!m_layerTreeHostImpl) {
         request->success = false;
         request->completion.signal();
@@ skipping 16 matching lines @@
     ASSERT(CCProxy::isImplThread());
     if (m_layerTreeHostImpl)
         m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
 }
 
 void CCThreadProxy::finishAllRendering()
 {
     ASSERT(CCProxy::isMainThread());
 
     // Make sure all GL drawing is finished on the impl thread.
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::finishAllRenderingOnImplThread, &completion));
     completion.wait();
 }
 
 bool CCThreadProxy::isStarted() const
 {
     ASSERT(CCProxy::isMainThread());
     return m_started;
 }
@@ skipping 18 matching lines @@
 
 void CCThreadProxy::setSurfaceReadyOnImplThread()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::setSurfaceReadyOnImplThread");
     m_schedulerOnImplThread->setCanBeginFrame(true);
 }
 
 void CCThreadProxy::setVisible(bool visible)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::setVisible");
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setVisibleOnImplThread, &completion, visible));
     completion.wait();
 }
 
 void CCThreadProxy::setVisibleOnImplThread(CCCompletionEvent* completion, bool visible)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::setVisibleOnImplThread");
     m_layerTreeHostImpl->setVisible(visible);
     m_schedulerOnImplThread->setVisible(visible);
     completion->signal();
 }
 
 bool CCThreadProxy::initializeRenderer()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeRenderer");
     // Make a blocking call to initializeRendererOnImplThread. The results of that call
     // are pushed into the initializeSucceeded and capabilities local variables.
     CCCompletionEvent completion;
     bool initializeSucceeded = false;
     RendererCapabilities capabilities;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeRendererOnImplThread,
                                                        &completion,
                                                        &initializeSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (initializeSucceeded) {
         m_rendererInitialized = true;
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     }
@@ skipping 12 matching lines @@
     if (m_layerTreeHost->needsSharedContext())
         if (!WebSharedGraphicsContext3D::createCompositorThreadContext())
             return false;
 
     // Make a blocking call to recreateContextOnImplThread. The results of that
     // call are pushed into the recreateSucceeded and capabilities local
     // variables.
     CCCompletionEvent completion;
     bool recreateSucceeded = false;
     RendererCapabilities capabilities;
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,
                                                        &completion,
                                                        context.leakPtr(),
                                                        &recreateSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (recreateSucceeded)
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     return recreateSucceeded;
 }
 
 int CCThreadProxy::compositorIdentifier() const
 {
     ASSERT(isMainThread());
     return m_compositorIdentifier;
 }
 
 void CCThreadProxy::implSideRenderingStats(CCRenderingStats& stats)
 {
     ASSERT(isMainThread());
 
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::implSideRenderingStatsOnImplThread,
                                                        &completion,
                                                        &stats));
     completion.wait();
 }
 
 const RendererCapabilities& CCThreadProxy::rendererCapabilities() const
 {
     ASSERT(m_rendererInitialized);
@@ skipping 98 matching lines @@
     ASSERT(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsRedrawOnImplThread");
     m_schedulerOnImplThread->setNeedsRedraw();
 }
 
 void CCThreadProxy::start()
 {
     ASSERT(isMainThread());
     ASSERT(CCProxy::implThread());
     // Create LayerTreeHostImpl.
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnImplThread, &completion));
     completion.wait();
 
     m_started = true;
 }
 
 void CCThreadProxy::stop()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::stop");
@@ skipping 11 matching lines @@
 
     m_mainThreadProxy->shutdown(); // Stop running tasks posted to us.
 
     ASSERT(!m_layerTreeHostImpl); // verify that the impl deleted.
     m_layerTreeHost = 0;
     m_started = false;
 }
 
 void CCThreadProxy::forceSerializeOnSwapBuffers()
 {
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));
     completion.wait();
 }
 
 void CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent* completion)
 {
     if (m_rendererInitialized)
         m_layerTreeHostImpl->renderer()->doNoOp();
     completion->signal();
@@ skipping 301 matching lines @@
     // 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.
     ASSERT(isMainThread());
 
     if (m_texturesAcquired)
         return;
 
     TRACE_EVENT0("cc", "CCThreadProxy::acquireLayerTextures");
+    DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));
     completion.wait(); // Block until it is safe to write to layer textures from the main thread.
 
     m_texturesAcquired = true;
 }
 
 void CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent* completion)
 {
     ASSERT(isImplThread());
@@ skipping 165 matching lines @@
 }
 
 void CCThreadProxy::implSideRenderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
 {
     ASSERT(isImplThread());
     m_layerTreeHostImpl->renderingStats(*stats);
     completion->signal();
 }
 
 } // namespace WebCore