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

cc/resource_provider_unittest.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 "base/logging.h"
 #include "cc/graphics_context.h"
 #include "cc/scoped_ptr_deque.h"
 #include "cc/scoped_ptr_hash_map.h"
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/compositor_fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include <public/WebGraphicsContext3D.h>
 
 using namespace cc;
 using namespace WebKit;
 
 namespace {
 
-size_t textureSize(const IntSize& size, WGC3Denum format)
+size_t textureSize(const gfx::Size& size, WGC3Denum format)
 {
     unsigned int componentsPerPixel = 4;
     unsigned int bytesPerComponent = 1;
     return size.width() * size.height() * componentsPerPixel * bytesPerComponent;
 }
 
 struct Texture {
-    Texture(const IntSize& size, WGC3Denum format)
+    Texture(const gfx::Size& size, WGC3Denum format)
         : size(size)
         , format(format)
         , data(new uint8_t[textureSize(size, format)])
     {
     }
 
-    IntSize size;
+    gfx::Size size;
     WGC3Denum format;
     scoped_array<uint8_t> data;
 };
 
 // Shared data between multiple ResourceProviderContext. This contains mailbox
 // contents as well as information about sync points.
 class ContextSharedData {
 public:
     static scoped_ptr<ContextSharedData> create() { return make_scoped_ptr(new ContextSharedData()); }
 
@@ skipping 95 matching lines @@
         WGC3Denum format = GL_RGBA;
         switch (internalformat) {
         case GL_RGBA8_OES:
             break;
         case GL_BGRA8_EXT:
             format = GL_BGRA_EXT;
             break;
         default:
             NOTREACHED();
         }
-        allocateTexture(IntSize(width, height), format);
+        allocateTexture(gfx::Size(width, height), format);
     }
 
     virtual void texImage2D(WGC3Denum target, WGC3Dint level, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height, WGC3Dint border, WGC3Denum format, WGC3Denum type, const void* pixels)
     {
         ASSERT_TRUE(m_currentTexture);
         ASSERT_EQ(target, GL_TEXTURE_2D);
         ASSERT_FALSE(level);
         ASSERT_EQ(internalformat, format);
         ASSERT_FALSE(border);
         ASSERT_EQ(type, GL_UNSIGNED_BYTE);
-        allocateTexture(IntSize(width, height), format);
+        allocateTexture(gfx::Size(width, height), format);
         if (pixels)
             setPixels(0, 0, width, height, pixels);
     }
 
     virtual void texSubImage2D(WGC3Denum target, WGC3Dint level, WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dsizei width, WGC3Dsizei height, WGC3Denum format, WGC3Denum type, const void* pixels)
     {
         ASSERT_TRUE(m_currentTexture);
         ASSERT_EQ(target, GL_TEXTURE_2D);
         ASSERT_FALSE(level);
         ASSERT_TRUE(m_textures.get(m_currentTexture));
@@ skipping 19 matching lines @@
         m_pendingProduceTextures.append(pending.Pass());
     }
 
     virtual void consumeTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox)
     {
         ASSERT_TRUE(m_currentTexture);
         ASSERT_EQ(target, GL_TEXTURE_2D);
         m_textures.set(m_currentTexture, m_sharedData->consumeTexture(mailbox, m_lastWaitedSyncPoint));
     }
 
-    void getPixels(const IntSize& size, WGC3Denum format, uint8_t* pixels)
+    void getPixels(const gfx::Size& size, WGC3Denum format, uint8_t* pixels)
     {
         ASSERT_TRUE(m_currentTexture);
         Texture* texture = m_textures.get(m_currentTexture);
         ASSERT_TRUE(texture);
         ASSERT_EQ(texture->size, size);
         ASSERT_EQ(texture->format, format);
         memcpy(pixels, texture->data.get(), textureSize(size, format));
     }
 
     int textureCount()
     {
         return m_textures.size();
     }
 
 protected:
     ResourceProviderContext(const Attributes& attrs, ContextSharedData* sharedData)
         : CompositorFakeWebGraphicsContext3D(attrs)
         , m_sharedData(sharedData)
         , m_currentTexture(0)
         , m_lastWaitedSyncPoint(0)
     { }
 
 private:
-    void allocateTexture(const IntSize& size, WGC3Denum format)
+    void allocateTexture(const gfx::Size& size, WGC3Denum format)
     {
         ASSERT_TRUE(m_currentTexture);
         m_textures.set(m_currentTexture, make_scoped_ptr(new Texture(size, format)));
     }
 
     void setPixels(int xoffset, int yoffset, int width, int height, const void* pixels)
     {
         ASSERT_TRUE(m_currentTexture);
         Texture* texture = m_textures.get(m_currentTexture);
         ASSERT_TRUE(texture);
         ASSERT_TRUE(xoffset >= 0 && xoffset+width <= texture->size.width());
         ASSERT_TRUE(yoffset >= 0 && yoffset+height <= texture->size.height());
         ASSERT_TRUE(pixels);
-        size_t inPitch = textureSize(IntSize(width, 1), texture->format);
-        size_t outPitch = textureSize(IntSize(texture->size.width(), 1), texture->format);
-        uint8_t* dest = texture->data.get() + yoffset * outPitch + textureSize(IntSize(xoffset, 1), texture->format);
+        size_t inPitch = textureSize(gfx::Size(width, 1), texture->format);
+        size_t outPitch = textureSize(gfx::Size(texture->size.width(), 1), texture->format);
+        uint8_t* dest = texture->data.get() + yoffset * outPitch + textureSize(gfx::Size(xoffset, 1), texture->format);
         const uint8_t* src = static_cast<const uint8_t*>(pixels);
         for (int i = 0; i < height; ++i) {
             memcpy(dest, src, inPitch);
             dest += outPitch;
             src += inPitch;
         }
     }
 
     typedef ScopedPtrHashMap<WebGLId, Texture> TextureMap;
     struct PendingProduceTexture {
@@ skipping 13 matching lines @@
     ResourceProviderTest()
         : m_sharedData(ContextSharedData::create())
         , m_context(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>().PassAs<WebKit::WebGraphicsContext3D>()))
         , m_resourceProvider(ResourceProvider::create(m_context.get()))
     {
         m_resourceProvider->setDefaultResourceType(GetParam());
     }
 
     ResourceProviderContext* context() { return static_cast<ResourceProviderContext*>(m_context->context3D()); }
 
-    void getResourcePixels(ResourceProvider::ResourceId id, const IntSize& size, WGC3Denum format, uint8_t* pixels)
+    void getResourcePixels(ResourceProvider::ResourceId id, const gfx::Size& size, WGC3Denum format, uint8_t* pixels)
     {
         if (GetParam() == ResourceProvider::GLTexture) {
             ResourceProvider::ScopedReadLockGL lockGL(m_resourceProvider.get(), id);
             ASSERT_NE(0U, lockGL.textureId());
             context()->bindTexture(GL_TEXTURE_2D, lockGL.textureId());
             context()->getPixels(size, format, pixels);
         } else if (GetParam() == ResourceProvider::Bitmap) {
             ResourceProvider::ScopedReadLockSoftware lockSoftware(m_resourceProvider.get(), id);
             memcpy(pixels, lockSoftware.skBitmap()->getPixels(), lockSoftware.skBitmap()->getSize());
         }
     }
 
     void expectNumResources(int count)
     {
         EXPECT_EQ(count, static_cast<int>(m_resourceProvider->numResources()));
         if (GetParam() == ResourceProvider::GLTexture)
             EXPECT_EQ(count, context()->textureCount());
     }
 
 protected:
     DebugScopedSetImplThread implThread;
     scoped_ptr<ContextSharedData> m_sharedData;
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
 };
 
 TEST_P(ResourceProviderTest, Basic)
 {
-    IntSize size(1, 1);
+    gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     ResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
     expectNumResources(1);
 
     uint8_t data[4] = {1, 2, 3, 4};
-    IntRect rect(IntPoint(), size);
-    m_resourceProvider->upload(id, data, rect, rect, IntSize());
+    gfx::Rect rect(gfx::Point(), size);
+    m_resourceProvider->upload(id, data, rect, rect, gfx::Vector2d());
 
     uint8_t result[4] = {0};
     getResourcePixels(id, size, format, result);
     EXPECT_EQ(0, memcmp(data, result, pixelSize));
 
     m_resourceProvider->deleteResource(id);
     expectNumResources(0);
 }
 
 TEST_P(ResourceProviderTest, DeleteOwnedResources)
 {
-    IntSize size(1, 1);
+    gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int pool = 1;
 
     const int count = 3;
     for (int i = 0; i < count; ++i)
         m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
     expectNumResources(3);
 
     m_resourceProvider->deleteOwnedResources(pool+1);
     expectNumResources(3);
 
     m_resourceProvider->deleteOwnedResources(pool);
     expectNumResources(0);
 }
 
 TEST_P(ResourceProviderTest, Upload)
 {
-    IntSize size(2, 2);
+    gfx::Size size(2, 2);
     WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(16U, pixelSize);
 
     ResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
 
     uint8_t image[16] = {0};
-    IntRect imageRect(IntPoint(), size);
-    m_resourceProvider->upload(id, image, imageRect, imageRect, IntSize());
+    gfx::Rect imageRect(gfx::Point(), size);
+    m_resourceProvider->upload(id, image, imageRect, imageRect, gfx::Vector2d());
 
     for (uint8_t i = 0 ; i < pixelSize; ++i)
         image[i] = i;
 
     uint8_t result[16] = {0};
     {
-        IntRect sourceRect(0, 0, 1, 1);
-        IntSize destOffset(0, 0);
+        gfx::Rect sourceRect(0, 0, 1, 1);
+        gfx::Vector2d destOffset(0, 0);
         m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
 
         uint8_t expected[16] = {0, 1, 2, 3,   0, 0, 0, 0,
                                 0, 0, 0, 0,   0, 0, 0, 0};
         getResourcePixels(id, size, format, result);
         EXPECT_EQ(0, memcmp(expected, result, pixelSize));
     }
     {
-        IntRect sourceRect(0, 0, 1, 1);
-        IntSize destOffset(1, 1);
+        gfx::Rect sourceRect(0, 0, 1, 1);
+        gfx::Vector2d destOffset(1, 1);
         m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
 
         uint8_t expected[16] = {0, 1, 2, 3,   0, 0, 0, 0,
                                 0, 0, 0, 0,   0, 1, 2, 3};
         getResourcePixels(id, size, format, result);
         EXPECT_EQ(0, memcmp(expected, result, pixelSize));
     }
     {
-        IntRect sourceRect(1, 0, 1, 1);
-        IntSize destOffset(0, 1);
+        gfx::Rect sourceRect(1, 0, 1, 1);
+        gfx::Vector2d destOffset(0, 1);
         m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
 
         uint8_t expected[16] = {0, 1, 2, 3,   0, 0, 0, 0,
                                 4, 5, 6, 7,   0, 1, 2, 3};
         getResourcePixels(id, size, format, result);
         EXPECT_EQ(0, memcmp(expected, result, pixelSize));
     }
     {
-        IntRect offsetImageRect(IntPoint(100, 100), size);
-        IntRect sourceRect(100, 100, 1, 1);
-        IntSize destOffset(1, 0);
+        gfx::Rect offsetImageRect(gfx::Point(100, 100), size);
+        gfx::Rect sourceRect(100, 100, 1, 1);
+        gfx::Vector2d destOffset(1, 0);
         m_resourceProvider->upload(id, image, offsetImageRect, sourceRect, destOffset);
 
         uint8_t expected[16] = {0, 1, 2, 3,   0, 1, 2, 3,
                                 4, 5, 6, 7,   0, 1, 2, 3};
         getResourcePixels(id, size, format, result);
         EXPECT_EQ(0, memcmp(expected, result, pixelSize));
     }
 
 
     m_resourceProvider->deleteResource(id);
 }
 
 TEST_P(ResourceProviderTest, TransferResources)
 {
     // Resource transfer is only supported with GL textures for now.
     if (GetParam() != ResourceProvider::GLTexture)
         return;
 
     scoped_ptr<GraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
     scoped_ptr<ResourceProvider> childResourceProvider(ResourceProvider::create(childContext.get()));
 
-    IntSize size(1, 1);
+    gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     ResourceProvider::ResourceId id1 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
     uint8_t data1[4] = {1, 2, 3, 4};
-    IntRect rect(IntPoint(), size);
-    childResourceProvider->upload(id1, data1, rect, rect, IntSize());
+    gfx::Rect rect(gfx::Point(), size);
+    childResourceProvider->upload(id1, data1, rect, rect, gfx::Vector2d());
 
     ResourceProvider::ResourceId id2 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
     uint8_t data2[4] = {5, 5, 5, 5};
-    childResourceProvider->upload(id2, data2, rect, rect, IntSize());
+    childResourceProvider->upload(id2, data2, rect, rect, gfx::Vector2d());
 
     int childPool = 2;
     int childId = m_resourceProvider->createChild(childPool);
 
     {
         // Transfer some resources to the parent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id1);
         resourceIdsToTransfer.push_back(id2);
         ResourceProvider::TransferableResourceList list = childResourceProvider->prepareSendToParent(resourceIdsToTransfer);
@@ skipping 83 matching lines @@
 
 TEST_P(ResourceProviderTest, DeleteTransferredResources)
 {
     // Resource transfer is only supported with GL textures for now.
     if (GetParam() != ResourceProvider::GLTexture)
         return;
 
     scoped_ptr<GraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
     scoped_ptr<ResourceProvider> childResourceProvider(ResourceProvider::create(childContext.get()));
 
-    IntSize size(1, 1);
+    gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     ResourceProvider::ResourceId id = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
     uint8_t data[4] = {1, 2, 3, 4};
-    IntRect rect(IntPoint(), size);
-    childResourceProvider->upload(id, data, rect, rect, IntSize());
+    gfx::Rect rect(gfx::Point(), size);
+    childResourceProvider->upload(id, data, rect, rect, gfx::Vector2d());
 
     int childPool = 2;
     int childId = m_resourceProvider->createChild(childPool);
 
     {
         // Transfer some resource to the parent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id);
         ResourceProvider::TransferableResourceList list = childResourceProvider->prepareSendToParent(resourceIdsToTransfer);
         EXPECT_NE(0u, list.syncPoint);
@@ skipping 20 matching lines @@
     }
     EXPECT_EQ(0u, childResourceProvider->numResources());
 }
 
 INSTANTIATE_TEST_CASE_P(ResourceProviderTests,
                         ResourceProviderTest,
                         ::testing::Values(ResourceProvider::GLTexture,
                                           ResourceProvider::Bitmap));
 
 } // namespace