Organize internal properties of cc/ layer types

cc/layer.h

 // 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.
 
 #ifndef CC_LAYER_H_
 #define CC_LAYER_H_
 
 #include <public/WebFilterOperations.h>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "cc/cc_export.h"
+#include "cc/draw_properties.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/region.h"
 #include "cc/render_surface.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/transform.h"
 
 namespace WebKit {
@@ skipping 97 matching lines @@
 
     void setFixedToContainerLayer(bool);
     bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }
 
     void setSublayerTransform(const gfx::Transform&);
     const gfx::Transform& sublayerTransform() const { return m_sublayerTransform; }
 
     void setTransform(const gfx::Transform&);
     bool transformIsAnimating() const;
 
-    const gfx::Rect& visibleContentRect() const { return m_visibleContentRect; }
-    void setVisibleContentRect(const gfx::Rect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
+    DrawProperties<Layer>& drawProperties() { return m_drawProperties; }
+    const DrawProperties<Layer>& drawProperties() const { return m_drawProperties; }
+
+    // The following are shortcut accessors to get various information from m_drawProperties
+    const gfx::Transform& drawTransform() const { return m_drawProperties.drawTransform; }
+    const gfx::Transform& screenSpaceTransform() const { return m_drawProperties.screenSpaceTransform; }
+    float drawOpacity() const { return m_drawProperties.drawOpacity; }
+    bool drawOpacityIsAnimating() const { return m_drawProperties.drawOpacityIsAnimating; }
+    bool drawTransformIsAnimating() const { return m_drawProperties.drawTransformIsAnimating; }
+    bool screenSpaceTransformIsAnimating() const { return m_drawProperties.screenSpaceTransformIsAnimating; }
+    bool isClipped() const { return m_drawProperties.isClipped; }
+    const gfx::Rect& clipRect() const { return m_drawProperties.clipRect; }
+    const gfx::Rect& drawableContentRect() const { return m_drawProperties.drawableContentRect; }
+    const gfx::Rect& visibleContentRect() const { return m_drawProperties.visibleContentRect; }
+    Layer* renderTarget() { DCHECK(!m_drawProperties.renderTarget || m_drawProperties.renderTarget->renderSurface()); return m_drawProperties.renderTarget; }
+    const Layer* renderTarget() const { DCHECK(!m_drawProperties.renderTarget || m_drawProperties.renderTarget->renderSurface()); return m_drawProperties.renderTarget; }
 
     void setScrollOffset(gfx::Vector2d);
     gfx::Vector2d scrollOffset() const { return m_scrollOffset; }
 
     void setMaxScrollOffset(gfx::Vector2d);
     gfx::Vector2d maxScrollOffset() const { return m_maxScrollOffset; }
 
     void setScrollable(bool);
     bool scrollable() const { return m_scrollable; }
 
@@ skipping 58 matching lines @@
     virtual void bindContentsTexture() { }
 
     void setDebugName(const std::string&);
 
     virtual void pushPropertiesTo(LayerImpl*);
 
     void clearRenderSurface() { m_renderSurface.reset(); }
     RenderSurface* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
 
-    float drawOpacity() const { return m_drawOpacity; }
-    void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
-
-    bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
-    void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
-
-    void setRenderTarget(Layer* target) { m_renderTarget = target; }
-    Layer* renderTarget() { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
-    const Layer* renderTarget() const { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
-
-    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; }
-
-    // This moves from layer space, with origin in the center to target space with origin in the top left.
-    // That is, it converts from logical, non-page-scaled, to target pixels (and if the target is the
-    // root render surface, then this converts to physical pixels).
-    const gfx::Transform& drawTransform() const { return m_drawTransform; }
-    void setDrawTransform(const gfx::Transform& matrix) { m_drawTransform = matrix; }
-    // This moves from content space, with origin the top left to screen space with origin in the top left.
-    // It converts logical, non-page-scaled pixels to physical pixels.
-    const gfx::Transform& screenSpaceTransform() const { return m_screenSpaceTransform; }
-    void setScreenSpaceTransform(const gfx::Transform& matrix) { m_screenSpaceTransform = matrix; }
-
-    bool isClipped() const { return m_isClipped; }
-    void setIsClipped(bool isClipped) { m_isClipped = isClipped; }
-
-    const gfx::Rect& clipRect() const { return m_clipRect; }
-    void setClipRect(const gfx::Rect& clipRect) { m_clipRect = clipRect; }
-
-    const gfx::Rect& drawableContentRect() const { return m_drawableContentRect; }
-    void setDrawableContentRect(const gfx::Rect& rect) { m_drawableContentRect = rect; }
-
     // The contentsScale converts from logical, non-page-scaled pixels to target pixels.
     // The contentsScale is 1 for the root layer as it is already in physical pixels.
     // By default contentsScale is forced to be 1 except for subclasses of ContentsScalingLayer.
     virtual float contentsScaleX() const;
     virtual float contentsScaleY() const;
     virtual void setContentsScale(float contentsScale) { }

[danakj, 2012/12/03 18:54:36]

setContentsScale is called from calcDrawEtc on the main thread only. How should
it relate to this struct?

[shawnsingh, 2012/12/03 19:27:44]

Been meaning to discuss this with you offline =)  had some questions/thoughts
about how it's computed in calcDrawTransforms.

[enne (OOO), 2012/12/03 21:18:14]

Given that contentsScale isn't stored on Layer in any case, I don't think it can
be part of the struct.  I'm fine with punting.  If you wanted something in the
struct, it'd have to be "ideal contents scale" and layers could choose to ignore
it if they wanted.

[danakj, 2012/12/03 21:29:45]

Oh, good point! Putting it in the struct is a bit awkward. We'd really want a
virtual method or something and then C++ would expload.

 
     // The scale at which contents should be rastered, to match the scale at
     // which they will drawn to the screen. This scale is a component of the
     // contentsScale() but does not include page/device scale factors.
     float rasterScale() const { return m_rasterScale; }
     void setRasterScale(float scale);
 
     // When true, the rasterScale() will be set by the compositor. If false, it
     // will use whatever value is given to it by the embedder.
     bool automaticallyComputeRasterScale() { return m_automaticallyComputeRasterScale; }
@@ skipping 88 matching lines @@
     // Layer instances have a weak pointer to their LayerTreeHost.
     // This pointer value is nil when a Layer is not in a tree and is
     // updated via setLayerTreeHost() if a layer moves between trees.
     LayerTreeHost* m_layerTreeHost;
 
     scoped_ptr<LayerAnimationController> m_layerAnimationController;
 
     // Layer properties.
     gfx::Size m_bounds;
 
-    // Uses layer's content space.
-    gfx::Rect m_visibleContentRect;
-
     gfx::Vector2d m_scrollOffset;
     gfx::Vector2d m_maxScrollOffset;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     bool m_nonFastScrollableRegionChanged;
     Region m_touchEventHandlerRegion;
     bool m_touchEventHandlerRegionChanged;
     gfx::PointF m_position;
@@ skipping 17 matching lines @@
     bool m_drawCheckerboardForMissingTiles;
     bool m_forceRenderSurface;
 
     gfx::Transform m_transform;
     gfx::Transform m_sublayerTransform;
 
     // Replica layer used for reflections.
     scoped_refptr<Layer> m_replicaLayer;
 
     // Transient properties.
     scoped_ptr<RenderSurface> m_renderSurface;

[danakj, 2012/12/03 18:54:36]

render surface is created/assigned in calcDraw. Should it be part of the struct?

[shawnsingh, 2012/12/03 19:27:44]

Agreed, I'll move it over

-    float m_drawOpacity;
-    bool m_drawOpacityIsAnimating;
-
-    Layer* m_renderTarget;
-
-    gfx::Transform m_drawTransform;
-    gfx::Transform m_screenSpaceTransform;
-    bool m_drawTransformIsAnimating;
-    bool m_screenSpaceTransformIsAnimating;
-
-    // Uses target surface space.
-    gfx::Rect m_drawableContentRect;
-    gfx::Rect m_clipRect;
-
-    // True if the layer is clipped by m_clipRect
-    bool m_isClipped;
 
     float m_rasterScale;
     bool m_automaticallyComputeRasterScale;
     bool m_boundsContainPageScale;
 
     gfx::Transform m_implTransform;
 
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
+
+    DrawProperties<Layer> m_drawProperties;
 };
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*);
 
 }  // namespace cc
 
 #endif  // CC_LAYER_H_