Activate LayerImpl tree with sync+push instead of pointer swap

cc/layer_impl.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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/animation_registrar.h"
@@ skipping 18 matching lines @@
     , m_maskLayerId(-1)
     , m_replicaLayerId(-1)
     , m_layerId(id)
     , m_layerTreeImpl(treeImpl)
     , m_anchorPoint(0.5, 0.5)
     , m_anchorPointZ(0)
     , m_scrollable(false)
     , m_shouldScrollOnMainThread(false)
     , m_haveWheelEventHandlers(false)
     , m_backgroundColor(0)
+    , m_stackingOrderChanged(false)
     , m_doubleSided(true)
     , m_layerPropertyChanged(false)
     , m_layerSurfacePropertyChanged(false)
     , m_masksToBounds(false)
     , m_contentsOpaque(false)
     , m_opacity(1.0)
     , m_preserves3D(false)
     , m_useParentBackfaceVisibility(false)
     , m_drawCheckerboardForMissingTiles(false)
     , m_drawsContent(false)
@@ skipping 25 matching lines @@
 }
 
 void LayerImpl::addChild(scoped_ptr<LayerImpl> child)
 {
     child->setParent(this);
     DCHECK_EQ(layerTreeImpl(), child->layerTreeImpl());
     m_children.push_back(child.Pass());
     layerTreeImpl()->SetNeedsUpdateDrawProperties();
 }
 
+LayerImpl* LayerImpl::childAt(size_t index) const
+{
+  DCHECK_LT(index, m_children.size());
+  return m_children[index];
+}
+
 scoped_ptr<LayerImpl> LayerImpl::removeChild(LayerImpl* child)
 {
     for (ScopedPtrVector<LayerImpl>::iterator it = m_children.begin(); it != m_children.end(); ++it) {
         if (*it == child) {
             scoped_ptr<LayerImpl> ret = m_children.take(it);
             m_children.erase(it);
             layerTreeImpl()->SetNeedsUpdateDrawProperties();
             return ret.Pass();
         }
     }
@@ skipping 203 matching lines @@
 bool LayerImpl::canClipSelf() const
 {
     return false;
 }
 
 bool LayerImpl::areVisibleResourcesReady() const
 {
     return true;
 }
 
+scoped_ptr<LayerImpl> LayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
+{
+    return LayerImpl::create(treeImpl, m_layerId);
+}
+
+void LayerImpl::pushPropertiesTo(LayerImpl* layer)
+{
+    layer->setAnchorPoint(m_anchorPoint);
+    layer->setAnchorPointZ(m_anchorPointZ);
+    layer->setBackgroundColor(m_backgroundColor);
+    layer->setBounds(m_bounds);
+    layer->setContentBounds(contentBounds());
+    layer->setContentsScale(contentsScaleX(), contentsScaleY());
+    layer->setDebugName(m_debugName);
+    layer->setDoubleSided(m_doubleSided);
+    layer->setDrawCheckerboardForMissingTiles(m_drawCheckerboardForMissingTiles);
+    layer->setForceRenderSurface(m_forceRenderSurface);
+    layer->setDrawsContent(drawsContent());
+    layer->setFilters(filters());
+    layer->setFilter(filter());
+    layer->setBackgroundFilters(backgroundFilters());
+    layer->setMasksToBounds(m_masksToBounds);
+    layer->setShouldScrollOnMainThread(m_shouldScrollOnMainThread);
+    layer->setHaveWheelEventHandlers(m_haveWheelEventHandlers);
+    layer->setNonFastScrollableRegion(m_nonFastScrollableRegion);
+    layer->setTouchEventHandlerRegion(m_touchEventHandlerRegion);
+    layer->setContentsOpaque(m_contentsOpaque);
+    if (!opacityIsAnimating())
+        layer->setOpacity(m_opacity);
+    layer->setPosition(m_position);
+    layer->setIsContainerForFixedPositionLayers(m_isContainerForFixedPositionLayers);
+    layer->setFixedToContainerLayer(m_fixedToContainerLayer);
+    layer->setPreserves3D(preserves3D());
+    layer->setUseParentBackfaceVisibility(m_useParentBackfaceVisibility);
+    layer->setSublayerTransform(m_sublayerTransform);
+    if (!transformIsAnimating())
+        layer->setTransform(m_transform);
+
+    layer->setScrollable(m_scrollable);
+    layer->setScrollOffset(m_scrollOffset);
+    layer->setMaxScrollOffset(m_maxScrollOffset);
+
+    // If the main thread commits multiple times before the impl thread actually draws, then damage tracking
+    // will become incorrect if we simply clobber the updateRect here. The LayerImpl's updateRect needs to
+    // accumulate (i.e. union) any update changes that have occurred on the main thread.
+    m_updateRect.Union(layer->updateRect());
+    layer->setUpdateRect(m_updateRect);
+
+    layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
+    layer->setSentScrollDelta(gfx::Vector2d());
+
+    layer->setStackingOrderChanged(m_stackingOrderChanged);
+
+    m_layerAnimationController->pushAnimationUpdatesTo(layer->layerAnimationController());
+
+    // Reset any state that should be cleared for the next update.
+    m_stackingOrderChanged = false;
+    m_updateRect = gfx::RectF();
+}
+
 std::string LayerImpl::indentString(int indent)
 {
     std::string str;
     for (int i = 0; i != indent; ++i)
         str.append("  ");
     return str;
 }
 
 void LayerImpl::dumpLayerProperties(std::string* str, int indent) const
 {
@@ skipping 83 matching lines @@
     list = new base::ListValue;
     for (size_t i = 0; i < m_children.size(); ++i)
         list->Append(m_children[i]->layerTreeAsJson());
     result->Set("Children", list);
 
     return result;
 }
 
 void LayerImpl::setStackingOrderChanged(bool stackingOrderChanged)
 {
-    // We don't need to store this flag; we only need to track that the change occurred.
-    if (stackingOrderChanged)
+    if (stackingOrderChanged) {
+        m_stackingOrderChanged = true;
         noteLayerPropertyChangedForSubtree();
+    }
 }
 
 bool LayerImpl::layerSurfacePropertyChanged() const
 {
     if (m_layerSurfacePropertyChanged)
         return true;
 
     // If this layer's surface property hasn't changed, we want to see if
     // some layer above us has changed this property. This is done for the
     // case when such parent layer does not draw content, and therefore will
@@ skipping 132 matching lines @@
     m_replicaLayerId = newLayerId;
     noteLayerPropertyChangedForSubtree();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::takeReplicaLayer()
 {
   m_replicaLayerId = -1;
   return m_replicaLayer.Pass();
 }
 
+ScrollbarLayerImpl* LayerImpl::toScrollbarLayer()
+{
+    return 0;
+}
+
 void LayerImpl::setDrawsContent(bool drawsContent)
 {
     if (m_drawsContent == drawsContent)
         return;
 
     m_drawsContent = drawsContent;
     noteLayerPropertyChanged();
 }
 
 void LayerImpl::setAnchorPoint(const gfx::PointF& anchorPoint)
@@ skipping 295 matching lines @@
         if (!m_scrollbarAnimationController)
             m_scrollbarAnimationController = createScrollbarAnimationControllerWithFade(this);
     } else {
         m_scrollbarAnimationController.reset();
     }
 
 }
 void LayerImpl::setHorizontalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 {
     m_horizontalScrollbarLayer = scrollbarLayer;
+    if (m_horizontalScrollbarLayer)
+        m_horizontalScrollbarLayer->setScrollLayerId(id());
 }
 
 void LayerImpl::setVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 {
     m_verticalScrollbarLayer = scrollbarLayer;
+    if (m_verticalScrollbarLayer)
+        m_verticalScrollbarLayer->setScrollLayerId(id());
 }
 
 }  // namespace cc