Aura: Resize locks with --ui-enable-threaded-compositing

cc/thread_proxy.cc

Index: cc/thread_proxy.cc
diff --git a/cc/thread_proxy.cc b/cc/thread_proxy.cc
index ee08f77cb3be14c3c6a6506e27944f14a1ccc0c1..b5a02e96fc4ea1c016369ce87f94c1bdfeb6eec0 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -53,6 +53,8 @@ ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_totalCommitCount(0)
+    , m_deferCommits(false)
+    , m_deferredCommitPending(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
@@ -70,6 +72,7 @@ bool ThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
     TRACE_EVENT0("cc", "ThreadPRoxy::compositeAndReadback");
     DCHECK(isMainThread());
     DCHECK(m_layerTreeHost);
+    DCHECK(!m_deferCommits);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
@@ -131,6 +134,7 @@ void ThreadProxy::requestStartPageScaleAnimationOnImplThread(IntSize targetPosit
 void ThreadProxy::finishAllRendering()
 {
     DCHECK(Proxy::isMainThread());
+    DCHECK(!m_deferCommits);
 
     // Make sure all GL drawing is finished on the impl thread.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
@@ -373,6 +377,21 @@ void ThreadProxy::setNeedsRedraw()
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsRedrawOnImplThread));
 }
 
+void ThreadProxy::setDeferCommits(bool deferCommits)
+{
+    DCHECK(isMainThread());
+    DCHECK_NE(m_deferCommits, deferCommits);
+    m_deferCommits = deferCommits;
+
+    if (m_deferCommits)
+        TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::setDeferCommits", this);
+    else
+        TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::setDeferCommits", this);
+
+    if (!m_deferCommits && m_deferredCommitPending)
+        m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::beginFrame));
+}
+
 bool ThreadProxy::commitRequested() const
 {
     DCHECK(isMainThread());
@@ -487,6 +506,14 @@ void ThreadProxy::beginFrame()
     if (!m_layerTreeHost)
         return;
 
+    if (m_deferCommits) {
+        m_deferredCommitPending = true;
+        m_layerTreeHost->didDeferCommit();
+        TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
+        return;
+    } else
+        m_deferredCommitPending = false;

[piman, 2012/10/25 16:18:58]

I would reset this when posting the task in setDeferCommits, right before
posting the task.
Otherwise, if the main thread quickly does several setDeferCommits(true);
setDeferCommits(false), we'll post several beginFrame tasks. The first one is
fine but the second one might catch a race as well (as soon as the first one
executes, the impl thread could send a new task, setting
m_pendingBeginFrameRequest, that the second task may catch while it's being
constructed).

[jonathan.backer, 2012/10/25 16:38:11]

Done.

+
     if (!m_pendingBeginFrameRequest) {
         TRACE_EVENT0("cc", "EarlyOut_StaleBeginFrameMessage");
         return;