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..2f472b9228e79f6650060ccb53ab0564b76604a1 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -53,6 +53,7 @@ ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_totalCommitCount(0)
+    , m_deferCommits(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
@@ -373,6 +374,28 @@ void ThreadProxy::setNeedsRedraw()
     Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsRedrawOnImplThread));
 }
 
+void ThreadProxy::setDeferCommits(bool deferCommits)
+{
+    DCHECK(isMainThread());
+    if (m_deferCommits == deferCommits)

[jamesr, 2012/10/23 21:24:34]

redundant calls would probably be a caller error and i think we should DCHECK()
on them. for instance, if a caller calls setDeferCommits(true) when commits are
already deferred, it probably means that there will also be an unbalanced set of
setDeferCommits(false) calls and commits will not be deferred after the first
call even if whoever made the second call probably expects commits to still be
deferred

or, if you really want a recursive lock, you'll need a counter here

[jonathan.backer, 2012/10/24 16:42:14]

Done.

Good idea. Let's not make this recursive (I can't imagine wanting that).
ui::Compositor currently prevents this from happening.

+        return;
+    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_pendingBeginFrameRequest)
+        m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::beginFrame));
+}
+
+bool ThreadProxy::deferCommits() const
+{
+    DCHECK(isMainThread());
+    return m_deferCommits;
+}
+
 bool ThreadProxy::commitRequested() const
 {
     DCHECK(isMainThread());
@@ -487,6 +510,11 @@ void ThreadProxy::beginFrame()
     if (!m_layerTreeHost)
         return;
 
+    if (m_layerTreeHost->deferCommits()) {
+        TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
+        return;
+    }
+
     if (!m_pendingBeginFrameRequest) {
         TRACE_EVENT0("cc", "EarlyOut_StaleBeginFrameMessage");
         return;