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

cc/single_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 "config.h"
 
 #include "cc/single_thread_proxy.h"
 
 #include "CCDrawQuad.h"
 #include "CCGraphicsContext.h"
 #include "base/debug/trace_event.h"
 #include "cc/layer_tree_host.h"
 #include "cc/texture_update_controller.h"
 #include "cc/timer.h"
 #include <wtf/CurrentTime.h>
 
 namespace cc {
 
 scoped_ptr<Proxy> SingleThreadProxy::create(LayerTreeHost* layerTreeHost)
 {
     return make_scoped_ptr(new SingleThreadProxy(layerTreeHost)).PassAs<Proxy>();
 }
 
 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layerTreeHost)
     : m_layerTreeHost(layerTreeHost)
     , m_contextLost(false)
     , m_rendererInitialized(false)
     , m_nextFrameIsNewlyCommittedFrame(false)
     , m_totalCommitCount(0)
+    , m_deferCommits(false)
 {
     TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
     DCHECK(Proxy::isMainThread());
 }
 
 void SingleThreadProxy::start()
 {
     DebugScopedSetImplThread impl;
     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
 }
@@ skipping 184 matching lines @@
 }
 
 void SingleThreadProxy::setNeedsRedraw()
 {
     // FIXME: Once we move render_widget scheduling into this class, we can
     // treat redraw requests more efficiently than commitAndRedraw requests.
     m_layerTreeHostImpl->setFullRootLayerDamage();
     setNeedsCommit();
 }
 
+void SingleThreadProxy::setDeferCommits(bool deferCommits)

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

I would say don't implement this at all - it doesn't make any sense to set
deferCommits() in single threaded mode since it's the embedder (not cc) that
decides when commits happen.  defersCommits is a hook to control the threaded
mode behavior only, since in threaded mode cc decides when to commit not the
embedder

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

Done. NOTREACHED.

+{
+    if (m_deferCommits == deferCommits)
+        return;
+    m_deferCommits = deferCommits;
+
+    if (m_deferCommits)
+        TRACE_EVENT_ASYNC_BEGIN0("cc", "SingleThreadProxy::setDeferCommits", this);
+    else
+        TRACE_EVENT_ASYNC_END0("cc", "SingleThreadProxy::setDeferCommits", this);
+}
+
+bool SingleThreadProxy::deferCommits() const
+{
+    return m_deferCommits;
+}
+
 bool SingleThreadProxy::commitRequested() const
 {
     return false;
 }
 
 void SingleThreadProxy::didAddAnimation()
 {
 }
 
 size_t SingleThreadProxy::maxPartialTextureUpdates() const
@@ skipping 129 matching lines @@
 
 void SingleThreadProxy::didSwapFrame()
 {
     if (m_nextFrameIsNewlyCommittedFrame) {
         m_nextFrameIsNewlyCommittedFrame = false;
         m_layerTreeHost->didCommitAndDrawFrame();
     }
 }
 
 }