Remove GraphicsContext3D:: stubs from cc

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 "CCResourceProvider.h"
 
 #include "CCGraphicsContext.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
-#include "Extensions3DChromium.h"
 #include "base/logging.h"
 #include "cc/scoped_ptr_deque.h"
 #include "cc/scoped_ptr_hash_map.h"
 #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)
 {
     unsigned int componentsPerPixel = 4;
@@ skipping 81 matching lines @@
         return syncPoint;
     }
 
     virtual void waitSyncPoint(unsigned syncPoint)
     {
         m_lastWaitedSyncPoint = std::max(syncPoint, m_lastWaitedSyncPoint);
     }
 
     virtual void bindTexture(WGC3Denum target, WebGLId texture)
     {
-      ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+      ASSERT_EQ(target, GL_TEXTURE_2D);
       ASSERT_TRUE(!texture || m_textures.find(texture) != m_textures.end());
       m_currentTexture = texture;
     }
 
     virtual WebGLId createTexture()
     {
         WebGLId id = CompositorFakeWebGraphicsContext3D::createTexture();
         m_textures.add(id, scoped_ptr<Texture>());
         return id;
     }
 
     virtual void deleteTexture(WebGLId id)
     {
         TextureMap::iterator it = m_textures.find(id);
         ASSERT_FALSE(it == m_textures.end());
         m_textures.erase(it);
         if (m_currentTexture == id)
             m_currentTexture = 0;
     }
 
     virtual void texStorage2DEXT(WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,
                                  WGC3Dint width, WGC3Dint height)
     {
         ASSERT_TRUE(m_currentTexture);
-        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_EQ(target, GL_TEXTURE_2D);
         ASSERT_EQ(levels, 1);
-        WGC3Denum format = GraphicsContext3D::RGBA;
+        WGC3Denum format = GL_RGBA;
         switch (internalformat) {
-        case Extensions3D::RGBA8_OES:
+        case GL_RGBA8_OES:
             break;
-        case Extensions3DChromium::BGRA8_EXT:
-            format = Extensions3D::BGRA_EXT;
+        case GL_BGRA8_EXT:
+            format = GL_BGRA_EXT;
             break;
         default:
             NOTREACHED();
         }
         allocateTexture(IntSize(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, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_EQ(target, GL_TEXTURE_2D);
         ASSERT_FALSE(level);
         ASSERT_EQ(internalformat, format);
         ASSERT_FALSE(border);
-        ASSERT_EQ(type, GraphicsContext3D::UNSIGNED_BYTE);
+        ASSERT_EQ(type, GL_UNSIGNED_BYTE);
         allocateTexture(IntSize(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, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_EQ(target, GL_TEXTURE_2D);
         ASSERT_FALSE(level);
         ASSERT_TRUE(m_textures.get(m_currentTexture));
         ASSERT_EQ(m_textures.get(m_currentTexture)->format, format);
-        ASSERT_EQ(type, GraphicsContext3D::UNSIGNED_BYTE);
+        ASSERT_EQ(type, GL_UNSIGNED_BYTE);
         ASSERT_TRUE(pixels);
         setPixels(xoffset, yoffset, width, height, pixels);
     }
 
     virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) { return m_sharedData->genMailbox(mailbox); }
     virtual void produceTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox)
     {
         ASSERT_TRUE(m_currentTexture);
-        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_EQ(target, GL_TEXTURE_2D);
 
         // Delay moving the texture into the mailbox until the next
         // insertSyncPoint, so that it is not visible to other contexts that
         // haven't waited on that sync point.
         scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
         memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
         pending->texture = m_textures.take(m_currentTexture);
         m_textures.set(m_currentTexture, scoped_ptr<Texture>());
         m_pendingProduceTextures.append(pending.Pass());
     }
 
     virtual void consumeTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox)
     {
         ASSERT_TRUE(m_currentTexture);
-        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        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)
     {
         ASSERT_TRUE(m_currentTexture);
         Texture* texture = m_textures.get(m_currentTexture);
         ASSERT_TRUE(texture);
         ASSERT_EQ(texture->size, size);
         ASSERT_EQ(texture->format, format);
@@ skipping 62 matching lines @@
         m_resourceProvider->setDefaultResourceType(GetParam());
     }
 
     ResourceProviderContext* context() { return static_cast<ResourceProviderContext*>(m_context->context3D()); }
 
     void getResourcePixels(CCResourceProvider::ResourceId id, const IntSize& size, WGC3Denum format, uint8_t* pixels)
     {
         if (GetParam() == CCResourceProvider::GLTexture) {
             CCResourceProvider::ScopedReadLockGL lockGL(m_resourceProvider.get(), id);
             ASSERT_NE(0U, lockGL.textureId());
-            context()->bindTexture(GraphicsContext3D::TEXTURE_2D, lockGL.textureId());
+            context()->bindTexture(GL_TEXTURE_2D, lockGL.textureId());
             context()->getPixels(size, format, pixels);
         } else if (GetParam() == CCResourceProvider::Bitmap) {
             CCResourceProvider::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() == CCResourceProvider::GLTexture)
             EXPECT_EQ(count, context()->textureCount());
     }
 
 protected:
     DebugScopedSetImplThread implThread;
     scoped_ptr<ContextSharedData> m_sharedData;
     scoped_ptr<CCGraphicsContext> m_context;
     scoped_ptr<CCResourceProvider> m_resourceProvider;
 };
 
 TEST_P(CCResourceProviderTest, Basic)
 {
     IntSize size(1, 1);
-    WGC3Denum format = GraphicsContext3D::RGBA;
+    WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     CCResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
     expectNumResources(1);
 
     uint8_t data[4] = {1, 2, 3, 4};
     IntRect rect(IntPoint(), size);
     m_resourceProvider->upload(id, data, rect, rect, IntSize());
 
     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(CCResourceProviderTest, DeleteOwnedResources)
 {
     IntSize size(1, 1);
-    WGC3Denum format = GraphicsContext3D::RGBA;
+    WGC3Denum format = GL_RGBA;
     int pool = 1;
 
     const int count = 3;
     for (int i = 0; i < count; ++i)
         m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
     expectNumResources(3);
 
     m_resourceProvider->deleteOwnedResources(pool+1);
     expectNumResources(3);
 
     m_resourceProvider->deleteOwnedResources(pool);
     expectNumResources(0);
 }
 
 TEST_P(CCResourceProviderTest, Upload)
 {
     IntSize size(2, 2);
-    WGC3Denum format = GraphicsContext3D::RGBA;
+    WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(16U, pixelSize);
 
     CCResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
 
     uint8_t image[16] = {0};
     IntRect imageRect(IntPoint(), size);
     m_resourceProvider->upload(id, image, imageRect, imageRect, IntSize());
 
@@ skipping 50 matching lines @@
 TEST_P(CCResourceProviderTest, TransferResources)
 {
     // Resource transfer is only supported with GL textures for now.
     if (GetParam() != CCResourceProvider::GLTexture)
         return;
 
     scoped_ptr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
     scoped_ptr<CCResourceProvider> childResourceProvider(CCResourceProvider::create(childContext.get()));
 
     IntSize size(1, 1);
-    WGC3Denum format = GraphicsContext3D::RGBA;
+    WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     CCResourceProvider::ResourceId id1 = childResourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
     uint8_t data1[4] = {1, 2, 3, 4};
     IntRect rect(IntPoint(), size);
     childResourceProvider->upload(id1, data1, rect, rect, IntSize());
 
     CCResourceProvider::ResourceId id2 = childResourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
@@ skipping 55 matching lines @@
     }
     EXPECT_EQ(0u, m_resourceProvider->mailboxCount());
     EXPECT_EQ(2u, childResourceProvider->mailboxCount());
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id1));
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id2));
 
     ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childContext->context3D());
     {
         CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id1);
         ASSERT_NE(0U, lock.textureId());
-        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
+        childContext3D->bindTexture(GL_TEXTURE_2D, lock.textureId());
         childContext3D->getPixels(size, format, result);
         EXPECT_EQ(0, memcmp(data1, result, pixelSize));
     }
     {
         CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id2);
         ASSERT_NE(0U, lock.textureId());
-        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
+        childContext3D->bindTexture(GL_TEXTURE_2D, lock.textureId());
         childContext3D->getPixels(size, format, result);
         EXPECT_EQ(0, memcmp(data2, result, pixelSize));
     }
 
     {
         // Transfer resources to the parent again.
         CCResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id1);
         resourceIdsToTransfer.push_back(id2);
         CCResourceProvider::TransferableResourceList list = childResourceProvider->prepareSendToParent(resourceIdsToTransfer);
@@ skipping 13 matching lines @@
 TEST_P(CCResourceProviderTest, DeleteTransferredResources)
 {
     // Resource transfer is only supported with GL textures for now.
     if (GetParam() != CCResourceProvider::GLTexture)
         return;
 
     scoped_ptr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
     scoped_ptr<CCResourceProvider> childResourceProvider(CCResourceProvider::create(childContext.get()));
 
     IntSize size(1, 1);
-    WGC3Denum format = GraphicsContext3D::RGBA;
+    WGC3Denum format = GL_RGBA;
     int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
     CCResourceProvider::ResourceId id = childResourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
     uint8_t data[4] = {1, 2, 3, 4};
     IntRect rect(IntPoint(), size);
     childResourceProvider->upload(id, data, rect, rect, IntSize());
 
     int childPool = 2;
@@ skipping 28 matching lines @@
     }
     EXPECT_EQ(0u, childResourceProvider->numResources());
 }
 
 INSTANTIATE_TEST_CASE_P(CCResourceProviderTests,
                         CCResourceProviderTest,
                         ::testing::Values(CCResourceProvider::GLTexture,
                                           CCResourceProvider::Bitmap));
 
 } // namespace