Revert of Remove create/delete methods from WebGraphicsContext3D.

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

 /*
  * Copyright (c) 2010, 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 258 matching lines @@
 
     // We must restore the texture binding since creating new textures,
     // consuming and producing mailboxes changes it.
     ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit, m_texture2DBinding);
 
     // First try to recycle an old buffer.
     RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox();
 
     // No buffer available to recycle, create a new one.
     if (!frontColorBufferMailbox) {
-        frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size));
+        TextureInfo newTexture = createTextureAndAllocateMemory(m_size);
+        // Bad things happened, abandon ship.
+        if (!newTexture.textureId)
+            return false;
+
+        frontColorBufferMailbox = createNewMailbox(newTexture);
     }
 
     if (m_preserveDrawingBuffer == Discard) {
         std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer);
         // It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
         // WebGLRenderingContext::clearIfComposited() call made before the next draw call which restores the framebuffer binding.
         // If this stops being true at some point, we should track the current framebuffer binding in the DrawingBuffer and restore
         // it after attaching the new back buffer here.
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         attachColorBufferToCurrentFBO();
@@ skipping 137 matching lines @@
 
 void DrawingBuffer::deleteMailbox(const WebExternalTextureMailbox& mailbox)
 {
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
         if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) {
             if (mailbox.validSyncToken)
                 m_gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
 
             deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo);
 
-            m_gl->DeleteTextures(1, &m_textureMailboxes[i]->textureInfo.textureId);
+            m_context->deleteTexture(m_textureMailboxes[i]->textureInfo.textureId);
             m_textureMailboxes.remove(i);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
 bool DrawingBuffer::initialize(const IntSize& size)
 {
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // Need to try to restore the context again later.
         return false;
     }
 
     m_gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
 
     int maxSampleCount = 0;
     m_antiAliasingMode = None;
     if (m_requestedAttributes.antialias && m_multisampleExtensionSupported) {
         m_gl->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &maxSampleCount);
         m_antiAliasingMode = MSAAExplicitResolve;
         if (m_extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture")) {
             m_antiAliasingMode = MSAAImplicitResolve;
         } else if (m_extensionsUtil->supportsExtension("GL_CHROMIUM_screen_space_antialiasing")) {
             m_antiAliasingMode = ScreenSpaceAntialiasing;
         }
     }
     m_sampleCount = std::min(4, maxSampleCount);
 
-    m_gl->GenFramebuffers(1, &m_fbo);
+    m_fbo = m_context->createFramebuffer();
 
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     createSecondaryBuffers();
     // We first try to initialize everything with the requested attributes.
     if (!reset(size))
         return false;
     // If that succeeds, we then see what we actually got and update our actual attributes to reflect that.
     m_actualAttributes = m_requestedAttributes;
     if (m_requestedAttributes.alpha) {
         WGC3Dint alphaBits = 0;
@@ skipping 60 matching lines @@
 
     GLboolean unpackPremultiplyAlphaNeeded = GL_FALSE;
     GLboolean unpackUnpremultiplyAlphaNeeded = GL_FALSE;
     if (m_actualAttributes.alpha && m_actualAttributes.premultipliedAlpha && !premultiplyAlpha)
         unpackUnpremultiplyAlphaNeeded = GL_TRUE;
     else if (m_actualAttributes.alpha && !m_actualAttributes.premultipliedAlpha && premultiplyAlpha)
         unpackPremultiplyAlphaNeeded = GL_TRUE;
 
     gl->CopyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY, unpackPremultiplyAlphaNeeded, unpackUnpremultiplyAlphaNeeded);
 
-    gl->DeleteTextures(1, &sourceTexture);
+    context->deleteTexture(sourceTexture);
 
     const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
 
     gl->Flush();
     GLbyte syncToken[24];
     gl->GenSyncTokenCHROMIUM(fenceSync, syncToken);
     m_gl->WaitSyncTokenCHROMIUM(syncToken);
 
     return true;
 }
@@ skipping 30 matching lines @@
 {
     ASSERT(!m_destructionInProgress);
     m_destructionInProgress = true;
 
     clearPlatformLayer();
 
     while (!m_recycledMailboxQueue.isEmpty())
         deleteMailbox(m_recycledMailboxQueue.takeLast());
 
     if (m_multisampleFBO)
-        m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
+        m_context->deleteFramebuffer(m_multisampleFBO);
 
     if (m_fbo)
-        m_gl->DeleteFramebuffers(1, &m_fbo);
+        m_context->deleteFramebuffer(m_fbo);
 
     if (m_multisampleColorBuffer)
-        m_gl->DeleteRenderbuffers(1, &m_multisampleColorBuffer);
+        m_context->deleteRenderbuffer(m_multisampleColorBuffer);
 
     if (m_depthStencilBuffer)
-        m_gl->DeleteRenderbuffers(1, &m_depthStencilBuffer);
+        m_context->deleteRenderbuffer(m_depthStencilBuffer);
 
     if (m_colorBuffer.textureId) {
         deleteChromiumImageForTexture(&m_colorBuffer);
-        m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
+        m_context->deleteTexture(m_colorBuffer.textureId);
     }
 
     setSize(IntSize());
 
     m_colorBuffer = TextureInfo();
     m_frontColorBuffer = FrontBufferInfo();
     m_multisampleColorBuffer = 0;
     m_depthStencilBuffer = 0;
     m_multisampleFBO = 0;
     m_fbo = 0;
 
     if (m_layer)
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
 }
 
 WebGLId DrawingBuffer::createColorTexture(const TextureParameters& parameters)
 {
-    GLuint offscreenColorTexture;
-    m_gl->GenTextures(1, &offscreenColorTexture);
+    WebGLId offscreenColorTexture = m_context->createTexture();
+    if (!offscreenColorTexture)
+        return 0;
+
     m_gl->BindTexture(parameters.target, offscreenColorTexture);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
     return offscreenColorTexture;
 }
 
 void DrawingBuffer::createSecondaryBuffers()
 {
     // create a multisample FBO
     if (m_antiAliasingMode == MSAAExplicitResolve) {
-        m_gl->GenFramebuffers(1, &m_multisampleFBO);
+        m_multisampleFBO = m_context->createFramebuffer();
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
-        m_gl->GenRenderbuffers(1, &m_multisampleColorBuffer);
+        m_multisampleColorBuffer = m_context->createRenderbuffer();
     }
 }
 
 bool DrawingBuffer::resizeFramebuffer(const IntSize& size)
 {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     if (m_antiAliasingMode != MSAAExplicitResolve)
         resizeDepthStencil(size);
     if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         return false;
@@ skipping 20 matching lines @@
 
     return true;
 }
 
 void DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
     if (!m_requestedAttributes.depth && !m_requestedAttributes.stencil)
         return;
 
     if (!m_depthStencilBuffer)
-        m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
+        m_depthStencilBuffer = m_context->createRenderbuffer();
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else if (m_antiAliasingMode == MSAAExplicitResolve)
         m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else
         m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
 }
@@ skipping 165 matching lines @@
     height = size().height();
 
     Checked<int, RecordOverflow> dataSize = 4;
     dataSize *= width;
     dataSize *= height;
     if (dataSize.hasOverflowed())
         return false;
 
     WTF::ArrayBufferContents pixels(width * height, 4, WTF::ArrayBufferContents::NotShared, WTF::ArrayBufferContents::DontInitialize);
 
-    GLuint fbo = 0;
+    GLint fbo = 0;
     if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
-        m_gl->GenFramebuffers(1, &fbo);
+        fbo = m_context->createFramebuffer();
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
         m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_frontColorBuffer.texInfo.parameters.target, m_frontColorBuffer.texInfo.textureId, 0);
     } else {
         m_gl->BindFramebuffer(GL_FRAMEBUFFER, framebuffer());
     }
 
     readBackFramebuffer(static_cast<unsigned char*>(pixels.data()), width, height, ReadbackRGBA, WebGLImageConversion::AlphaDoNothing);
     flipVertically(static_cast<uint8_t*>(pixels.data()), width, height);
 
     if (fbo) {
         m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_frontColorBuffer.texInfo.parameters.target, 0, 0);
-        m_gl->DeleteFramebuffers(1, &fbo);
+        m_context->deleteFramebuffer(fbo);
     }
 
     restoreFramebufferBindings();
 
     pixels.transfer(contents);
     return true;
 }
 
 void DrawingBuffer::readBackFramebuffer(unsigned char* pixels, int width, int height, ReadbackOrder readbackOrder, WebGLImageConversion::AlphaOp op)
 {
@@ skipping 69 matching lines @@
         return createDefaultTextureAndAllocateMemory(size);
 
     // First, try to allocate a CHROMIUM_image. This always has the potential to
     // fail.
     TextureParameters parameters = chromiumImageTextureParameters();
     WGC3Duint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.internalColorFormat, GC3D_SCANOUT_CHROMIUM);
     if (!imageId)
         return createDefaultTextureAndAllocateMemory(size);
 
     WebGLId textureId = createColorTexture(parameters);
+    if (!textureId) {
+        m_gl->DestroyImageCHROMIUM(imageId);
+        return createDefaultTextureAndAllocateMemory(size);
+    }
+
     m_gl->BindTexImage2DCHROMIUM(parameters.target, imageId);
 
     TextureInfo info;
     info.textureId = textureId;
     info.imageId = imageId;
     info.parameters = parameters;
     return info;
 }
 
 DrawingBuffer::TextureInfo DrawingBuffer::createDefaultTextureAndAllocateMemory(const IntSize& size)
@@ skipping 38 matching lines @@
 
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0, m_sampleCount);
     else
         m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0);
 
     m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 } // namespace blink