Move simple methods [A-E] from WebGraphicsContext3D to GLES2Interface.

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 48 matching lines @@
 {
     DEFINE_STATIC_LOCAL(WTF::RefCountedLeakCounter, staticDrawingBufferCounter, ("DrawingBuffer"));
     return staticDrawingBufferCounter;
 }
 #endif
 
 class ScopedTextureUnit0BindingRestorer {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(ScopedTextureUnit0BindingRestorer);
 public:
-    ScopedTextureUnit0BindingRestorer(WebGraphicsContext3D* context, GLenum activeTextureUnit, Platform3DObject textureUnitZeroId)
-        : m_context(context)
+    ScopedTextureUnit0BindingRestorer(gpu::gles2::GLES2Interface* gl, GLenum activeTextureUnit, Platform3DObject textureUnitZeroId)
+        : m_gl(gl)
         , m_oldActiveTextureUnit(activeTextureUnit)
         , m_oldTextureUnitZeroId(textureUnitZeroId)
     {
-        m_context->activeTexture(GL_TEXTURE0);
+        m_gl->ActiveTexture(GL_TEXTURE0);
     }
     ~ScopedTextureUnit0BindingRestorer()
     {
-        m_context->bindTexture(GL_TEXTURE_2D, m_oldTextureUnitZeroId);
-        m_context->activeTexture(m_oldActiveTextureUnit);
+        m_gl->BindTexture(GL_TEXTURE_2D, m_oldTextureUnitZeroId);
+        m_gl->ActiveTexture(m_oldActiveTextureUnit);
     }
 
 private:
-    WebGraphicsContext3D* m_context;
+    gpu::gles2::GLES2Interface* m_gl;
     GLenum m_oldActiveTextureUnit;
     Platform3DObject m_oldTextureUnitZeroId;
 };
 
 static bool shouldFailDrawingBufferCreationForTesting = false;
 
 } // namespace
 
 PassRefPtr<DrawingBuffer> DrawingBuffer::create(PassOwnPtr<WebGraphicsContext3D> context, const IntSize& size, PreserveDrawingBuffer preserve, WebGraphicsContext3D::Attributes requestedAttributes)
 {
@@ skipping 168 matching lines @@
 
         unsigned char* pixels = bitmap->pixels();
         bool needPremultiply = m_actualAttributes.alpha && !m_actualAttributes.premultipliedAlpha;
         WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
         if (pixels)
             readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
     }
 
     // We must restore the texture binding since creating new textures,
     // consuming and producing mailboxes changes it.
-    ScopedTextureUnit0BindingRestorer restorer(m_context.get(), m_activeTextureUnit, m_texture2DBinding);
+    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) {
         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_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         attachColorBufferToCurrentFBO();
 
         if (m_discardFramebufferSupported) {
             // Explicitly discard framebuffer to save GPU memory bandwidth for tile-based GPU arch.
             const WGC3Denum attachments[3] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT};
-            m_context->discardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
+            m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
         }
     } else {
         m_context->copyTextureCHROMIUM(m_colorBuffer.textureId, frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.internalColorFormat, GL_UNSIGNED_BYTE, GL_FALSE, GL_FALSE, GL_FALSE);
     }
 
     restoreFramebufferBindings();
     m_contentsChanged = false;
 
     m_context->produceTextureDirectCHROMIUM(frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.target, frontColorBufferMailbox->mailbox.name);
-    const WGC3Duint64 fenceSync = m_context->insertFenceSyncCHROMIUM();
+    const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
     m_context->flush();
     frontColorBufferMailbox->mailbox.validSyncToken = m_context->genSyncTokenCHROMIUM(fenceSync, frontColorBufferMailbox->mailbox.syncToken);
     frontColorBufferMailbox->mailbox.allowOverlay = frontColorBufferMailbox->textureInfo.imageId != 0;
     frontColorBufferMailbox->mailbox.textureTarget = frontColorBufferMailbox->textureInfo.parameters.target;
     frontColorBufferMailbox->mailbox.textureSize = WebSize(m_size.width(), m_size.height());
     setBufferClearNeeded(true);
 
     // set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes
     ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer);
     frontColorBufferMailbox->m_parentDrawingBuffer = this;
@@ skipping 80 matching lines @@
     RefPtr<MailboxInfo> mailboxInfo;
     for (size_t i = 0; i < m_textureMailboxes.size(); i++) {
         if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) {
             mailboxInfo = m_textureMailboxes[i];
             break;
         }
     }
     ASSERT(mailboxInfo);
 
     if (mailboxInfo->mailbox.validSyncToken) {
-        m_context->waitSyncTokenCHROMIUM(mailboxInfo->mailbox.syncToken);
+        m_gl->WaitSyncTokenCHROMIUM(mailboxInfo->mailbox.syncToken);
         mailboxInfo->mailbox.validSyncToken = false;
     }
 
     if (mailboxInfo->size != m_size) {
         resizeTextureMemory(&mailboxInfo->textureInfo, m_size);
         mailboxInfo->size = m_size;
     }
 
     return mailboxInfo.release();
 }
 
 PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::createNewMailbox(const TextureInfo& info)
 {
     RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo());
     m_context->genMailboxCHROMIUM(returnMailbox->mailbox.name);
     returnMailbox->textureInfo = info;
     returnMailbox->size = m_size;
     m_textureMailboxes.append(returnMailbox);
     return returnMailbox.release();
 }
 
 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_context->waitSyncTokenCHROMIUM(mailbox.syncToken);
+                m_gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
 
             deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo);
 
             m_context->deleteTexture(m_textureMailboxes[i]->textureInfo.textureId);
             m_textureMailboxes.remove(i);
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
@@ skipping 15 matching lines @@
         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_fbo = m_context->createFramebuffer();
 
-    m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+    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;
         m_context->getIntegerv(GL_ALPHA_BITS, &alphaBits);
         m_actualAttributes.alpha = alphaBits > 0;
@@ skipping 11 matching lines @@
     m_actualAttributes.antialias = multisample();
 
     if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
         // It's possible that the drawing buffer allocation provokes a context loss, so check again just in case. http://crbug.com/512302
         return false;
     }
 
     return true;
 }
 
-bool DrawingBuffer::copyToPlatformTexture(WebGraphicsContext3D* context, Platform3DObject texture, GLenum internalFormat,
+bool DrawingBuffer::copyToPlatformTexture(WebGraphicsContext3D* context, gpu::gles2::GLES2Interface* gl, Platform3DObject texture, GLenum internalFormat,
     GLenum destType, GLint level, bool premultiplyAlpha, bool flipY, SourceDrawingBuffer sourceBuffer)
 {
     if (m_contentsChanged) {
         if (m_antiAliasingMode != None) {
             commit();
             restoreFramebufferBindings();
         }
         m_context->flush();
     }
 
     // Assume that the destination target is GL_TEXTURE_2D.
     if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(GL_TEXTURE_2D, internalFormat, destType, level))
         return false;
 
     // Contexts may be in a different share group. We must transfer the texture through a mailbox first
     WebExternalTextureMailbox mailbox;
     GLint textureId = 0;
     GLenum target = 0;
     if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
         textureId = m_frontColorBuffer.texInfo.textureId;
         mailbox = m_frontColorBuffer.mailbox;
         target = m_frontColorBuffer.texInfo.parameters.target;
     } else {
         textureId = m_colorBuffer.textureId;
         target = m_colorBuffer.parameters.target;
         m_context->genMailboxCHROMIUM(mailbox.name);
         m_context->produceTextureDirectCHROMIUM(textureId, target, mailbox.name);
-        const WGC3Duint64 fenceSync = m_context->insertFenceSyncCHROMIUM();
+        const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
         m_context->flush();
         mailbox.validSyncToken = m_context->genSyncTokenCHROMIUM(fenceSync, mailbox.syncToken);
     }
 
     if (mailbox.validSyncToken)
-        context->waitSyncTokenCHROMIUM(mailbox.syncToken);
+        gl->WaitSyncTokenCHROMIUM(mailbox.syncToken);
     Platform3DObject sourceTexture = context->createAndConsumeTextureCHROMIUM(target, mailbox.name);
 
     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;
 
     context->copyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY, unpackPremultiplyAlphaNeeded, unpackUnpremultiplyAlphaNeeded);
 
     context->deleteTexture(sourceTexture);
 
-    const WGC3Duint64 fenceSync = context->insertFenceSyncCHROMIUM();
+    const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM();
 
     context->flush();
     GLbyte syncToken[24];
     if (context->genSyncTokenCHROMIUM(fenceSync, syncToken))
-        m_context->waitSyncTokenCHROMIUM(syncToken);
+        m_gl->WaitSyncTokenCHROMIUM(syncToken);
 
     return true;
 }
 
 Platform3DObject DrawingBuffer::framebuffer() const
 {
     return m_fbo;
 }
 
 WebLayer* DrawingBuffer::platformLayer()
@@ skipping 58 matching lines @@
     if (m_layer)
         GraphicsLayer::unregisterContentsLayer(m_layer->layer());
 }
 
 WebGLId DrawingBuffer::createColorTexture(const TextureParameters& parameters)
 {
     WebGLId offscreenColorTexture = m_context->createTexture();
     if (!offscreenColorTexture)
         return 0;
 
-    m_context->bindTexture(parameters.target, offscreenColorTexture);
+    m_gl->BindTexture(parameters.target, offscreenColorTexture);
     m_context->texParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     m_context->texParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     m_context->texParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     m_context->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_multisampleFBO = m_context->createFramebuffer();
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
         m_multisampleColorBuffer = m_context->createRenderbuffer();
     }
 }
 
 bool DrawingBuffer::resizeFramebuffer(const IntSize& size)
 {
-    m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     if (m_antiAliasingMode != MSAAExplicitResolve)
         resizeDepthStencil(size);
-    if (m_context->checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+    if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         return false;
 
     return true;
 }
 
 bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size)
 {
     if (m_antiAliasingMode == MSAAExplicitResolve) {
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
 
-        m_context->bindRenderbuffer(GL_RENDERBUFFER, m_multisampleColorBuffer);
-        m_context->renderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
+        m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleColorBuffer);
+        m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
 
         if (m_context->getError() == GL_OUT_OF_MEMORY)
             return false;
 
         m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleColorBuffer);
         resizeDepthStencil(size);
-        if (m_context->checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+        if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
             return false;
     }
 
     return true;
 }
 
 void DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
     if (!m_requestedAttributes.depth && !m_requestedAttributes.stencil)
         return;
 
     if (!m_depthStencilBuffer)
         m_depthStencilBuffer = m_context->createRenderbuffer();
-    m_context->bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_context->renderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else if (m_antiAliasingMode == MSAAExplicitResolve)
-        m_context->renderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
+        m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
     else
         m_context->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_context->bindRenderbuffer(GL_RENDERBUFFER, 0);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
 
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask)
 {
     // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer.
     if (m_multisampleFBO) {
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-        m_context->clear(GL_COLOR_BUFFER_BIT);
+        m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+        m_gl->Clear(GL_COLOR_BUFFER_BIT);
     }
 
-    m_context->bindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
-    m_context->clear(clearMask);
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
+    m_gl->Clear(clearMask);
 }
 
 bool DrawingBuffer::hasImplicitStencilBuffer() const
 {
     return m_depthStencilBuffer && m_requestedAttributes.depth && !m_requestedAttributes.stencil;
 }
 
 void DrawingBuffer::setSize(const IntSize& size)
 {
     if (m_size == size)
@@ skipping 24 matching lines @@
         return false;
 
     if (adjustedSize != m_size) {
         do {
             if (m_colorBuffer.textureId) {
                 resizeTextureMemory(&m_colorBuffer, adjustedSize);
             } else {
                 m_colorBuffer = createTextureAndAllocateMemory(adjustedSize);
             }
 
-            m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
             attachColorBufferToCurrentFBO();
 
             // resize multisample FBO
             if (!resizeMultisampleFramebuffer(adjustedSize) || !resizeFramebuffer(adjustedSize)) {
                 adjustedSize.scale(s_resourceAdjustedRatio);
                 continue;
             }
             break;
         } while (!adjustedSize.isEmpty());
 
         setSize(adjustedSize);
 
         if (adjustedSize.isEmpty())
             return false;
     }
 
-    m_context->disable(GL_SCISSOR_TEST);
-    m_context->clearColor(0, 0, 0, 0);
-    m_context->colorMask(true, true, true, true);
+    m_gl->Disable(GL_SCISSOR_TEST);
+    m_gl->ClearColor(0, 0, 0, 0);
+    m_gl->ColorMask(true, true, true, true);
 
     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
     if (m_actualAttributes.depth) {
-        m_context->clearDepth(1.0f);
+        m_gl->ClearDepthf(1.0f);
         clearMask |= GL_DEPTH_BUFFER_BIT;
-        m_context->depthMask(true);
+        m_gl->DepthMask(true);
     }
     if (m_actualAttributes.stencil) {
-        m_context->clearStencil(0);
+        m_gl->ClearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
         m_context->stencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
     clearFramebuffers(clearMask);
     return true;
 }
 
 void DrawingBuffer::commit()
 {
     if (m_multisampleFBO && !m_contentsChangeCommitted) {
-        m_context->bindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleFBO);
-        m_context->bindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
+        m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleFBO);
+        m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
 
         if (m_scissorEnabled)
-            m_context->disable(GL_SCISSOR_TEST);
+            m_gl->Disable(GL_SCISSOR_TEST);
 
         int width = m_size.width();
         int height = m_size.height();
         // Use NEAREST, because there is no scale performed during the blit.
         m_context->blitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
         if (m_scissorEnabled)
-            m_context->enable(GL_SCISSOR_TEST);
+            m_gl->Enable(GL_SCISSOR_TEST);
     }
 
-    m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     if (m_antiAliasingMode == ScreenSpaceAntialiasing) {
-        m_context->applyScreenSpaceAntialiasingCHROMIUM();
+        m_gl->ApplyScreenSpaceAntialiasingCHROMIUM();
     }
     m_contentsChangeCommitted = true;
 }
 
 void DrawingBuffer::restoreFramebufferBindings()
 {
     if (m_drawFramebufferBinding && m_readFramebufferBinding) {
         if (m_drawFramebufferBinding == m_readFramebufferBinding) {
-            m_context->bindFramebuffer(GL_FRAMEBUFFER, m_readFramebufferBinding);
+            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_readFramebufferBinding);
         } else {
-            m_context->bindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding);
-            m_context->bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding);
+            m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding);
+            m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding);
         }
         return;
     }
     if (!m_drawFramebufferBinding && !m_readFramebufferBinding) {
         bind(GL_FRAMEBUFFER);
         return;
     }
     if (!m_drawFramebufferBinding) {
         bind(GL_DRAW_FRAMEBUFFER);
-        m_context->bindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding);
+        m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding);
     } else {
         bind(GL_READ_FRAMEBUFFER);
-        m_context->bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding);
+        m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding);
     }
 }
 
 bool DrawingBuffer::multisample() const
 {
     return m_antiAliasingMode != None;
 }
 
 void DrawingBuffer::bind(GLenum target)
 {
     if (target != GL_READ_FRAMEBUFFER)
-        m_context->bindFramebuffer(target, m_multisampleFBO ? m_multisampleFBO : m_fbo);
+        m_gl->BindFramebuffer(target, m_multisampleFBO ? m_multisampleFBO : m_fbo);
     else
-        m_context->bindFramebuffer(target, m_fbo);
+        m_gl->BindFramebuffer(target, m_fbo);
 }
 
 void DrawingBuffer::setPackAlignment(GLint param)
 {
     m_packAlignment = param;
 }
 
 bool DrawingBuffer::paintRenderingResultsToImageData(int& width, int& height, SourceDrawingBuffer sourceBuffer, WTF::ArrayBufferContents& contents)
 {
     ASSERT(!m_actualAttributes.premultipliedAlpha);
     width = size().width();
     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);
 
     GLint fbo = 0;
     if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
         fbo = m_context->createFramebuffer();
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, fbo);
+        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_context->bindFramebuffer(GL_FRAMEBUFFER, framebuffer());
+        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_context->deleteFramebuffer(fbo);
     }
 
@@ skipping 51 matching lines @@
 
 void DrawingBuffer::texImage2DResourceSafe(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLint unpackAlignment)
 {
     ASSERT(unpackAlignment == 1 || unpackAlignment == 2 || unpackAlignment == 4 || unpackAlignment == 8);
     m_context->texImage2D(target, level, internalformat, width, height, border, format, type, 0);
 }
 
 void DrawingBuffer::deleteChromiumImageForTexture(TextureInfo* info)
 {
     if (info->imageId) {
-        m_context->bindTexture(info->parameters.target, info->textureId);
+        m_gl->BindTexture(info->parameters.target, info->textureId);
         m_context->releaseTexImage2DCHROMIUM(info->parameters.target, info->imageId);
         m_context->destroyImageCHROMIUM(info->imageId);
         info->imageId = 0;
     }
 }
 
 DrawingBuffer::TextureInfo DrawingBuffer::createTextureAndAllocateMemory(const IntSize& size)
 {
     // TODO(erikchen): Add support for a CHROMIUM_image back buffer whose
     // behavior mimics a texture with internal format GL_RGB.
@@ skipping 38 matching lines @@
     return info;
 }
 
 void DrawingBuffer::resizeTextureMemory(TextureInfo* info, const IntSize& size)
 {
     ASSERT(info->textureId);
     if (info->imageId) {
         deleteChromiumImageForTexture(info);
         info->imageId = m_context->createGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), info->parameters.internalColorFormat, GC3D_SCANOUT_CHROMIUM);
         if (info->imageId) {
-            m_context->bindTexture(info->parameters.target, info->textureId);
+            m_gl->BindTexture(info->parameters.target, info->textureId);
             m_context->bindTexImage2DCHROMIUM(info->parameters.target, info->imageId);
             return;
         }
 
         // If the desired texture target is different, there's no way to fall back
         // to a non CHROMIUM_image texture.
         if (chromiumImageTextureParameters().target != defaultTextureParameters().target)
             return;
     }
 
-    m_context->bindTexture(info->parameters.target, info->textureId);
+    m_gl->BindTexture(info->parameters.target, info->textureId);
     texImage2DResourceSafe(info->parameters.target, 0, info->parameters.internalColorFormat, size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE);
 }
 
 void DrawingBuffer::attachColorBufferToCurrentFBO()
 {
     WGC3Denum target = m_colorBuffer.parameters.target;
 
-    m_context->bindTexture(target, m_colorBuffer.textureId);
+    m_gl->BindTexture(target, m_colorBuffer.textureId);
 
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_context->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_context->bindTexture(GL_TEXTURE_2D, m_texture2DBinding);
+    m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 } // namespace blink