Move simple methods [F-S] from WebGraphicsContext3D to GLES2Interface.

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 80 matching lines @@
     void WaitSyncTokenCHROMIUM(const GLbyte* syncToken) override
     {
         memcpy(&m_mostRecentlyWaitedSyncToken, syncToken, sizeof(m_mostRecentlyWaitedSyncToken));
     }
 
     GLenum CheckFramebufferStatus(GLenum target) override
     {
         return GL_FRAMEBUFFER_COMPLETE;
     }
 
+    void GetIntegerv(GLenum pname, GLint* value) override
+    {
+        if (pname == GL_MAX_TEXTURE_SIZE)
+            *value = 1024;
+    }
+
+    void GenMailboxCHROMIUM(GLbyte* mailbox) override
+    {
+        ++m_currentMailboxByte;
+        WebExternalTextureMailbox temp;
+        memset(mailbox, m_currentMailboxByte, sizeof(temp.name));
+    }
+
+    void ProduceTextureDirectCHROMIUM(GLuint texture, GLenum target, const GLbyte* mailbox) override
+    {
+        ASSERT_EQ(target, drawingBufferTextureTarget(m_allowImageChromium));
+        ASSERT_TRUE(m_textureSizes.contains(texture));
+        m_mostRecentlyProducedSize = m_textureSizes.get(texture);
+    }
+
     uint32_t boundTexture() const { return m_boundTexture; }
     uint32_t boundTextureTarget() const { return m_boundTextureTarget; }
     uint32_t mostRecentlyWaitedSyncToken() const { return m_mostRecentlyWaitedSyncToken; }
+    IntSize mostRecentlyProducedSize() const { return m_mostRecentlyProducedSize; }
+    bool allowImageChromium() const { return m_allowImageChromium; }
+    HashMap<WebGLId, IntSize>& textureSizes() { return m_textureSizes; }
+    const HashMap<WebGLId, IntSize>& textureSizes() const { return m_textureSizes; }
+
+    void setAllowImageChromium(bool allow) { m_allowImageChromium = allow; }
 
 private:
     uint32_t m_boundTexture = 0;
     uint32_t m_boundTextureTarget = 0;
     uint32_t m_mostRecentlyWaitedSyncToken = 0;
+    HashMap<WebGLId, IntSize> m_textureSizes;
+    WGC3Dbyte m_currentMailboxByte = 0;
+    IntSize m_mostRecentlyProducedSize;
+    bool m_allowImageChromium = true;
 };
 
 class WebGraphicsContext3DForTests : public MockWebGraphicsContext3D {
 public:
     WebGraphicsContext3DForTests(PassOwnPtr<GLES2InterfaceForTests> contextGL)
-        : m_currentMailboxByte(0)
-        , m_currentImageId(1)
-        , m_allowImageChromium(true)
+        : m_currentImageId(1)
         , m_contextGL(std::move(contextGL))
     {
     }
 
     void texImage2D(WGC3Denum target, WGC3Dint level, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height, WGC3Dint border, WGC3Denum format, WGC3Denum type, const void* pixels) override
     {
         if (target == GL_TEXTURE_2D && !level) {
-            m_textureSizes.set(m_contextGL->boundTexture(), IntSize(width, height));
+            m_contextGL->textureSizes().set(m_contextGL->boundTexture(), IntSize(width, height));
         }
     }
 
-    void genMailboxCHROMIUM(WGC3Dbyte* mailbox) override
-    {
-        ++m_currentMailboxByte;
-        WebExternalTextureMailbox temp;
-        memset(mailbox, m_currentMailboxByte, sizeof(temp.name));
-    }
-
-    void produceTextureDirectCHROMIUM(WebGLId texture, WGC3Denum target, const WGC3Dbyte* mailbox) override
-    {
-        ASSERT_EQ(target, drawingBufferTextureTarget(m_allowImageChromium));
-        ASSERT_TRUE(m_textureSizes.contains(texture));
-        m_mostRecentlyProducedSize = m_textureSizes.get(texture);
-    }
-
-    IntSize mostRecentlyProducedSize()
-    {
-        return m_mostRecentlyProducedSize;
-    }
-
     bool genSyncTokenCHROMIUM(WGC3Duint64 fenceSync, WGC3Dbyte* syncToken) override
     {
         memcpy(syncToken, &fenceSync, sizeof(fenceSync));
         return true;
     }
 
     WGC3Duint createGpuMemoryBufferImageCHROMIUM(WGC3Dsizei width, WGC3Dsizei height, WGC3Denum internalformat, WGC3Denum usage) override
     {
-        if (!m_allowImageChromium)
+        if (!m_contextGL->allowImageChromium())
             return false;
         m_imageSizes.set(m_currentImageId, IntSize(width, height));
         return m_currentImageId++;
     }
 
     MOCK_METHOD1(destroyImageMock, void(WGC3Duint imageId));
     void destroyImageCHROMIUM(WGC3Duint imageId)
     {
         m_imageSizes.remove(imageId);
         // No textures should be bound to this.
         ASSERT(m_imageToTextureMap.find(imageId) == m_imageToTextureMap.end());
         m_imageSizes.remove(imageId);
         destroyImageMock(imageId);
     }
 
     MOCK_METHOD1(bindTexImage2DMock, void(WGC3Dint imageId));
     void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId)
     {
         if (target == imageTextureTarget()) {
-            m_textureSizes.set(m_contextGL->boundTexture(), m_imageSizes.find(imageId)->value);
+            m_contextGL->textureSizes().set(m_contextGL->boundTexture(), m_imageSizes.find(imageId)->value);
             m_imageToTextureMap.set(imageId, m_contextGL->boundTexture());
             bindTexImage2DMock(imageId);
         }
     }
 
     MOCK_METHOD1(releaseTexImage2DMock, void(WGC3Dint imageId));
     void releaseTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId)
     {
         if (target == imageTextureTarget()) {
             m_imageSizes.set(m_currentImageId, IntSize());
             m_imageToTextureMap.remove(imageId);
             releaseTexImage2DMock(imageId);
         }
     }
 
     WGC3Duint mostRecentlyWaitedSyncToken()
     {
         return m_contextGL->mostRecentlyWaitedSyncToken();
     }
 
+    IntSize mostRecentlyProducedSize()
+    {
+        return m_contextGL->mostRecentlyProducedSize();
+    }
+
+
     WGC3Duint nextImageIdToBeCreated()
     {
         return m_currentImageId;
     }
 
-    void setAllowImageChromium(bool allow)
-    {
-        m_allowImageChromium = allow;
-    }
-
     gpu::gles2::GLES2Interface* getGLES2Interface() override
     {
         return m_contextGL.get();
     }
 
 private:
-    HashMap<WebGLId, IntSize> m_textureSizes;
-    WGC3Dbyte m_currentMailboxByte;
-    IntSize m_mostRecentlyProducedSize;
     WGC3Duint m_currentImageId;
     HashMap<WGC3Duint, IntSize> m_imageSizes;
     HashMap<WGC3Duint, WebGLId> m_imageToTextureMap;
-    bool m_allowImageChromium;
     OwnPtr<GLES2InterfaceForTests> m_contextGL;
 };
 
 static const int initialWidth = 100;
 static const int initialHeight = 100;
 static const int alternateHeight = 50;
 
 class DrawingBufferForTests : public DrawingBuffer {
 public:
     static PassRefPtr<DrawingBufferForTests> create(PassOwnPtr<WebGraphicsContext3D> context, gpu::gles2::GLES2Interface* gl, const IntSize& size, PreserveDrawingBuffer preserve)
@@ skipping 363 matching lines @@
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     GLenum CheckFramebufferStatus(GLenum target) override
     {
         return GL_FRAMEBUFFER_COMPLETE;
     }
 
+    void GetIntegerv(GLenum ptype, GLint* value) override
+    {
+        switch (ptype) {
+        case GL_DEPTH_BITS:
+            *value = (m_depthAttachment || m_depthStencilAttachment) ? 24 : 0;
+            return;
+        case GL_STENCIL_BITS:
+            *value = (m_stencilAttachment || m_depthStencilAttachment) ? 8 : 0;
+            return;
+        case GL_MAX_TEXTURE_SIZE:
+            *value = 1024;
+            return;
+        }
+    }
+
     uint32_t stencilAttachment() const { return m_stencilAttachment; }
     uint32_t depthAttachment() const { return m_depthAttachment; }
     uint32_t depthStencilAttachment() const { return m_depthStencilAttachment; }
 
 private:
     uint32_t m_depthAttachment = 0;
     uint32_t m_stencilAttachment = 0;
     uint32_t m_depthStencilAttachment = 0;
 };
 
@@ skipping 13 matching lines @@
             return WebString::fromUTF8("GL_OES_packed_depth_stencil");
         }
         return WebString();
     }
 
     WebGLId createRenderbuffer() override
     {
         return ++m_nextRenderBufferId;
     }
 
-    void getIntegerv(WGC3Denum ptype, WGC3Dint* value) override
-    {
-        switch (ptype) {
-        case GL_DEPTH_BITS:
-            *value = (depthAttachment() || depthStencilAttachment()) ? 24 : 0;
-            return;
-        case GL_STENCIL_BITS:
-            *value = (stencilAttachment() || depthStencilAttachment()) ? 8 : 0;
-            return;
-        }
-        MockWebGraphicsContext3D::getIntegerv(ptype, value);
-    }
-
     gpu::gles2::GLES2Interface* getGLES2Interface() override { return &m_contextGL; }
 
 private:
     WebGLId m_nextRenderBufferId;
     DepthStencilTrackingGLES2Interface m_contextGL;
 };
 
 struct DepthStencilTestCase {
     DepthStencilTestCase(bool requestStencil, bool requestDepth, int expectedRenderBuffers, const char* const testCaseName)
         : requestStencil(requestStencil)
@@ skipping 81 matching lines @@
     EXPECT_EQ(waitSyncToken, webContext()->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->beginDestruction();
 }
 
 class DrawingBufferImageChromiumFallbackTest : public DrawingBufferTest {
 protected:
     void SetUp() override
     {
         OwnPtr<GLES2InterfaceForTests> gl = adoptPtr(new GLES2InterfaceForTests);
+        gl->setAllowImageChromium(false);
         m_gl = gl.get();
         OwnPtr<WebGraphicsContext3DForTests> context = adoptPtr(new WebGraphicsContext3DForTests(gl.release()));
-        context->setAllowImageChromium(false);
         m_context = context.get();
         RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(true);
         m_drawingBuffer = DrawingBufferForTests::create(context.release(), m_gl,
             IntSize(initialWidth, initialHeight), DrawingBuffer::Preserve);
     }
 
     void TearDown() override
     {
         RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(false);
     }
 };
 
 TEST_F(DrawingBufferImageChromiumFallbackTest, verifyImageChromiumFallback)
 {
     WebExternalTextureMailbox mailbox;
 
     IntSize initialSize(initialWidth, initialHeight);
     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