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

cc/resource_provider.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_provider.h"
 
 #include <limits.h>
 
-#include "IntRect.h"
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "cc/gl_renderer.h" // For the GLC() macro.
 #include "cc/proxy.h"
 #include "cc/texture_uploader.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/vector2d.h"
 
 #include <public/WebGraphicsContext3D.h>
 
 using WebKit::WebGraphicsContext3D;
 
 namespace {
    // Temporary variables for debugging crashes in issue 151428 in canary.
    // Do not use these!
    const int g_debugMaxResourcesTracked = 64;
    unsigned int g_debugZone = 0;
@@ skipping 41 matching lines @@
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size()
     , format(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
-ResourceProvider::Resource::Resource(unsigned textureId, int pool, const IntSize& size, GLenum format)
+ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format)
     : glId(textureId)
     , pixels(0)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size(size)
     , format(format)
     , type(GLTexture)
 {
 }
 
-ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const IntSize& size, GLenum format)
+ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format)
     : glId(0)
     , pixels(pixels)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size(size)
     , format(format)
@@ skipping 34 matching lines @@
 
 bool ResourceProvider::inUseByConsumer(ResourceId id)
 {
     DCHECK(Proxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     return !!resource->lockForReadCount || resource->exported;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const IntSize& size, GLenum format, TextureUsageHint hint)
+ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
 {
     switch (m_defaultResourceType) {
     case GLTexture:
         return createGLTexture(pool, size, format, hint);
     case Bitmap:
         DCHECK(format == GL_RGBA);
         return createBitmap(pool, size);
     }
 
     CRASH();
     return 0;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const IntSize& size, GLenum format, TextureUsageHint hint)
+ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
 {
     DCHECK(Proxy::isImplThread());
     unsigned textureId = 0;
     WebGraphicsContext3D* context3d = m_context->context3D();
     DCHECK(context3d);
     GLC(context3d, textureId = context3d->createTexture());
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     if (m_useTextureUsageHint && hint == TextureUsageFramebuffer)
         GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
     if (m_useTextureStorageExt && isTextureFormatSupportedForStorage(format)) {
         GLenum storageFormat = textureToStorageFormat(format);
         GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D, 1, storageFormat, size.width(), size.height()));
     } else
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
     ResourceId id = m_nextId++;
     Resource resource(textureId, pool, size, format);
     m_resources[id] = resource;
     return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const IntSize& size)
+ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const gfx::Size& size)
 {
     DCHECK(Proxy::isImplThread());
 
     uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
 
     ResourceId id = m_nextId++;
     Resource resource(pixels, pool, size, GL_RGBA);
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture(unsigned textureId)
 {
     DCHECK(Proxy::isImplThread());
     DCHECK(m_context->context3D());
     ResourceId id = m_nextId++;
-    Resource resource(textureId, 0, IntSize(), 0);
+    Resource resource(textureId, 0, gfx::Size(), 0);
     resource.external = true;
     m_resources[id] = resource;
     return id;
 }
 
 void ResourceProvider::deleteResource(ResourceId id)
 {
     DCHECK(Proxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
@@ skipping 37 matching lines @@
 }
 
 ResourceProvider::ResourceType ResourceProvider::resourceType(ResourceId id)
 {
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     return resource->type;
 }
 
-void ResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset)
+void ResourceProvider::upload(ResourceId id, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset)
 {
     DCHECK(Proxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
 
@@ skipping 14 matching lines @@
         SkBitmap srcFull;
         srcFull.setConfig(SkBitmap::kARGB_8888_Config, imageRect.width(), imageRect.height());
         srcFull.setPixels(const_cast<uint8_t*>(image));
         SkBitmap srcSubset;
         SkIRect skSourceRect = SkIRect::MakeXYWH(sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height());
         skSourceRect.offset(-imageRect.x(), -imageRect.y());
         srcFull.extractSubset(&srcSubset, skSourceRect);
 
         ScopedWriteLockSoftware lock(this, id);
         SkCanvas* dest = lock.skCanvas();
-        dest->writePixels(srcSubset, destOffset.width(), destOffset.height());
+        dest->writePixels(srcSubset, destOffset.x(), destOffset.y());
     }
 }
 
 size_t ResourceProvider::numBlockingUploads()
 {
     if (!m_textureUploader)
         return 0;
 
     return m_textureUploader->numBlockingUploads();
 }
@@ skipping 394 matching lines @@
     g_debugZone = zone;
 }
 
 void ResourceProvider::debugNotifyLeaveZone()
 {
     g_debugZone = 0;
 }
 
 
 }