Use gfx:: Geometry types for the resource provider and layer updater classes.

cc/image_layer.cc

 // 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.
 
 #include "config.h"
 
 #include "cc/image_layer.h"
 
 #include "base/compiler_specific.h"
 #include "cc/layer_updater.h"
 #include "cc/layer_tree_host.h"
 #include "cc/resource_update_queue.h"
 
 namespace cc {
 
 class ImageLayerUpdater : public LayerUpdater {
 public:
     class Resource : public LayerUpdater::Resource {
     public:
         Resource(ImageLayerUpdater* updater, scoped_ptr<PrioritizedTexture> texture)
             : LayerUpdater::Resource(texture.Pass())
             , m_updater(updater)
         {
         }
 
-        virtual void update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
+        virtual void update(ResourceUpdateQueue& queue, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
         {
             updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
         }
 
     private:
         ImageLayerUpdater* updater() { return m_updater; }
 
         ImageLayerUpdater* m_updater;
     };
 
     static scoped_refptr<ImageLayerUpdater> create()
     {
         return make_scoped_refptr(new ImageLayerUpdater());
     }
 
     virtual scoped_ptr<LayerUpdater::Resource> createResource(
         PrioritizedTextureManager* manager) OVERRIDE
     {
         return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
     }
 
-    void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
+    void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate)
     {
         // Source rect should never go outside the image pixels, even if this
         // is requested because the texture extends outside the image.
-        IntRect clippedSourceRect = sourceRect;
-        IntRect imageRect = IntRect(0, 0, m_bitmap.width(), m_bitmap.height());
-        clippedSourceRect.intersect(imageRect);
+        gfx::Rect clippedSourceRect = sourceRect;
+        gfx::Rect imageRect = gfx::Rect(0, 0, m_bitmap.width(), m_bitmap.height());
+        clippedSourceRect.Intersect(imageRect);
 
-        IntSize clippedDestOffset = destOffset + IntSize(clippedSourceRect.location() - sourceRect.location());
+        gfx::Vector2d clippedDestOffset = destOffset + (clippedSourceRect.origin() - sourceRect.origin());
 
         ResourceUpdate upload = ResourceUpdate::Create(texture,
                                                        &m_bitmap,
                                                        imageRect,
                                                        clippedSourceRect,
                                                        clippedDestOffset);
         if (partialUpdate)
             queue.appendPartialUpload(upload);
         else
             queue.appendFullUpload(upload);
@@ skipping 83 matching lines @@
     return !m_bitmap.isNull() && TiledLayer::drawsContent();
 }
 
 bool ImageLayer::needsContentsScale() const
 {
     // Contents scale is not need for image layer because this can be done in compositor more efficiently.
     return false;
 }
 
 }