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 32 matching lines @@
     , m_started(false)
     , m_texturesAcquired(true)
     , m_inCompositeAndReadback(false)
     , m_manageTilesPending(false)
     , m_weakFactoryOnImplThread(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_mainThreadProxy(ScopedThreadProxy::create(Proxy::mainThread()))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
+    , m_pendingTreeActivationEventOnImplThread(0)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_totalCommitCount(0)
     , m_deferCommits(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
 }
 
 ThreadProxy::~ThreadProxy()
@@ skipping 573 matching lines @@
         Proxy::implThread()->postTask(base::Bind(&ThreadProxy::beginFrameCompleteOnImplThread, m_implThreadWeakPtr, &completion, queue.release()));
         completion.wait();
         base::TimeTicks endTime = base::TimeTicks::HighResNow();
 
         m_totalCommitTime += endTime - startTime;
         m_totalCommitCount++;
     }
 
     m_layerTreeHost->commitComplete();
     m_layerTreeHost->didBeginFrame();
+
+    if (m_layerTreeHost->settings().implSidePainting)
+        blockUntilPendingActivationIfNeeded();
 }
 
 void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, ResourceUpdateQueue* rawQueue)
 {
     scoped_ptr<ResourceUpdateQueue> queue(rawQueue);
 
     TRACE_EVENT0("cc", "ThreadProxy::beginFrameCompleteOnImplThread");
     DCHECK(!m_commitCompletionEventOnImplThread);
     DCHECK(isImplThread() && isMainThreadBlocked());
     DCHECK(m_schedulerOnImplThread);
@@ skipping 54 matching lines @@
 
     if (newImplTreeHasNoEvictedResources) {
         if (m_layerTreeHostImpl->contentsTexturesPurged())
             m_layerTreeHostImpl->resetContentsTexturesPurged();
     }
 
     m_layerTreeHostImpl->commitComplete();
 
     m_nextFrameIsNewlyCommittedFrameOnImplThread = true;
 
     m_commitCompletionEventOnImplThread->signal();

[nduca, 2013/01/05 04:56:22]

how about making not signaling this in impl side painting mode and then instead
if we activate the pending tree in scheduledActionDraw we signal this then?

[enne (OOO), 2013/01/05 06:25:45]

You mean conditionally not signaling this here based on blocksPendingCommit and
just communicating that boolean rather than the mutex?

     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());
     m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::beginContextRecreation, base::Unretained(this)));
@@ skipping 32 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_pendingTreeActivationEventOnImplThread && !m_layerTreeHostImpl->pendingTree())
+    {
+        DCHECK(m_layerTreeHostImpl->settings().implSidePainting);
+        m_pendingTreeActivationEventOnImplThread->signal();
+        m_pendingTreeActivationEventOnImplThread = 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 222 matching lines @@
     return commitPendingRequest.commitPending;
 }
 
 void ThreadProxy::commitPendingOnImplThreadForTesting(CommitPendingRequest* request)
 {
     DCHECK(isImplThread());
     request->commitPending = m_schedulerOnImplThread->commitPending();
     request->completion.signal();
 }
 
+void ThreadProxy::blockUntilPendingActivationIfNeeded()
+{
+    DCHECK(isMainThread());
+    DCHECK(m_layerTreeHost->settings().implSidePainting);
+
+    if (!m_layerTreeHost->blocksPendingCommit())
+        return;
+
+    TRACE_EVENT0("cc", "ThreadProxy::blockUntilPendingActivationIfNeeded");
+    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(base::Bind(&ThreadProxy::blockUntilPendingActivationOnImplThread, m_implThreadWeakPtr, &completion));
+    completion.wait();
+}
+
+void ThreadProxy::blockUntilPendingActivationOnImplThread(CompletionEvent* completion)
+{
+    DCHECK(isImplThread());
+    DCHECK(isMainThreadBlocked());
+    DCHECK(m_layerTreeHostImpl->settings().implSidePainting);
+    CHECK(!m_pendingTreeActivationEventOnImplThread);
+
+    if (!m_layerTreeHostImpl->pendingTree()) {
+        completion->signal();
+        return;
+    }
+
+    m_pendingTreeActivationEventOnImplThread = completion;
+}
+
 }  // namespace cc