cc: Use gfx:: Geometry types for positions, bounds, and related things.

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 LayerChromium_h
 #define LayerChromium_h
 
-#include "FloatPoint.h"
 #include "Region.h"
 #include "base/memory/ref_counted.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/occlusion_tracker.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 <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 #include <string>
 #include <vector>
 
 namespace WebKit {
 class WebAnimationDelegate;
 class WebLayerScrollClient;
 }
 
@@ skipping 34 matching lines @@
     Layer* parent() const;
     void addChild(scoped_refptr<Layer>);
     void insertChild(scoped_refptr<Layer>, size_t index);
     void replaceChild(Layer* reference, scoped_refptr<Layer> newLayer);
     void removeFromParent();
     void removeAllChildren();
     void setChildren(const LayerList&);
 
     const LayerList& children() const { return m_children; }
 
-    void setAnchorPoint(const FloatPoint&);
-    FloatPoint anchorPoint() const { return m_anchorPoint; }
+    void setAnchorPoint(const gfx::PointF&);
+    gfx::PointF anchorPoint() const { return m_anchorPoint; }
 
     void setAnchorPointZ(float);
     float anchorPointZ() const { return m_anchorPointZ; }
 
     void setBackgroundColor(SkColor);
     SkColor backgroundColor() const { return m_backgroundColor; }
 
     // A layer's bounds are in logical, non-page-scaled pixels (however, the
     // root layer's bounds are in physical pixels).
-    void setBounds(const IntSize&);
-    const IntSize& bounds() const { return m_bounds; }
-    virtual IntSize contentBounds() const;
+    void setBounds(const gfx::Size&);
+    const gfx::Size& bounds() const { return m_bounds; }
+    virtual gfx::Size contentBounds() const;
 
     void setMasksToBounds(bool);
     bool masksToBounds() const { return m_masksToBounds; }
 
     void setMaskLayer(Layer*);
     Layer* maskLayer() const { return m_maskLayer.get(); }
 
-    virtual void setNeedsDisplayRect(const FloatRect& dirtyRect);
-    void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); }
+    virtual void setNeedsDisplayRect(const gfx::RectF& dirtyRect);
+    void setNeedsDisplay() { setNeedsDisplayRect(gfx::RectF(gfx::PointF(), bounds())); }
     virtual bool needsDisplay() const;
 
     void setOpacity(float);
     bool opacityIsAnimating() const;
 
     void setFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& filters() const { return m_filters; }
 
     void setFilter(SkImageFilter* filter);
     SkImageFilter* filter() const { return m_filter; }
 
     // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque
     // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.
     void setBackgroundFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
 
     virtual void setContentsOpaque(bool);
     bool contentsOpaque() const { return m_contentsOpaque; }
 
-    void setPosition(const FloatPoint&);
-    FloatPoint position() const { return m_position; }
+    void setPosition(const gfx::PointF&);
+    gfx::PointF position() const { return m_position; }
 
     void setIsContainerForFixedPositionLayers(bool);
     bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; }
 
     void setFixedToContainerLayer(bool);
     bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }
 
     void setSublayerTransform(const WebKit::WebTransformationMatrix&);
     const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
 
     void setTransform(const WebKit::WebTransformationMatrix&);
     bool transformIsAnimating() const;
 
-    const IntRect& visibleContentRect() const { return m_visibleContentRect; }
-    void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
+    const gfx::Rect& visibleContentRect() const { return m_visibleContentRect; }
+    void setVisibleContentRect(const gfx::Rect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
 
     void setScrollPosition(const IntPoint&);
     const IntPoint& scrollPosition() const { return m_scrollPosition; }
 
     void setMaxScrollPosition(const IntSize&);
     const IntSize& maxScrollPosition() const { return m_maxScrollPosition; }
 
     void setScrollable(bool);
     bool scrollable() const { return m_scrollable; }
 
@@ skipping 79 matching lines @@
 
     // 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 WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; }
     void setDrawTransform(const WebKit::WebTransformationMatrix& 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 WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }
     void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }
-    const IntRect& drawableContentRect() const { return m_drawableContentRect; }
-    void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
+    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.
     float contentsScale() const { return m_contentsScale; }
     void setContentsScale(float);
 
     // 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; }
@@ skipping 43 matching lines @@
 
 protected:
     friend class LayerImpl;
     friend class TreeSynchronizer;
     virtual ~Layer();
 
     Layer();
 
     void setNeedsCommit();
 
-    IntRect layerRectToContentRect(const WebKit::WebRect& layerRect);
+    gfx::Rect layerRectToContentRect(const gfx::Rect& layerRect);
 
     // This flag is set when layer need repainting/updating.
     bool m_needsDisplay;
 
     // Tracks whether this layer may have changed stacking order with its siblings.
     bool m_stackingOrderChanged;
 
     // The update rect is the region of the compositor resource that was actually updated by the compositor.
     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
     // is not available and the update rect will remain empty.
     // Note this rect is in layer space (not content space).
-    FloatRect m_updateRect;
+    gfx::RectF m_updateRect;
 
     scoped_refptr<Layer> m_maskLayer;
 
     // Constructs a LayerImpl of the correct runtime type for this Layer type.
     virtual scoped_ptr<LayerImpl> createLayerImpl();
     int m_layerId;
 
 private:
     friend class base::RefCounted<Layer>;
 
@@ skipping 13 matching lines @@
     Layer* m_parent;
 
     // 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.
-    IntSize m_bounds;
+    gfx::Size m_bounds;
 
     // Uses layer's content space.
-    IntRect m_visibleContentRect;
+    gfx::Rect m_visibleContentRect;
 
     IntPoint m_scrollPosition;
     IntSize m_maxScrollPosition;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     bool m_nonFastScrollableRegionChanged;
-    FloatPoint m_position;
-    FloatPoint m_anchorPoint;
+    gfx::PointF m_position;
+    gfx::PointF m_anchorPoint;
     SkColor m_backgroundColor;
     SkColor m_debugBorderColor;
     float m_debugBorderWidth;
     std::string m_debugName;
     float m_opacity;
     SkImageFilter* m_filter;
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
     float m_anchorPointZ;
     bool m_isContainerForFixedPositionLayers;
@@ skipping 20 matching lines @@
     bool m_drawOpacityIsAnimating;
 
     Layer* m_renderTarget;
 
     WebKit::WebTransformationMatrix m_drawTransform;
     WebKit::WebTransformationMatrix m_screenSpaceTransform;
     bool m_drawTransformIsAnimating;
     bool m_screenSpaceTransformIsAnimating;
 
     // Uses target surface space.
-    IntRect m_drawableContentRect;
+    gfx::Rect m_drawableContentRect;
     float m_contentsScale;
     float m_rasterScale;
     bool m_automaticallyComputeRasterScale;
     bool m_boundsContainPageScale;
 
     WebKit::WebTransformationMatrix m_implTransform;
 
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
 };
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*);
 
 }  // namespace cc
 
 #endif