Organize internal properties of cc/ layer types

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 <public/WebFilterOperations.h>
 #include <string>
 
@@ skipping 18 matching lines @@
 class LayerSorter;
 class LayerTreeHostImpl;
 class QuadSink;
 class Renderer;
 class ScrollbarAnimationController;
 class ScrollbarLayerImpl;
 class Layer;
 
 struct AppendQuadsData;
 
+// Container for properties that layers need to compute before they can be drawn.
+struct DrawProperties {

[danakj, 2012/12/01 03:51:40]

If the struct has all the same things on both threads.. can we pull it out and
have it shared between layer and layer impl?

I'd reeeally love to have some sharing between these two.

+    DrawProperties()
+        : drawOpacity(0)
+        , drawOpacityIsAnimating(false)
+        , drawTransformIsAnimating(false)
+        , screenSpaceTransformIsAnimating(false)
+        , isClipped(false)
+        , renderTarget(0)
+    {
+    }
+
+    // Transforms objects from content space to target surface space, where
+    // this layer would be drawn.
+    gfx::Transform drawTransform;
+
+    // Transforms objects from content space to screen space (viewport space).
+    gfx::Transform screenSpaceTransform;
+
+    // drawOpacity may be different than layer's opacity, particularly in the
+    // case where a renderSurface re-parents the layer's opacity.
+    float drawOpacity;
+
+    // XXXIsAnimating flags are used to indicate whether the drawProperties
+    // are actually meaningful on the main thread. When the properties are
+    // animating, the main thread may not have the same values that are used
+    // to draw.
+    bool drawOpacityIsAnimating;
+    bool drawTransformIsAnimating;
+    bool screenSpaceTransformIsAnimating;
+
+    // True if the layer needs to be clipped by clipRect.
+    bool isClipped;
+
+    // The layer whose coordinate space this layer draws into. This can be
+    // either the same layer (m_drawProperties.renderTarget == this) or an
+    // ancestor of this layer.
+    LayerImpl* renderTarget;
+
+    // Uses layer's content space.
+    gfx::Rect visibleContentRect;
+
+    // In target surface space, the rect that encloses the clipped, drawable
+    // content of the layer.
+    gfx::Rect drawableContentRect;
+
+    // In target surface space, the original rect that clipped this
+    // layer. This value is used to avoid unnecessarily changing GL scissor
+    // state.
+    gfx::Rect clipRect;
+};
+
 class CC_EXPORT LayerImpl : public LayerAnimationControllerClient {
 public:
     typedef ScopedPtrVector<LayerImpl> LayerList;
 
     static scoped_ptr<LayerImpl> create(int id)
     {
         return make_scoped_ptr(new LayerImpl(id));
     }
 
     virtual ~LayerImpl();
@@ skipping 106 matching lines @@
     // Debug layer name.
     void setDebugName(const std::string& debugName) { m_debugName = debugName; }
     std::string debugName() const { return m_debugName; }
 
     bool showDebugBorders() const;
 
     RenderSurfaceImpl* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
     void clearRenderSurface() { m_renderSurface.reset(); }
 
-    float drawOpacity() const { return m_drawOpacity; }
-    void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
+    float drawOpacity() const { return m_drawProperties.drawOpacity; }

[danakj, 2012/12/01 03:51:40]

I guess the plan is for these accessors to go away?

+    void setDrawOpacity(float opacity) { m_drawProperties.drawOpacity = opacity; }
 
-    bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
-    void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
+    bool drawOpacityIsAnimating() const { return m_drawProperties.drawOpacityIsAnimating; }
+    void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawProperties.drawOpacityIsAnimating = drawOpacityIsAnimating; }
 
-    void setRenderTarget(LayerImpl* target) { m_renderTarget = target; }
-    LayerImpl* renderTarget() { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
-    const LayerImpl* renderTarget() const { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
+    void setRenderTarget(LayerImpl* target) { m_drawProperties.renderTarget = target; }
+    LayerImpl* renderTarget() { DCHECK(!m_drawProperties.renderTarget || m_drawProperties.renderTarget->renderSurface()); return m_drawProperties.renderTarget; }
+    const LayerImpl* renderTarget() const { DCHECK(!m_drawProperties.renderTarget || m_drawProperties.renderTarget->renderSurface()); return m_drawProperties.renderTarget; }
 
     // The client should be responsible for setting bounds, contentBounds and
     // contentsScale to appropriate values. LayerImpl doesn't calculate any of
     // them from the other values.
 
     void setBounds(const gfx::Size&);
     const gfx::Size& bounds() const { return m_bounds; }
 
     // ContentBounds may be [0, 1) pixels larger than bounds * contentsScale.
     // Don't calculate scale from it. Use contentsScale instead for accuracy.
@@ skipping 35 matching lines @@
     void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; }
 
     const Region& touchEventHandlerRegion() const { return m_touchEventHandlerRegion; }
     void setTouchEventHandlerRegion(const Region& region) { m_touchEventHandlerRegion = region; }
 
     void setDrawCheckerboardForMissingTiles(bool checkerboard) { m_drawCheckerboardForMissingTiles = checkerboard; }
     bool drawCheckerboardForMissingTiles() const;
 
     InputHandlerClient::ScrollStatus tryScroll(const gfx::PointF& screenSpacePoint, InputHandlerClient::ScrollInputType) const;
 
-    const gfx::Rect& visibleContentRect() const { return m_visibleContentRect; }
-    void setVisibleContentRect(const gfx::Rect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
+    const gfx::Rect& visibleContentRect() const { return m_drawProperties.visibleContentRect; }
+    void setVisibleContentRect(const gfx::Rect& visibleContentRect) { m_drawProperties.visibleContentRect = visibleContentRect; }
 
     bool doubleSided() const { return m_doubleSided; }
     void setDoubleSided(bool);
 
     void setTransform(const gfx::Transform&);
     bool transformIsAnimating() const;
 
-    const gfx::Transform& drawTransform() const { return m_drawTransform; }
-    void setDrawTransform(const gfx::Transform& matrix) { m_drawTransform = matrix; }
-    const gfx::Transform& screenSpaceTransform() const { return m_screenSpaceTransform; }
-    void setScreenSpaceTransform(const gfx::Transform& matrix) { m_screenSpaceTransform = matrix; }
+    const gfx::Transform& drawTransform() const { return m_drawProperties.drawTransform; }
+    void setDrawTransform(const gfx::Transform& matrix) { m_drawProperties.drawTransform = matrix; }
+    const gfx::Transform& screenSpaceTransform() const { return m_drawProperties.screenSpaceTransform; }
+    void setScreenSpaceTransform(const gfx::Transform& matrix) { m_drawProperties.screenSpaceTransform = matrix; }
 
-    bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
-    void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
-    bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
-    void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
+    bool drawTransformIsAnimating() const { return m_drawProperties.drawTransformIsAnimating; }
+    void setDrawTransformIsAnimating(bool animating) { m_drawProperties.drawTransformIsAnimating = animating; }
+    bool screenSpaceTransformIsAnimating() const { return m_drawProperties.screenSpaceTransformIsAnimating; }
+    void setScreenSpaceTransformIsAnimating(bool animating) { m_drawProperties.screenSpaceTransformIsAnimating = animating; }
 
-    bool isClipped() const { return m_isClipped; }
-    void setIsClipped(bool isClipped) { m_isClipped = isClipped; }
+    bool isClipped() const { return m_drawProperties.isClipped; }
+    void setIsClipped(bool isClipped) { m_drawProperties.isClipped = isClipped; }
 
-    const gfx::Rect& clipRect() const { return m_clipRect; }
-    void setClipRect(const gfx::Rect& clipRect) { m_clipRect = clipRect; }
+    const gfx::Rect& clipRect() const { return m_drawProperties.clipRect; }
+    void setClipRect(const gfx::Rect& clipRect) { m_drawProperties.clipRect = clipRect; }
 
-    const gfx::Rect& drawableContentRect() const { return m_drawableContentRect; }
-    void setDrawableContentRect(const gfx::Rect& rect) { m_drawableContentRect = rect; }
+    const gfx::Rect& drawableContentRect() const { return m_drawProperties.drawableContentRect; }
+    void setDrawableContentRect(const gfx::Rect& rect) { m_drawProperties.drawableContentRect = rect; }
 
     const gfx::RectF& updateRect() const { return m_updateRect; }
     void setUpdateRect(const gfx::RectF& updateRect) { m_updateRect = updateRect; }
 
     std::string layerTreeAsText() const;
 
     void setStackingOrderChanged(bool);
 
     bool layerPropertyChanged() const { return m_layerPropertyChanged || layerIsAlwaysDamaged(); }
     bool layerSurfacePropertyChanged() const;
@@ skipping 81 matching lines @@
 
     // 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.
     // For layers that do not own a surface this flag acts as m_layerPropertyChanged.
     bool m_layerSurfacePropertyChanged;
 
-    // Uses layer's content space.
-    gfx::Rect m_visibleContentRect;
     bool m_masksToBounds;
     bool m_contentsOpaque;
     float m_opacity;
     gfx::PointF m_position;
     bool m_preserves3D;
     bool m_useParentBackfaceVisibility;
     bool m_drawCheckerboardForMissingTiles;
     gfx::Transform m_sublayerTransform;
     gfx::Transform m_transform;
     bool m_useLCDText;
 
     bool m_drawsContent;
     bool m_forceRenderSurface;
 
     // Set for the layer that other layers are fixed to.
     bool m_isContainerForFixedPositionLayers;
     // This is true if the layer should be fixed to the closest ancestor container.
     bool m_fixedToContainerLayer;
 
     gfx::Vector2dF m_scrollDelta;
     gfx::Vector2d m_sentScrollDelta;
     gfx::Vector2d m_maxScrollOffset;
     gfx::Transform m_implTransform;
 
-    // The layer whose coordinate space this layer draws into. This can be
-    // either the same layer (m_renderTarget == this) or an ancestor of this
-    // layer.
-    LayerImpl* m_renderTarget;
-
     // The global depth value of the center of the layer. This value is used
     // to sort layers from back to front.
     float m_drawDepth;
-    float m_drawOpacity;
-    bool m_drawOpacityIsAnimating;
 
     // Debug layer name.
     std::string m_debugName;
 
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
     SkImageFilter* m_filter;
 
-    gfx::Transform m_drawTransform;
-    gfx::Transform m_screenSpaceTransform;
-    bool m_drawTransformIsAnimating;
-    bool m_screenSpaceTransformIsAnimating;
-
 #ifndef NDEBUG
     bool m_betweenWillDrawAndDidDraw;
 #endif
 
     // Render surface associated with this layer. The layer and its descendants
     // will render to this surface.
     scoped_ptr<RenderSurfaceImpl> m_renderSurface;
 
-    // Uses target surface's space.
-    gfx::Rect m_drawableContentRect;
-    gfx::Rect m_clipRect;
-
-    // True if the layer is clipped by m_clipRect.
-    bool m_isClipped;
-
     // Rect indicating what was repainted/updated during update.
     // Note that plugin layers bypass this and leave it empty.
     // Uses layer's content space.
     gfx::RectF m_updateRect;
 
     // Manages animations for this layer.
     scoped_ptr<LayerAnimationController> m_layerAnimationController;
 
     // Manages scrollbars for this layer
     scoped_ptr<ScrollbarAnimationController> m_scrollbarAnimationController;
 
+    // Group of properties that need to be computed based on the layer tree
+    // hierarchy before layers can be drawn.
+    DrawProperties m_drawProperties;
+
     DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter*);
 
 }
 
 #endif  // CC_LAYER_IMPL_H_