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

cc/layer.cc

 // Copyright 2010 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.h"
 
 #include "cc/active_animation.h"
 #include "cc/animation_events.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
@@ skipping 98 matching lines @@
     if (host && m_layerAnimationController->hasActiveAnimation())
         host->didAddAnimation();
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
+void Layer::setNeedsFullTreeSync()
+{
+    if (m_layerTreeHost)
+        m_layerTreeHost->setNeedsFullTreeSync();
+}
+
 gfx::Rect Layer::layerRectToContentRect(const gfx::RectF& layerRect) const
 {
     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
     // Intersect with content rect to avoid the extra pixel because for some
     // values x and y, ceil((x / y) * y) may be x + 1.
     contentRect.Intersect(gfx::Rect(gfx::Point(), contentBounds()));
     return gfx::ToEnclosingRect(contentRect);
 }
 
 void Layer::setParent(Layer* layer)
@@ skipping 21 matching lines @@
 
 void Layer::insertChild(scoped_refptr<Layer> child, size_t index)
 {
     child->removeFromParent();
     child->setParent(this);
     child->m_stackingOrderChanged = true;
 
     index = min(index, m_children.size());
     LayerList::iterator iter = m_children.begin();
     m_children.insert(iter + index, child);
-    setNeedsCommit();
+    setNeedsFullTreeSync();
 }
 
 void Layer::removeFromParent()
 {
     if (m_parent)
         m_parent->removeChild(this);
 }
 
 void Layer::removeChild(Layer* child)
 {
     for (LayerList::iterator iter = m_children.begin(); iter != m_children.end(); ++iter)
     {
         if (*iter != child)
             continue;
 
         child->setParent(0);
         m_children.erase(iter);
-        setNeedsCommit();
+        setNeedsFullTreeSync();
         return;
     }
 }
 
 void Layer::replaceChild(Layer* reference, scoped_refptr<Layer> newLayer)
 {
     DCHECK(reference);
     DCHECK_EQ(reference->parent(), this);
 
     if (reference == newLayer)
@@ skipping 106 matching lines @@
 {
     if (m_maskLayer == maskLayer)
         return;
     if (m_maskLayer)
         m_maskLayer->setLayerTreeHost(0);
     m_maskLayer = maskLayer;
     if (m_maskLayer) {
         m_maskLayer->setLayerTreeHost(m_layerTreeHost);
         m_maskLayer->setIsMask(true);
     }
-    setNeedsCommit();
+    setNeedsFullTreeSync();
 }
 
 void Layer::setReplicaLayer(Layer* layer)
 {
     if (m_replicaLayer == layer)
         return;
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(0);
     m_replicaLayer = layer;
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(m_layerTreeHost);
-    setNeedsCommit();
+    setNeedsFullTreeSync();
 }
 
 void Layer::setFilters(const WebKit::WebFilterOperations& filters)
 {
     if (m_filters == filters)
         return;
     DCHECK(!m_filter);
     m_filters = filters;
     setNeedsCommit();
     if (!filters.isEmpty())
@@ skipping 76 matching lines @@
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 }
 
 void Layer::setScrollOffset(gfx::Vector2d scrollOffset)
 {
     if (m_scrollOffset == scrollOffset)
         return;
     m_scrollOffset = scrollOffset;
     if (m_layerScrollClient)
         m_layerScrollClient->didScroll();
-    setNeedsCommit();
+    setNeedsFullTreeSync();

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

How come a scrollOffset needs a full sync?

 }
 
 void Layer::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 {
     if (m_maxScrollOffset == maxScrollOffset)
         return;
     m_maxScrollOffset = maxScrollOffset;
     setNeedsCommit();
 }
 
@@ skipping 413 matching lines @@
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }  // namespace cc