Remove create/delete methods from WebGraphicsContext3D.

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 150 matching lines @@
             m_imageToTextureMap.remove(imageId);
             ReleaseTexImage2DMock(imageId);
         }
     }
 
     void GenSyncTokenCHROMIUM(GLuint64 fenceSync, GLbyte* syncToken) override
     {
         memcpy(syncToken, &fenceSync, sizeof(fenceSync));
     }
 
-    uint32_t boundTexture() const { return m_boundTexture; }
-    uint32_t boundTextureTarget() const { return m_boundTextureTarget; }
-    uint32_t mostRecentlyWaitedSyncToken() const { return m_mostRecentlyWaitedSyncToken; }
-    uint32_t currentImageId() const { return m_currentImageId; }
+    void GenTextures(GLsizei n, GLuint* textures) override
+    {
+        static GLuint id = 1;

[Ken Russell (switch to Gerrit), 2016/03/22 00:43:45]

I think it'd be more reliable to add the most recently allocated texture ID as a
member variable rather than a static local in this function.

[danakj, 2016/03/22 00:47:47]

Well, the result should be roughly the same, the difference being that as a
static if multiple contexts are being used, a single context may not give out
sequential ids (it may skip some numbers). And it would let us query the
variable in tests though if we needed to.

All things being equal I prefer it in the method if we don't need to query it,
as it keeps the class definition simpler and limits the scope of the variable
maximally.

[Ken Russell (switch to Gerrit), 2016/03/22 00:50:37]

OK. I defer to your judgment.

+        for (GLsizei i = 0; i < n; ++i)
+            textures[i] = id++;
+    }
+
+    GLuint boundTexture() const { return m_boundTexture; }
+    GLuint boundTextureTarget() const { return m_boundTextureTarget; }
+    GLuint mostRecentlyWaitedSyncToken() const { return m_mostRecentlyWaitedSyncToken; }
+    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:
-    uint32_t m_boundTexture = 0;
-    uint32_t m_boundTextureTarget = 0;
-    uint32_t m_mostRecentlyWaitedSyncToken = 0;
+    GLuint m_boundTexture = 0;
+    GLuint m_boundTextureTarget = 0;
+    GLuint m_mostRecentlyWaitedSyncToken = 0;
     WGC3Dbyte m_currentMailboxByte = 0;
     IntSize m_mostRecentlyProducedSize;
     bool m_allowImageChromium = true;
-    uint32_t m_currentImageId = 1;
-    HashMap<uint32_t, IntSize> m_textureSizes;
-    HashMap<uint32_t, IntSize> m_imageSizes;
-    HashMap<uint32_t, uint32_t> m_imageToTextureMap;
+    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(PassOwnPtr<GLES2InterfaceForTests> contextGL)
         : m_contextGL(std::move(contextGL))
     {
     }
 
     WGC3Duint mostRecentlyWaitedSyncToken()
@@ skipping 410 matching lines @@
             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; }
+    void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
+    {
+        for (GLsizei i = 0; i < n; ++i)
+            renderbuffers[i] = m_nextGenRenderbufferId++;
+    }
+
+    GLuint stencilAttachment() const { return m_stencilAttachment; }
+    GLuint depthAttachment() const { return m_depthAttachment; }
+    GLuint depthStencilAttachment() const { return m_depthStencilAttachment; }
+    size_t numAllocatedRenderBuffer() const { return m_nextGenRenderbufferId - 1; }
 
 private:
-    uint32_t m_depthAttachment = 0;
-    uint32_t m_stencilAttachment = 0;
-    uint32_t m_depthStencilAttachment = 0;
+    GLuint m_nextGenRenderbufferId = 1;
+    GLuint m_depthAttachment = 0;
+    GLuint m_stencilAttachment = 0;
+    GLuint m_depthStencilAttachment = 0;
 };
 
 class DepthStencilTrackingContext : public MockWebGraphicsContext3D {
 public:
-    DepthStencilTrackingContext() : m_nextRenderBufferId(1) {}
     ~DepthStencilTrackingContext() override {}
 
-    int numAllocatedRenderBuffer() const { return m_nextRenderBufferId - 1; }
+    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(); }
 
     WebString getString(WGC3Denum type) override
     {
         if (type == GL_EXTENSIONS) {
             return WebString::fromUTF8("GL_OES_packed_depth_stencil");
         }
         return WebString();
     }
 
-    WebGLId createRenderbuffer() override
-    {
-        return ++m_nextRenderBufferId;
-    }
-
     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)
         , requestDepth(requestDepth)
         , expectedRenderBuffers(expectedRenderBuffers)
         , testCaseName(testCaseName) { }
 
     bool requestStencil;
     bool requestDepth;
-    int expectedRenderBuffers;
+    size_t expectedRenderBuffers;
     const char* const testCaseName;
 };
 
 // This tests that when the packed depth+stencil extension is supported DrawingBuffer always allocates
 // a single packed renderbuffer if either is requested and properly computes the actual context attributes
 // as defined by WebGL. We always allocate a packed buffer in this case since many desktop OpenGL drivers
 // that support this extension do not consider a framebuffer with only a depth or a stencil buffer attached
 // to be complete.
 TEST(DrawingBufferDepthStencilTest, packedDepthStencilSupported)
 {
@@ skipping 95 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