Organize internal properties of cc/ layer types

cc/layer_impl.h

Index: cc/layer_impl.h
diff --git a/cc/layer_impl.h b/cc/layer_impl.h
index 3e72d20a70220a488d3b675637e3892bbd49d503..96c8025c896b702ebafbe65b191cd4763928146d 100644
--- a/cc/layer_impl.h
+++ b/cc/layer_impl.h
@@ -36,6 +36,58 @@ 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;
@@ -162,15 +214,15 @@ public:
     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
@@ -226,8 +278,8 @@ public:
 
     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);
@@ -235,24 +287,24 @@ public:
     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; }
@@ -354,8 +406,6 @@ private:
     // 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;
@@ -380,16 +430,9 @@ private:
     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;
@@ -398,11 +441,6 @@ private:
     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
@@ -411,13 +449,6 @@ private:
     // 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.
@@ -429,6 +460,10 @@ private:
     // 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);
 };