Only do full tree sync if tree is actually changed, otherwise just push properties

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 "cc/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "cc/font_atlas.h"
@@ skipping 142 matching lines @@
 {
     scoped_ptr<LayerTreeHost> layerTreeHost(new LayerTreeHost(client, settings));
     if (!layerTreeHost->initialize(implThread.Pass()))
         return scoped_ptr<LayerTreeHost>();
     return layerTreeHost.Pass();
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
     , m_needsAnimateLayers(false)
+    , m_needsFullTreeSync(true)
     , m_client(client)
     , m_commitNumber(0)
     , m_renderingStats()
     , m_rendererInitialized(false)
     , m_contextLost(false)
     , m_numTimesRecreateShouldFail(0)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
@@ skipping 129 matching lines @@
 {
     m_client->layout();
 }
 
 void LayerTreeHost::beginCommitOnImplThread(LayerTreeHostImpl* hostImpl)
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHost::commitTo");
 }
 
+static void pushPropertiesRecursive(Layer* layer, LayerImpl* layerImpl)
+{
+    if (!layer) {
+        DCHECK(!layerImpl);
+        return;
+    }
+
+    DCHECK_EQ(layer->id(), layerImpl->id());
+    layer->pushPropertiesTo(layerImpl);
+
+    pushPropertiesRecursive(layer->maskLayer(), layerImpl->maskLayer());
+    pushPropertiesRecursive(layer->replicaLayer(), layerImpl->replicaLayer());
+
+    const std::vector<scoped_refptr<Layer> >& children = layer->children();
+    const ScopedPtrVector<LayerImpl>& implChildren = layerImpl->children();
+    DCHECK_EQ(children.size(), implChildren.size());

[danakj, 2012/12/03 18:46:25]

should it CRASH() in this case? We could end up passing an address off the end
of the implChildren array to pushPropertiesTo() which could result in bad times.

+
+    for (size_t i = 0; i < children.size(); ++i) {
+        pushPropertiesRecursive(children[i].get(), implChildren[i]);
+    }
+}
+
 // This function commits the LayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a Layer,
 // should be delayed until the LayerTreeHost::commitComplete, which will run
 // after the commit, but on the main thread.
 void LayerTreeHost::finishCommitOnImplThread(LayerTreeHostImpl* hostImpl)
 {
     DCHECK(m_proxy->isImplThread());
 
     m_contentsTextureManager->updateBackingsInDrawingImplTree();
     m_contentsTextureManager->reduceMemory(hostImpl->resourceProvider());
 
-    hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->detachLayerTree(), hostImpl));
+    if (m_needsFullTreeSync) {
+        hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->detachLayerTree(), hostImpl));
+    } else {
+        TRACE_EVENT0("cc", "LayerTreeHost::pushPropertiesRecursive");
+        pushPropertiesRecursive(rootLayer(), hostImpl->rootLayer());
+    }
+    m_needsFullTreeSync = false;
 
     if (m_rootLayer && m_hudLayer)
         hostImpl->setHudLayer(static_cast<HeadsUpDisplayLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_hudLayer->id())));
     else
         hostImpl->setHudLayer(0);
 
     // We may have added an animation during the tree sync. This will cause both layer tree hosts
     // to visit their controllers.
     if (rootLayer() && m_needsAnimateLayers)
         hostImpl->setNeedsAnimateLayers();
@@ skipping 100 matching lines @@
 
 void LayerTreeHost::setNeedsCommit()
 {
     if (!m_prepaintCallback.IsCancelled()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHost::setNeedsCommit::cancel prepaint");
         m_prepaintCallback.Cancel();
     }
     m_proxy->setNeedsCommit();
 }
 
+void LayerTreeHost::setNeedsFullTreeSync()
+{
+    m_needsFullTreeSync = true;
+    setNeedsCommit();
+}
+
 void LayerTreeHost::setNeedsRedraw()
 {
     m_proxy->setNeedsRedraw();
     if (!m_proxy->implThread())
         m_client->scheduleComposite();
 }
 
 bool LayerTreeHost::commitRequested() const
 {
     return m_proxy->commitRequested();
@@ skipping 18 matching lines @@
 
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     m_rootLayer = rootLayer;
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(this);
 
     if (m_hudLayer)
         m_hudLayer->removeFromParent();
 
-    setNeedsCommit();
+    setNeedsFullTreeSync();
 }
 
 void LayerTreeHost::setDebugState(const LayerTreeDebugState& debugState)
 {
     LayerTreeDebugState newDebugState = LayerTreeDebugState::unite(m_settings.initialDebugState, debugState);
 
     if (LayerTreeDebugState::equal(m_debugState, newDebugState))
         return;
 
     m_debugState = newDebugState;
@@ skipping 415 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 }  // namespace cc