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

cc/layer_tree_host_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 CCLayerTreeHostImpl_h
 #define CCLayerTreeHostImpl_h
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 57 matching lines @@
     void setSentPageScaleDelta(float delta) { m_sentPageScaleDelta = delta; }
     float sentPageScaleDelta() const { return m_sentPageScaleDelta; }
 
     // Returns true if the passed parameters were different from those previously
     // cached.
     bool setPageScaleFactorAndLimits(float pageScaleFactor,
                                      float minPageScaleFactor,
                                      float maxPageScaleFactor);
 
     // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom.
-    FloatRect bounds() const;
+    gfx::RectF bounds() const;
     const FloatPoint& scrollDelta() const { return m_pinchViewportScrollDelta; }
 
-    void setLayoutViewportSize(const FloatSize& size) { m_layoutViewportSize = size; }
+    void setLayoutViewportSize(const gfx::SizeF& size) { m_layoutViewportSize = size; }
 
     // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be
     // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to
     // this constraint.
     FloatSize applyScroll(FloatSize&);
 
     WebKit::WebTransformationMatrix implTransform() const;
 
 private:
     float m_pageScaleFactor;
     float m_pageScaleDelta;
     float m_sentPageScaleDelta;
     float m_maxPageScaleFactor;
     float m_minPageScaleFactor;
 
     FloatPoint m_pinchViewportScrollDelta;
-    FloatSize m_layoutViewportSize;
+    gfx::SizeF m_layoutViewportSize;
 };
 
 // LayerTreeHostImpl owns the LayerImpl tree as well as associated rendering state
 class LayerTreeHostImpl : public InputHandlerClient,
                             public RendererClient,
                             public WebKit::WebCompositorOutputSurfaceClient {
     typedef std::vector<LayerImpl*> LayerList;
 
 public:
     static scoped_ptr<LayerTreeHostImpl> create(const LayerTreeSettings&, LayerTreeHostImplClient*);
@@ skipping 31 matching lines @@
     // Returns false if problems occured preparing the frame, and we should try
     // to avoid displaying the frame. If prepareToDraw is called,
     // didDrawAllLayers must also be called, regardless of whether drawLayers is
     // called between the two.
     virtual bool prepareToDraw(FrameData&);
     virtual void drawLayers(const FrameData&);
     // Must be called if and only if prepareToDraw was called.
     void didDrawAllLayers(const FrameData&);
 
     // RendererClient implementation
-    virtual const IntSize& deviceViewportSize() const OVERRIDE;
+    virtual const gfx::Size& deviceViewportSize() const OVERRIDE;
     virtual const LayerTreeSettings& settings() const OVERRIDE;
     virtual void didLoseContext() OVERRIDE;
     virtual void onSwapBuffersComplete() OVERRIDE;
     virtual void setFullRootLayerDamage() OVERRIDE;
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
 
     // WebCompositorOutputSurfaceClient implementation.
     virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE;
 
     // Implementation
     bool canDraw();
     GraphicsContext* context() const;
 
     std::string layerTreeAsText() const;
 
     void finishAllRendering();
     int sourceAnimationFrameNumber() const;
 
     bool initializeRenderer(scoped_ptr<GraphicsContext>);
     bool isContextLost();
     Renderer* renderer() { return m_renderer.get(); }
     const RendererCapabilities& rendererCapabilities() const;
 
     bool swapBuffers();
 
-    void readback(void* pixels, const IntRect&);
+    void readback(void* pixels, const gfx::Rect&);
 
     void setRootLayer(scoped_ptr<LayerImpl>);
     LayerImpl* rootLayer() { return m_rootLayerImpl.get(); }
 
     void setHudLayer(HeadsUpDisplayLayerImpl* layerImpl) { m_hudLayerImpl = layerImpl; }
     HeadsUpDisplayLayerImpl* hudLayer() { return m_hudLayerImpl; }
 
     // Release ownership of the current layer tree and replace it with an empty
     // tree. Returns the root layer of the detached tree.
     scoped_ptr<LayerImpl> detachLayerTree();
 
     LayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; }
 
     bool visible() const { return m_visible; }
     void setVisible(bool);
 
     int sourceFrameNumber() const { return m_sourceFrameNumber; }
     void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
 
     bool contentsTexturesPurged() const { return m_contentsTexturesPurged; }
     void setContentsTexturesPurged();
     void resetContentsTexturesPurged();
     size_t memoryAllocationLimitBytes() const { return m_managedMemoryPolicy.bytesLimitWhenVisible; }
 
-    void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize);
-    const IntSize& layoutViewportSize() const { return m_layoutViewportSize; }
+    void setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize);
+    const gfx::Size& layoutViewportSize() const { return m_layoutViewportSize; }
 
     float deviceScaleFactor() const { return m_deviceScaleFactor; }
     void setDeviceScaleFactor(float);
 
     float pageScaleFactor() const;
     void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
 
     scoped_ptr<ScrollAndScaleSet> processScrollDeltas();
     WebKit::WebTransformationMatrix implTransform() const;
 
@@ skipping 74 matching lines @@
     void setPageScaleDelta(float);
     void updateMaxScrollPosition();
     void trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList);
 
     // Returns false if the frame should not be displayed. This function should
     // only be called from prepareToDraw, as didDrawAllLayers must be called
     // if this helper function is called.
     bool calculateRenderPasses(FrameData&);
     void animateLayersRecursive(LayerImpl*, base::TimeTicks monotonicTime, base::Time wallClockTime, AnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers);
     void setBackgroundTickingEnabled(bool);
-    IntSize contentSize() const;
+    gfx::Size contentSize() const;
 
     void sendDidLoseContextRecursive(LayerImpl*);
     void clearRenderSurfaces();
     bool ensureRenderSurfaceLayerList();
     void clearCurrentlyScrollingLayer();
 
     void animateScrollbarsRecursive(LayerImpl*, base::TimeTicks monotonicTime);
 
     void dumpRenderSurfaces(std::string*, int indent, const LayerImpl*) const;
 
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<Renderer> m_renderer;
     scoped_ptr<LayerImpl> m_rootLayerImpl;
     LayerImpl* m_rootScrollLayerImpl;
     LayerImpl* m_currentlyScrollingLayerImpl;
     HeadsUpDisplayLayerImpl* m_hudLayerImpl;
     int m_scrollingLayerIdFromPreviousTree;
     bool m_scrollDeltaIsInViewportSpace;
     LayerTreeSettings m_settings;
-    IntSize m_layoutViewportSize;
-    IntSize m_deviceViewportSize;
+    gfx::Size m_layoutViewportSize;
+    gfx::Size m_deviceViewportSize;
     float m_deviceScaleFactor;
     bool m_visible;
     bool m_contentsTexturesPurged;
     ManagedMemoryPolicy m_managedMemoryPolicy;
 
     SkColor m_backgroundColor;
     bool m_hasTransparentBackground;
 
     // If this is true, it is necessary to traverse the layer tree ticking the animators.
     bool m_needsAnimateLayers;
@@ skipping 18 matching lines @@
 
     size_t m_numImplThreadScrolls;
     size_t m_numMainThreadScrolls;
 
     DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif