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

cc/resource_update_controller.cc

 // Copyright 2012 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/resource_update_controller.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/prioritized_texture.h"
@@ skipping 21 matching lines @@
 // Measured in seconds.
 const double uploaderBusyTickRate = 0.001;
 
 // Flush interval when performing texture uploads.
 const int textureUploadFlushPeriod = 4;
 
 // Number of blocking update intervals to allow.
 const size_t maxBlockingUpdateIntervals = 4;
 
 scoped_ptr<SkCanvas> createAcceleratedCanvas(
-    GrContext* grContext, cc::IntSize canvasSize, unsigned textureId)
+    GrContext* grContext, gfx::Size canvasSize, unsigned textureId)
 {
     GrPlatformTextureDesc textureDesc;
     textureDesc.fFlags = kRenderTarget_GrPlatformTextureFlag;
     textureDesc.fWidth = canvasSize.width();
     textureDesc.fHeight = canvasSize.height();
     textureDesc.fConfig = kSkia8888_GrPixelConfig;
     textureDesc.fTextureHandle = textureId;
     SkAutoTUnref<GrTexture> target(
         grContext->createPlatformTexture(textureDesc));
     SkAutoTUnref<SkDevice> device(new SkGpuDevice(grContext, target.get()));
@@ skipping 61 matching lines @@
 
 void ResourceUpdateController::discardUploadsToEvictedResources()
 {
     m_queue->clearUploadsToEvictedResources();
 }
 
 void ResourceUpdateController::updateTexture(ResourceUpdate update)
 {
     if (update.picture) {
         PrioritizedTexture* texture = update.texture;
-        IntRect pictureRect = update.content_rect;
-        IntRect sourceRect = update.source_rect;
-        IntSize destOffset = update.dest_offset;
+        gfx::Rect pictureRect = update.content_rect;
+        gfx::Rect sourceRect = update.source_rect;
+        gfx::Vector2d destOffset = update.dest_offset;
 
         texture->acquireBackingTexture(m_resourceProvider);
         DCHECK(texture->haveBackingTexture());
 
         DCHECK(m_resourceProvider->resourceType(texture->resourceId()) ==
                ResourceProvider::GLTexture);
 
         WebGraphicsContext3D* paintContext = Proxy::hasImplThread() ?
             WebSharedGraphicsContext3D::compositorThreadContext() :
             WebSharedGraphicsContext3D::mainThreadContext();
@@ skipping 15 matching lines @@
         // Create an accelerated canvas to draw on.
         scoped_ptr<SkCanvas> canvas = createAcceleratedCanvas(
             paintGrContext, texture->size(), lock.textureId());
 
         // The compositor expects the textures to be upside-down so it can flip
         // the final composited image. Ganesh renders the image upright so we
         // need to do a y-flip.
         canvas->translate(0.0, texture->size().height());
         canvas->scale(1.0, -1.0);
         // Clip to the destination on the texture that must be updated.
-        canvas->clipRect(SkRect::MakeXYWH(destOffset.width(),
-                                          destOffset.height(),
+        canvas->clipRect(SkRect::MakeXYWH(destOffset.x(),
+                                          destOffset.y(),
                                           sourceRect.width(),
                                           sourceRect.height()));
         // Translate the origin of pictureRect to destOffset.
         // Note that destOffset is defined relative to sourceRect.
         canvas->translate(
-            pictureRect.x() - sourceRect.x() + destOffset.width(),
-            pictureRect.y() - sourceRect.y() + destOffset.height());
+            pictureRect.x() - sourceRect.x() + destOffset.x(),
+            pictureRect.y() - sourceRect.y() + destOffset.y());
         canvas->drawPicture(*update.picture);
 
         // Flush ganesh context so that all the rendered stuff appears on the
         // texture.
         paintGrContext->flush();
 
         // Flush the GL context so rendering results from this context are
         // visible in the compositor's context.
         paintContext->flush();
     }
@@ skipping 114 matching lines @@
     while (m_queue->fullUploadSize() && uploadCount < uploads) {
         if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             m_resourceProvider->shallowFlushIfSupported();
         updateTexture(m_queue->takeFirstFullUpload());
         uploadCount++;
     }
     m_resourceProvider->shallowFlushIfSupported();
 }
 
 }  // namespace cc