Remove WGC3D typedefs and move WebGraphicsInfo to Platform.

third_party/WebKit/Source/platform/graphics/gpu/DrawingBufferTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 35 matching lines @@
 #include "wtf/RefPtr.h"
 
 using testing::Test;
 using testing::_;
 
 namespace blink {
 
 namespace {
 
 // The target to use when binding a texture to a Chromium image.
-WGC3Denum imageTextureTarget()
+GLenum imageTextureTarget()
 {
 #if OS(MACOSX)
     return GC3D_TEXTURE_RECTANGLE_ARB;
 #else
     return GL_TEXTURE_2D;
 #endif
 }
 
 // The target to use when preparing a mailbox texture.
-WGC3Denum drawingBufferTextureTarget(bool allowImageChromium)
+GLenum drawingBufferTextureTarget(bool allowImageChromium)
 {
     if (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && allowImageChromium)
         return imageTextureTarget();
     return GL_TEXTURE_2D;
 }
 
 } // namespace
 
 class GLES2InterfaceForTests : public gpu::gles2::GLES2InterfaceStub {
 public:
     void BindTexture(GLenum target, GLuint texture) override
     {
         if (target != m_boundTextureTarget && texture == 0)
             return;
 
         // For simplicity, only allow one target to ever be bound.
         ASSERT_TRUE(m_boundTextureTarget == 0 || target == m_boundTextureTarget);
         m_boundTextureTarget = target;
         m_boundTexture = texture;
     }
 
     GLuint64 InsertFenceSyncCHROMIUM() override
     {
-        static WGC3Duint64 syncPointGenerator = 0;
+        static GLuint64 syncPointGenerator = 0;
         return ++syncPointGenerator;
     }
 
     void WaitSyncTokenCHROMIUM(const GLbyte* syncToken) override
     {
         memcpy(&m_mostRecentlyWaitedSyncToken, syncToken, sizeof(m_mostRecentlyWaitedSyncToken));
     }
 
     GLenum CheckFramebufferStatus(GLenum target) override
     {
@@ skipping 20 matching lines @@
         m_mostRecentlyProducedSize = m_textureSizes.get(texture);
     }
 
     void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
     {
         if (target == GL_TEXTURE_2D && !level) {
             m_textureSizes.set(m_boundTexture, IntSize(width, height));
         }
     }
 
-    WGC3Duint CreateGpuMemoryBufferImageCHROMIUM(GLsizei width, GLsizei height, GLenum internalformat, GLenum usage) override
+    GLuint CreateGpuMemoryBufferImageCHROMIUM(GLsizei width, GLsizei height, GLenum internalformat, GLenum usage) override
     {
         if (!m_allowImageChromium)
             return false;
         m_imageSizes.set(m_currentImageId, IntSize(width, height));
         return m_currentImageId++;
     }
 
     MOCK_METHOD1(DestroyImageMock, void(GLuint imageId));
     void DestroyImageCHROMIUM(GLuint imageId)
     {
@@ skipping 42 matching lines @@
     GLuint currentImageId() const { return m_currentImageId; }
     IntSize mostRecentlyProducedSize() const { return m_mostRecentlyProducedSize; }
     bool allowImageChromium() const { return m_allowImageChromium; }
 
     void setAllowImageChromium(bool allow) { m_allowImageChromium = allow; }
 
 private:
     GLuint m_boundTexture = 0;
     GLuint m_boundTextureTarget = 0;
     GLuint m_mostRecentlyWaitedSyncToken = 0;
-    WGC3Dbyte m_currentMailboxByte = 0;
+    GLbyte m_currentMailboxByte = 0;
     IntSize m_mostRecentlyProducedSize;
     bool m_allowImageChromium = true;
     GLuint m_currentImageId = 1;
     HashMap<GLuint, IntSize> m_textureSizes;
     HashMap<GLuint, IntSize> m_imageSizes;
     HashMap<GLuint, GLuint> m_imageToTextureMap;
 };
 
 class WebGraphicsContext3DForTests : public MockWebGraphicsContext3D {
 public:
     WebGraphicsContext3DForTests(GLES2InterfaceForTests* contextGL)
         : m_contextGL(contextGL)
     {
     }
 
-    WGC3Duint mostRecentlyWaitedSyncToken()
+    GLuint mostRecentlyWaitedSyncToken()
     {
         return m_contextGL->mostRecentlyWaitedSyncToken();
     }
 
     IntSize mostRecentlyProducedSize()
     {
         return m_contextGL->mostRecentlyProducedSize();
     }
 
 
-    WGC3Duint nextImageIdToBeCreated()
+    GLuint nextImageIdToBeCreated()
     {
         return m_contextGL->currentImageId();
     }
 
 private:
     GLES2InterfaceForTests* m_contextGL;
 };
 
 static const int initialWidth = 100;
 static const int initialHeight = 100;
@@ skipping 245 matching lines @@
 {
     WebExternalTextureMailbox mailbox;
 
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
     EXPECT_EQ(0u, webContext()->mostRecentlyWaitedSyncToken());
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     // prepareMailbox() does not wait for any sync point.
     EXPECT_EQ(0u, webContext()->mostRecentlyWaitedSyncToken());
 
-    WGC3Duint64 waitSyncToken = 0;
-    m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), reinterpret_cast<WGC3Dbyte*>(&waitSyncToken));
+    GLuint64 waitSyncToken = 0;
+    m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), reinterpret_cast<GLbyte*>(&waitSyncToken));
     memcpy(mailbox.syncToken, &waitSyncToken, sizeof(waitSyncToken));
     mailbox.validSyncToken = true;
     m_drawingBuffer->mailboxReleased(mailbox, false);
     // m_drawingBuffer will wait for the sync point when recycling.
     EXPECT_EQ(0u, webContext()->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     // m_drawingBuffer waits for the sync point when recycling in prepareMailbox().
     EXPECT_EQ(waitSyncToken, webContext()->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->beginDestruction();
-    m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), reinterpret_cast<WGC3Dbyte*>(&waitSyncToken));
+    m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), reinterpret_cast<GLbyte*>(&waitSyncToken));
     memcpy(mailbox.syncToken, &waitSyncToken, sizeof(waitSyncToken));
     mailbox.validSyncToken = true;
     m_drawingBuffer->mailboxReleased(mailbox, false);
     // m_drawingBuffer waits for the sync point because the destruction is in progress.
     EXPECT_EQ(waitSyncToken, webContext()->mostRecentlyWaitedSyncToken());
 }
 
 class DrawingBufferImageChromiumTest : public DrawingBufferTest {
 protected:
     void SetUp() override
@@ skipping 19 matching lines @@
     GLuint m_imageId0;
 };
 
 TEST_F(DrawingBufferImageChromiumTest, verifyResizingReallocatesImages)
 {
     WebExternalTextureMailbox mailbox;
 
     IntSize initialSize(initialWidth, initialHeight);
     IntSize alternateSize(initialWidth, alternateHeight);
 
-    WGC3Duint m_imageId1 = webContext()->nextImageIdToBeCreated();
+    GLuint m_imageId1 = webContext()->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId1)).Times(1);
     // Produce one mailbox at size 100x100.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(initialSize, webContext()->mostRecentlyProducedSize());
     EXPECT_TRUE(mailbox.allowOverlay);
     testing::Mock::VerifyAndClearExpectations(webContext());
 
-    WGC3Duint m_imageId2 = webContext()->nextImageIdToBeCreated();
+    GLuint m_imageId2 = webContext()->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId2)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId0)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId0)).Times(1);
     // Resize to 100x50.
     m_drawingBuffer->reset(IntSize(initialWidth, alternateHeight));
     m_drawingBuffer->mailboxReleased(mailbox, false);
     testing::Mock::VerifyAndClearExpectations(webContext());
 
-    WGC3Duint m_imageId3 = webContext()->nextImageIdToBeCreated();
+    GLuint m_imageId3 = webContext()->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId3)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId1)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId1)).Times(1);
     // Produce a mailbox at this size.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(alternateSize, webContext()->mostRecentlyProducedSize());
     EXPECT_TRUE(mailbox.allowOverlay);
     testing::Mock::VerifyAndClearExpectations(webContext());
 
-    WGC3Duint m_imageId4 = webContext()->nextImageIdToBeCreated();
+    GLuint m_imageId4 = webContext()->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId4)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId2)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId2)).Times(1);
     // Reset to initial size.
     m_drawingBuffer->reset(IntSize(initialWidth, initialHeight));
     m_drawingBuffer->mailboxReleased(mailbox, false);
     testing::Mock::VerifyAndClearExpectations(webContext());
 
-    WGC3Duint m_imageId5 = webContext()->nextImageIdToBeCreated();
+    GLuint m_imageId5 = webContext()->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId3)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId3)).Times(1);
     // Prepare another mailbox and verify that it's the correct size.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(initialSize, webContext()->mostRecentlyProducedSize());
     EXPECT_TRUE(mailbox.allowOverlay);
     testing::Mock::VerifyAndClearExpectations(webContext());
 
@@ skipping 80 matching lines @@
 
 class DepthStencilTrackingContext : public MockWebGraphicsContext3D {
 public:
     DepthStencilTrackingContext(DepthStencilTrackingGLES2Interface* gl)
         : m_contextGL(gl)
     {
     }
     ~DepthStencilTrackingContext() override {}
 
     size_t numAllocatedRenderBuffer() const { return m_contextGL->numAllocatedRenderBuffer(); }
-    WebGLId stencilAttachment() const { return m_contextGL->stencilAttachment(); }
-    WebGLId depthAttachment() const { return m_contextGL->depthAttachment(); }
-    WebGLId depthStencilAttachment() const { return m_contextGL->depthStencilAttachment(); }
+    GLuint stencilAttachment() const { return m_contextGL->stencilAttachment(); }
+    GLuint depthAttachment() const { return m_contextGL->depthAttachment(); }
+    GLuint depthStencilAttachment() const { return m_contextGL->depthStencilAttachment(); }
 
 private:
     DepthStencilTrackingGLES2Interface* m_contextGL;
 };
 
 struct DepthStencilTestCase {
     DepthStencilTestCase(bool requestStencil, bool requestDepth, int expectedRenderBuffers, const char* const testCaseName)
         : requestStencil(requestStencil)
         , requestDepth(requestDepth)
         , expectedRenderBuffers(expectedRenderBuffers)
@@ skipping 71 matching lines @@
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
 
     m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), mailbox.syncToken);
     mailbox.validSyncToken = true;
     m_drawingBuffer->setIsHidden(true);
     m_drawingBuffer->mailboxReleased(mailbox);
     // m_drawingBuffer deletes mailbox immediately when hidden.
 
-    WGC3Duint waitSyncToken = 0;
+    GLuint waitSyncToken = 0;
     memcpy(&waitSyncToken, mailbox.syncToken, sizeof(waitSyncToken));
     EXPECT_EQ(waitSyncToken, webContext()->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->beginDestruction();
 }
 
 class DrawingBufferImageChromiumFallbackTest : public DrawingBufferTest {
 protected:
     void SetUp() override
     {
@@ skipping 22 matching lines @@
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(initialSize, webContext()->mostRecentlyProducedSize());
     EXPECT_FALSE(mailbox.allowOverlay);
 
     m_drawingBuffer->mailboxReleased(mailbox, false);
     m_drawingBuffer->beginDestruction();
 }
 
 } // namespace blink