Activate LayerImpl tree with sync+push instead of pointer swap

cc/layer_impl.h

 // 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.
 
 #ifndef CC_LAYER_IMPL_H_
 #define CC_LAYER_IMPL_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 49 matching lines @@
 
     // LayerAnimationValueObserver implementation.
     virtual void OnOpacityAnimated(float) OVERRIDE;
     virtual void OnTransformAnimated(const gfx::Transform&) OVERRIDE;
     virtual bool IsActive() const OVERRIDE;
 
     // Tree structure.
     LayerImpl* parent() { return m_parent; }
     const LayerImpl* parent() const { return m_parent; }
     const LayerList& children() const { return m_children; }
+    LayerList& children() { return m_children; }
+    LayerImpl* childAt(size_t index) const;
     void addChild(scoped_ptr<LayerImpl>);
     scoped_ptr<LayerImpl> removeChild(LayerImpl* child);
     void removeAllChildren();
+    void setParent(LayerImpl* parent) { m_parent = parent; }
+    void clearChildList(); // Warning: This does not preserve tree structure invariants.
 
     void setMaskLayer(scoped_ptr<LayerImpl>);
     LayerImpl* maskLayer() { return m_maskLayer.get(); }
     const LayerImpl* maskLayer() const { return m_maskLayer.get(); }
+    scoped_ptr<LayerImpl> takeMaskLayer();
 
     void setReplicaLayer(scoped_ptr<LayerImpl>);
     LayerImpl* replicaLayer() { return m_replicaLayer.get(); }
     const LayerImpl* replicaLayer() const { return m_replicaLayer.get(); }
+    scoped_ptr<LayerImpl> takeReplicaLayer();
 
     bool hasMask() const { return m_maskLayer; }
     bool hasReplica() const { return m_replicaLayer; }
     bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); }
 
     LayerTreeImpl* layerTreeImpl() const { return m_layerTreeImpl; }
 
     scoped_ptr<SharedQuadState> createSharedQuadState() const;
     // willDraw must be called before appendQuads. If willDraw is called,
     // didDraw is guaranteed to be called before another willDraw or before
     // the layer is destroyed. To enforce this, any class that overrides
     // willDraw/didDraw must call the base class version.
     virtual void willDraw(ResourceProvider*);
     virtual void appendQuads(QuadSink&, AppendQuadsData&) { }
     virtual void didDraw(ResourceProvider*);
 
     virtual ResourceProvider::ResourceId contentsResourceId() const;
 
     virtual bool hasDelegatedContent() const;
     virtual bool hasContributingDelegatedRenderPasses() const;
     virtual RenderPass::Id firstContributingRenderPassId() const;
     virtual RenderPass::Id nextContributingRenderPassId(RenderPass::Id) const;
 
+    virtual ScrollbarLayerImpl* toScrollbarLayer();
+
     // Returns true if this layer has content to draw.
     void setDrawsContent(bool);
     bool drawsContent() const { return m_drawsContent; }
 
     bool forceRenderSurface() const { return m_forceRenderSurface; }
     void setForceRenderSurface(bool force) { m_forceRenderSurface = force; }
 
     void setAnchorPoint(const gfx::PointF&);
     const gfx::PointF& anchorPoint() const { return m_anchorPoint; }
 
@@ skipping 175 matching lines @@
     ScrollbarLayerImpl* verticalScrollbarLayer() { return m_verticalScrollbarLayer; }
 
     gfx::Rect layerRectToContentRect(const gfx::RectF& layerRect) const;
 
     virtual skia::RefPtr<SkPicture> getPicture();
 
     virtual bool canClipSelf() const;
 
     virtual bool areVisibleResourcesReady() const;
 
+    virtual scoped_ptr<LayerImpl> createLayerImpl(LayerTreeImpl*);
+    virtual void pushPropertiesTo(LayerImpl*);
+
 protected:
     LayerImpl(LayerTreeImpl* layerImpl, int);
 
     // Get the color and size of the layer's debug border.
     virtual void getDebugBorderProperties(SkColor*, float* width) const;
 
     void appendDebugBorderQuad(QuadSink&, const SharedQuadState*, AppendQuadsData&) const;
 
     virtual void dumpLayerProperties(std::string*, int indent) const;
     static std::string indentString(int indent);
 
 private:
-    scoped_ptr<LayerImpl> takeMaskLayer();
-    scoped_ptr<LayerImpl> takeReplicaLayer();
-
-    void setParent(LayerImpl* parent) { m_parent = parent; }
-    friend class TreeSynchronizer;
-    void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer.
-
     void updateScrollbarPositions();
 
     void noteLayerSurfacePropertyChanged();
     void noteLayerPropertyChanged();
     void noteLayerPropertyChangedForSubtree();
 
     // Note carefully this does not affect the current layer.
     void noteLayerPropertyChangedForDescendants();
 
     virtual const char* layerTypeAsString() const;
@@ skipping 15 matching lines @@
     gfx::PointF m_anchorPoint;
     float m_anchorPointZ;
     gfx::Size m_bounds;
     gfx::Vector2d m_scrollOffset;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     Region m_touchEventHandlerRegion;
     SkColor m_backgroundColor;
+    bool m_stackingOrderChanged;
 
     // Whether the "back" of this layer should draw.
     bool m_doubleSided;
 
     // Tracks if drawing-related properties have changed since last redraw.
     bool m_layerPropertyChanged;
 
     // Indicates that a property has changed on this layer that would not
     // affect the pixels on its target surface, but would require redrawing
     // but would require redrawing the targetSurface onto its ancestor targetSurface.
@@ skipping 58 matching lines @@
     // Group of properties that need to be computed based on the layer tree
     // hierarchy before layers can be drawn.
     DrawProperties<LayerImpl, RenderSurfaceImpl> m_drawProperties;
 
     DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }
 
 #endif  // CC_LAYER_IMPL_H_