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

cc/layer_tree_host.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/layer_tree_host.h"
 
 #include "CCFontAtlas.h"
 #include "CCGraphicsContext.h"
@@ skipping 92 matching lines @@
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
     , m_hasTransparentBackground(false)
     , m_partialTextureUpdateRequests(0)
+    , m_deferCommits(false)

[jamesr, 2012/10/23 17:50:44]

There's no reason to shadow state here on LayerTreeHost - just pass the call
through to the proxy

[jonathan.backer, 2012/10/23 19:26:42]

Done.

 {
     DCHECK(Proxy::isMainThread());
     numLayerTreeInstances++;
 }
 
 bool LayerTreeHost::initialize()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::initialize");
 
     if (Proxy::hasImplThread())
@@ skipping 200 matching lines @@
 {
     TRACE_EVENT0("cc", "LayerTreeHost::didLoseContext");
     DCHECK(Proxy::isMainThread());
     m_contextLost = true;
     m_numFailedRecreateAttempts = 0;
     setNeedsCommit();
 }
 
 bool LayerTreeHost::compositeAndReadback(void *pixels, const IntRect& rect)
 {
+    // Clear any pending commits.
+    setDeferCommits(false);

[jamesr, 2012/10/23 17:50:44]

This doesn't look right at all - what this will do if we have a pending commit
is post a task to run that commit, then run a forced commit (due to
compositeAndReadback), then run the deferred commit, then be left in
non-deferred commit mode.

There are two options here:
1.) Calling compositeAndReadback() with deferCommits true is a caller error and
we just dcheck() here
2.) We let the compositeAndReadback proceed synchronously - meaning we run any
commit that is currently deferred run synchronously, then do the
composite+readback path (which will synchronously run another commit)

[jonathan.backer, 2012/10/23 19:26:42]

We're more than happy to bail out of non-deferred commit mode. In
ui/compositor/compositor.cc, we have a timeout on the deferred commit, so we
have to structure our code so that it is always safe to bail out early. Given
that it must always be safe to bail out early, I like the shortcut here -- I
think it simplifies the logic.
We use this for window snapshotting in Aura. I'd prefer to handle this case if
it does not impose too much complexity.
This is totally an option. Although as I mentioned above, I prefer just bailing
--- it's simpler and we have to handle this case anyway.

+
     m_triggerIdleUpdates = false;
     bool ret = m_proxy->compositeAndReadback(pixels, rect);
     m_triggerIdleUpdates = true;
     return ret;
 }
 
 void LayerTreeHost::finishAllRendering()
 {
     if (!m_rendererInitialized)
         return;
+
+    // Clear any pending commits.
+    setDeferCommits(false);

[jamesr, 2012/10/23 17:50:44]

There are the same sorts of problems here as with compositeAndReadback().  Do
you ever actually call finishAllRendering() from aura/ash code?

[jonathan.backer, 2012/10/23 19:26:42]

'git gs' says no. Just doing it for completeness. I'm more than happy to DCHECK
here. SG?

+
     m_proxy->finishAllRendering();
 }
 
+void LayerTreeHost::setDeferCommits(bool deferCommits)
+{
+    if (m_deferCommits == deferCommits)
+        return;
+    m_deferCommits = deferCommits;
+
+    if (deferCommits)
+        TRACE_EVENT_ASYNC_BEGIN0("cc", "LayerTreeHost::setDeferCommits", this);
+    else
+        TRACE_EVENT_ASYNC_END0("cc", "LayerTreeHost::setDeferCommits", this);
+
+    m_proxy->setDeferCommits(deferCommits);
+}
+
 void LayerTreeHost::renderingStats(RenderingStats* stats) const
 {
     *stats = m_renderingStats;
     m_proxy->renderingStats(stats);
 }
 
 const RendererCapabilities& LayerTreeHost::rendererCapabilities() const
 {
     return m_proxy->rendererCapabilities();
 }
@@ skipping 461 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime);
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace cc