cc: Block the main thread for texture layers during impl-side painting

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"
@@ skipping 701 matching lines @@
 
     if (newImplTreeHasNoEvictedResources) {
         if (m_layerTreeHostImpl->contentsTexturesPurged())
             m_layerTreeHostImpl->resetContentsTexturesPurged();
     }
 
     m_layerTreeHostImpl->commitComplete();
 
     m_nextFrameIsNewlyCommittedFrameOnImplThread = true;
 
-    m_commitCompletionEventOnImplThread->signal();
-    m_commitCompletionEventOnImplThread = 0;
+    if (m_layerTreeHost->settings().implSidePainting && m_layerTreeHost->blocksPendingCommit())
+    {
+        // For some layer types in impl-side painting, the commit is held until
+        // the pending tree is activated.
+        TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCommit_HoldCommit");

[nduca, 2013/01/08 04:49:27]

You can just write HoldCommitUntilActivate and use TRACE_EVENT_INSTANT0 ---
this'll get issued be inside a ScheduldActionCommit, so it'll be pretty
straightfowrad to see who did it.

+    }
+    else
+    {
+        m_commitCompletionEventOnImplThread->signal();
+        m_commitCompletionEventOnImplThread = 0;
+    }
 
     // SetVisible kicks off the next scheduler action, so this must be last.
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 }
 
 void ThreadProxy::scheduledActionBeginContextRecreation()
 {
     DCHECK(isImplThread());
     Proxy::mainThread()->postTask(base::Bind(&ThreadProxy::beginContextRecreation, m_mainThreadWeakPtr));
 }
@@ skipping 33 matching lines @@
     // prepareToDraw(), it is guarded on canDraw() as well.
 
     LayerTreeHostImpl::FrameData frame;
     bool drawFrame = m_layerTreeHostImpl->canDraw() && (m_layerTreeHostImpl->prepareToDraw(frame) || forcedDraw);
     if (drawFrame) {
         m_layerTreeHostImpl->drawLayers(frame);
         result.didDraw = true;
     }
     m_layerTreeHostImpl->didDrawAllLayers(frame);
 
+    // Check for tree activation.
+    if (m_commitCompletionEventOnImplThread && !m_layerTreeHostImpl->pendingTree())
+    {
+        TRACE_EVENT0("cc", "ThreadProxy::scheduledActionDrawAndSwapInternal_ReleaseCommit");
+        DCHECK(m_layerTreeHostImpl->settings().implSidePainting);
+        m_commitCompletionEventOnImplThread->signal();
+        m_commitCompletionEventOnImplThread = 0;
+    }
+
     // Check for a pending compositeAndReadback.
     if (m_readbackRequestOnImplThread) {
         m_readbackRequestOnImplThread->success = false;
         if (drawFrame) {
             m_layerTreeHostImpl->readback(m_readbackRequestOnImplThread->pixels, m_readbackRequestOnImplThread->rect);
             m_readbackRequestOnImplThread->success = !m_layerTreeHostImpl->isContextLost();
         }
         m_readbackRequestOnImplThread->completion.signal();
         m_readbackRequestOnImplThread = 0;
     } else if (drawFrame)
@@ skipping 228 matching lines @@
 }
 
 void ThreadProxy::commitPendingOnImplThreadForTesting(CommitPendingRequest* request)
 {
     DCHECK(isImplThread());
     request->commitPending = m_schedulerOnImplThread->commitPending();
     request->completion.signal();
 }
 
 }  // namespace cc