DrawingBuffer: Clean up GL state restoration

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 696 matching lines @@
       std::move(drawingBuffer()->transferToStaticBitmapImage()),
       drawingBuffer()->contextProvider()->isSoftwareRendering());
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::getImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!drawingBuffer())
     return nullptr;
 
-  drawingBuffer()->commit();
+  drawingBuffer()->resolveAndBindForReadAndDraw();
   IntSize size = clampedCanvasSize();
   OpacityMode opacityMode =
       creationAttributes().hasAlpha() ? NonOpaque : Opaque;
   std::unique_ptr<AcceleratedImageBufferSurface> surface =
       wrapUnique(new AcceleratedImageBufferSurface(size, opacityMode));
   if (!surface->isValid())
     return nullptr;
   std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(std::move(surface));
   if (!buffer->copyRenderingResultsFromDrawingBuffer(drawingBuffer(),
                                                      BackBuffer)) {
@@ skipping 318 matching lines @@
                                                    : DrawingBuffer::Discard;
   DrawingBuffer::WebGLVersion webGLVersion = DrawingBuffer::WebGL1;
   if (version() == 1) {
     webGLVersion = DrawingBuffer::WebGL1;
   } else if (version() == 2) {
     webGLVersion = DrawingBuffer::WebGL2;
   } else {
     NOTREACHED();
   }
   return DrawingBuffer::create(
-      std::move(contextProvider), clampedCanvasSize(), premultipliedAlpha,
+      std::move(contextProvider), this, clampedCanvasSize(), premultipliedAlpha,
       wantAlphaChannel, wantDepthBuffer, wantStencilBuffer, wantAntialiasing,
       preserve, webGLVersion, chromiumImageUsage);
 }
 
 void WebGLRenderingContextBase::initializeNewContext() {
   ASSERT(!isContextLost());
   ASSERT(drawingBuffer());
 
   m_markedCanvasDirty = false;
   m_activeTextureUnit = 0;
@@ skipping 10 matching lines @@
   m_stencilEnabled = false;
   m_stencilMask = 0xFFFFFFFF;
   m_stencilMaskBack = 0xFFFFFFFF;
   m_stencilFuncRef = 0;
   m_stencilFuncRefBack = 0;
   m_stencilFuncMask = 0xFFFFFFFF;
   m_stencilFuncMaskBack = 0xFFFFFFFF;
   m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;
 
   m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;
-  drawingBuffer()->setClearColor(m_clearColor);
   m_scissorEnabled = false;
   m_clearDepth = 1;
   m_clearStencil = 0;
   m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;
-  drawingBuffer()->setColorMask(m_colorMask);
 
   GLint numCombinedTextureImageUnits = 0;
   contextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                            &numCombinedTextureImageUnits);
   m_textureUnits.clear();
   m_textureUnits.resize(numCombinedTextureImageUnits);
 
   GLint numVertexAttribs = 0;
   contextGL()->GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &numVertexAttribs);
   m_maxVertexAttribs = numVertexAttribs;
@@ skipping 265 matching lines @@
     else
       contextGL()->ClearStencil(0);
     clearMask |= GL_STENCIL_BUFFER_BIT;
     contextGL()->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
   }
 
   contextGL()->ColorMask(
       true, true, true,
       !drawingBuffer()->defaultBufferRequiresAlphaChannelToBePreserved());
   drawingBuffer()->clearFramebuffers(clearMask);
-
-  restoreStateAfterClear();
-  drawingBuffer()->restoreFramebufferBindings();
   drawingBuffer()->setBufferClearNeeded(false);
 
   return combinedClear ? CombinedClear : JustClear;
 }
 
 void WebGLRenderingContextBase::restoreScissorEnabled() {
   if (isContextLost())
     return;
 
   if (m_scissorEnabled) {
@@ skipping 12 matching lines @@
 }
 
 void WebGLRenderingContextBase::restoreClearColor() {
   if (isContextLost())
     return;
 
   contextGL()->ClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2],
                           m_clearColor[3]);
 }
 
-void WebGLRenderingContextBase::restoreClearDepthf() {
-  if (isContextLost())
-    return;
-
-  contextGL()->ClearDepthf(m_clearDepth);
-}
-
-void WebGLRenderingContextBase::restoreClearStencil() {
-  if (isContextLost())
-    return;
-
-  contextGL()->ClearStencil(m_clearStencil);
-}
-
-void WebGLRenderingContextBase::restoreStencilMaskSeparate() {
-  if (isContextLost())
-    return;
-
-  contextGL()->StencilMaskSeparate(GL_FRONT, m_stencilMask);
-}
-
 void WebGLRenderingContextBase::restoreColorMask() {
   if (isContextLost())
     return;
 
   contextGL()->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2],
                          m_colorMask[3]);
 }
 
-void WebGLRenderingContextBase::restoreDepthMask() {
-  if (isContextLost())
-    return;
-
-  contextGL()->DepthMask(m_depthMask);
-}
-
-void WebGLRenderingContextBase::restoreStateAfterClear() {
-  // Restore clear-related state items back to what the context had set.
-  restoreScissorEnabled();
-  restoreClearColor();
-  restoreColorMask();
-  restoreClearDepthf();
-  restoreClearStencil();
-  restoreStencilMaskSeparate();
-  restoreDepthMask();
-}
-
 void WebGLRenderingContextBase::markLayerComposited() {
   if (!isContextLost())
     drawingBuffer()->setBufferClearNeeded(true);
 }
 
 void WebGLRenderingContextBase::setIsHidden(bool hidden) {
   m_isHidden = hidden;
   if (drawingBuffer())
     drawingBuffer()->setIsHidden(hidden);
 
@@ skipping 15 matching lines @@
 
   canvas()->clearCopiedImage();
   m_markedCanvasDirty = false;
 
   if (!canvas()->buffer())
     return false;
 
   ScopedTexture2DRestorer restorer(this);
   ScopedFramebufferRestorer fboRestorer(this);
 
-  drawingBuffer()->commit();
+  drawingBuffer()->resolveAndBindForReadAndDraw();
   if (!canvas()->buffer()->copyRenderingResultsFromDrawingBuffer(
           drawingBuffer(), sourceBuffer)) {
     // Currently, copyRenderingResultsFromDrawingBuffer is expected to always
     // succeed because cases where canvas()-buffer() is not accelerated are
     // handle before reaching this point.  If that assumption ever stops holding
     // true, we may need to implement a fallback right here.
     ASSERT_NOT_REACHED();
     return false;
   }
 
   return true;
 }
 
 ImageData* WebGLRenderingContextBase::paintRenderingResultsToImageData(
     SourceDrawingBuffer sourceBuffer) {
   if (isContextLost())
     return nullptr;
   if (creationAttributes().premultipliedAlpha())
     return nullptr;
 
   clearIfComposited();
-  drawingBuffer()->commit();
+  drawingBuffer()->resolveAndBindForReadAndDraw();
   ScopedFramebufferRestorer restorer(this);
   int width, height;
   WTF::ArrayBufferContents contents;
   if (!drawingBuffer()->paintRenderingResultsToImageData(
           width, height, sourceBuffer, contents))
     return nullptr;
   DOMArrayBuffer* imageDataPixels = DOMArrayBuffer::create(contents);
 
   return ImageData::create(
       IntSize(width, height),
@@ skipping 27 matching lines @@
     // If we've exceeded the area limit scale the buffer down, preserving
     // ascpect ratio, until it fits.
     float scaleFactor =
         sqrtf(static_cast<float>(maxArea) / static_cast<float>(currentArea));
     width = std::max(1, static_cast<int>(width * scaleFactor));
     height = std::max(1, static_cast<int>(height * scaleFactor));
   }
 
   // We don't have to mark the canvas as dirty, since the newly created image
   // buffer will also start off clear (and this matches what reshape will do).
-  drawingBuffer()->reset(IntSize(width, height));

[ccameron, 2016/10/09 21:10:53]

This callsite has the most sin of all of them...

To start, why is this called "reset" ... what exactly are we re-setting? Was
there something wrong with calling it "resize" or "reshape"??

-  restoreStateAfterClear();
-
-  contextGL()->BindTexture(

[ccameron, 2016/10/09 21:10:53]

Note that we already have the helper function
WebGLRenderingContextBase::restoreCurrentTexture2D to do this!

AND we have the DrawingBuffer helper function
DrawingBuffer::restoreTextureBindings to do this, too!

And yet we call neither of them, and re-roll it here!!

-      GL_TEXTURE_2D,
-      objectOrZero(
-          m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
-  contextGL()->BindRenderbuffer(GL_RENDERBUFFER,

[ccameron, 2016/10/09 21:10:54]

This line is also precious, because we track the current renderbuffer binding in
DrawingBuffer (as DrawingBuffer::m_renderbufferBinding), but we never have any
methods that use that variable! We're tracking the state for fun in
DrawingBuffer, and restoring it explicitly  here!

-                                objectOrZero(m_renderbufferBinding.get()));
-  drawingBuffer()->restoreFramebufferBindings();

[ccameron, 2016/10/09 21:10:53]

We already have a method WebGLRenderingContextBase::restoreCurrentFramebuffer to
do EXACTLY this... why are we implementing it in DrawingBuffer and then calling
that????

-  drawingBuffer()->restorePixelUnpackBufferBindings();
+  drawingBuffer()->resize(IntSize(width, height));
 }
 
 int WebGLRenderingContextBase::drawingBufferWidth() const {
   return isContextLost() ? 0 : drawingBuffer()->size().width();
 }
 
 int WebGLRenderingContextBase::drawingBufferHeight() const {
   return isContextLost() ? 0 : drawingBuffer()->size().height();
 }
 
 void WebGLRenderingContextBase::activeTexture(GLenum texture) {
   if (isContextLost())
     return;
   if (texture - GL_TEXTURE0 >= m_textureUnits.size()) {
     synthesizeGLError(GL_INVALID_ENUM, "activeTexture",
                       "texture unit out of range");
     return;
   }
   m_activeTextureUnit = texture - GL_TEXTURE0;
   contextGL()->ActiveTexture(texture);
-
-  drawingBuffer()->setActiveTextureUnit(texture);
 }
 
 void WebGLRenderingContextBase::attachShader(WebGLProgram* program,
                                              WebGLShader* shader) {
   if (isContextLost() || !validateWebGLObject("attachShader", program) ||
       !validateWebGLObject("attachShader", shader))
     return;
   if (!program->attachShader(shader)) {
     synthesizeGLError(GL_INVALID_OPERATION, "attachShader",
                       "shader attachment already has shader");
@@ skipping 71 matching lines @@
   bool deleted;
   if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
     return;
   if (deleted) {
     synthesizeGLError(GL_INVALID_OPERATION, "bindBuffer",
                       "attempt to bind a deleted buffer");
     return;
   }
   if (!validateAndUpdateBufferBindTarget("bindBuffer", target, buffer))
     return;
-
-  if (target == GL_PIXEL_UNPACK_BUFFER) {
-    drawingBuffer()->setPixelUnpackBufferBinding(objectOrZero(buffer));
-  }
   contextGL()->BindBuffer(target, objectOrZero(buffer));
 }
 
 void WebGLRenderingContextBase::bindFramebuffer(GLenum target,
                                                 WebGLFramebuffer* buffer) {
   bool deleted;
   if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
     return;
   if (deleted) {
     synthesizeGLError(GL_INVALID_OPERATION, "bindFramebuffer",
@@ skipping 19 matching lines @@
     synthesizeGLError(GL_INVALID_OPERATION, "bindRenderbuffer",
                       "attempt to bind a deleted renderbuffer");
     return;
   }
   if (target != GL_RENDERBUFFER) {
     synthesizeGLError(GL_INVALID_ENUM, "bindRenderbuffer", "invalid target");
     return;
   }
   m_renderbufferBinding = renderBuffer;
   contextGL()->BindRenderbuffer(target, objectOrZero(renderBuffer));
-
-  drawingBuffer()->setRenderbufferBinding(objectOrZero(renderBuffer));
-
   if (renderBuffer)
     renderBuffer->setHasEverBeenBound();
 }
 
 void WebGLRenderingContextBase::bindTexture(GLenum target,
                                             WebGLTexture* texture) {
   bool deleted;
   if (!checkObjectToBeBound("bindTexture", texture, deleted))
     return;
   if (deleted) {
     synthesizeGLError(GL_INVALID_OPERATION, "bindTexture",
                       "attempt to bind a deleted texture");
     return;
   }
   if (texture && texture->getTarget() && texture->getTarget() != target) {
     synthesizeGLError(GL_INVALID_OPERATION, "bindTexture",
                       "textures can not be used with multiple targets");
     return;
   }
 
   if (target == GL_TEXTURE_2D) {
     m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
-
-    if (!m_activeTextureUnit)
-      drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
   } else if (target == GL_TEXTURE_CUBE_MAP) {
     m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
   } else if (isWebGL2OrHigher() && target == GL_TEXTURE_2D_ARRAY) {
     m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding = texture;
   } else if (isWebGL2OrHigher() && target == GL_TEXTURE_3D) {
     m_textureUnits[m_activeTextureUnit].m_texture3DBinding = texture;
   } else {
     synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
     return;
   }
@@ skipping 241 matching lines @@
   if (std::isnan(g))
     g = 0;
   if (std::isnan(b))
     b = 0;
   if (std::isnan(a))
     a = 1;
   m_clearColor[0] = r;
   m_clearColor[1] = g;
   m_clearColor[2] = b;
   m_clearColor[3] = a;
-  drawingBuffer()->setClearColor(m_clearColor);
   contextGL()->ClearColor(r, g, b, a);
 }
 
 void WebGLRenderingContextBase::clearDepth(GLfloat depth) {
   if (isContextLost())
     return;
   m_clearDepth = depth;
   contextGL()->ClearDepthf(depth);
 }
 
 void WebGLRenderingContextBase::clearStencil(GLint s) {
   if (isContextLost())
     return;
   m_clearStencil = s;
   contextGL()->ClearStencil(s);
 }
 
 void WebGLRenderingContextBase::colorMask(GLboolean red,
                                           GLboolean green,
                                           GLboolean blue,
                                           GLboolean alpha) {
   if (isContextLost())
     return;
   m_colorMask[0] = red;
   m_colorMask[1] = green;
   m_colorMask[2] = blue;
   m_colorMask[3] = alpha;
-  drawingBuffer()->setColorMask(m_colorMask);
   contextGL()->ColorMask(red, green, blue, alpha);
 }
 
 void WebGLRenderingContextBase::compileShader(WebGLShader* shader) {
   if (isContextLost() || !validateWebGLObject("compileShader", shader))
     return;
   contextGL()->CompileShader(objectOrZero(shader));
 }
 
 void WebGLRenderingContextBase::compressedTexImage2D(GLenum target,
@@ skipping 190 matching lines @@
   }
   if (object->hasObject()) {
     // We need to pass in context here because we want
     // things in this context unbound.
     object->deleteObject(contextGL());
   }
   return true;
 }
 
 void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer) {
-  GLuint bufferName = objectOrZero(buffer);
   if (!deleteObject(buffer))
     return;
-  drawingBuffer()->notifyBufferDeleted(bufferName);
   removeBoundBuffer(buffer);
 }
 
 void WebGLRenderingContextBase::deleteFramebuffer(
     WebGLFramebuffer* framebuffer) {
   if (!deleteObject(framebuffer))
     return;
   if (framebuffer == m_framebufferBinding) {
     m_framebufferBinding = nullptr;
-    drawingBuffer()->setFramebufferBinding(GL_FRAMEBUFFER, 0);
     // Have to call drawingBuffer()->bind() here to bind back to internal fbo.
     drawingBuffer()->bind(GL_FRAMEBUFFER);
   }
 }
 
 void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program) {
   deleteObject(program);
   // We don't reset m_currentProgram to 0 here because the deletion of the
   // current program is delayed.
 }
 
 void WebGLRenderingContextBase::deleteRenderbuffer(
     WebGLRenderbuffer* renderbuffer) {
   if (!deleteObject(renderbuffer))
     return;
   if (renderbuffer == m_renderbufferBinding) {
     m_renderbufferBinding = nullptr;
-    drawingBuffer()->setRenderbufferBinding(0);
   }
   if (m_framebufferBinding)
     m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GL_FRAMEBUFFER,
                                                                renderbuffer);
   if (getFramebufferBinding(GL_READ_FRAMEBUFFER))
     getFramebufferBinding(GL_READ_FRAMEBUFFER)
         ->removeAttachmentFromBoundFramebuffer(GL_READ_FRAMEBUFFER,
                                                renderbuffer);
 }
 
 void WebGLRenderingContextBase::deleteShader(WebGLShader* shader) {
   deleteObject(shader);
 }
 
 void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture) {
   if (!deleteObject(texture))
     return;
 
   int maxBoundTextureIndex = -1;
   for (size_t i = 0; i < m_onePlusMaxNonDefaultTextureUnit; ++i) {
     if (texture == m_textureUnits[i].m_texture2DBinding) {
       m_textureUnits[i].m_texture2DBinding = nullptr;
       maxBoundTextureIndex = i;
-      if (!i)
-        drawingBuffer()->setTexture2DBinding(0);
     }
     if (texture == m_textureUnits[i].m_textureCubeMapBinding) {
       m_textureUnits[i].m_textureCubeMapBinding = nullptr;
       maxBoundTextureIndex = i;
     }
     if (isWebGL2OrHigher()) {
       if (texture == m_textureUnits[i].m_texture3DBinding) {
         m_textureUnits[i].m_texture3DBinding = nullptr;
         maxBoundTextureIndex = i;
       }
@@ skipping 57 matching lines @@
 }
 
 void WebGLRenderingContextBase::disable(GLenum cap) {
   if (isContextLost() || !validateCapability("disable", cap))
     return;
   if (cap == GL_STENCIL_TEST) {
     m_stencilEnabled = false;
     applyStencilTest();
     return;
   }
-  if (cap == GL_SCISSOR_TEST) {
+  if (cap == GL_SCISSOR_TEST)
     m_scissorEnabled = false;
-    drawingBuffer()->setScissorEnabled(m_scissorEnabled);
-  }
   contextGL()->Disable(cap);
 }
 
 void WebGLRenderingContextBase::disableVertexAttribArray(GLuint index) {
   if (isContextLost())
     return;
   if (index >= m_maxVertexAttribs) {
     synthesizeGLError(GL_INVALID_VALUE, "disableVertexAttribArray",
                       "index out of range");
     return;
@@ skipping 115 matching lines @@
 }
 
 void WebGLRenderingContextBase::enable(GLenum cap) {
   if (isContextLost() || !validateCapability("enable", cap))
     return;
   if (cap == GL_STENCIL_TEST) {
     m_stencilEnabled = true;
     applyStencilTest();
     return;
   }
-  if (cap == GL_SCISSOR_TEST) {
+  if (cap == GL_SCISSOR_TEST)
     m_scissorEnabled = true;
-    drawingBuffer()->setScissorEnabled(m_scissorEnabled);
-  }
   contextGL()->Enable(cap);
 }
 
 void WebGLRenderingContextBase::enableVertexAttribArray(GLuint index) {
   if (isContextLost())
     return;
   if (index >= m_maxVertexAttribs) {
     synthesizeGLError(GL_INVALID_VALUE, "enableVertexAttribArray",
                       "index out of range");
     return;
@@ skipping 1380 matching lines @@
             GL_INVALID_VALUE, "pixelStorei",
             "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");
         return;
       }
       break;
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
       if (param == 1 || param == 2 || param == 4 || param == 8) {
         if (pname == GL_PACK_ALIGNMENT) {
           m_packAlignment = param;
-          drawingBuffer()->setPackAlignment(param);
         } else {  // GL_UNPACK_ALIGNMENT:
           m_unpackAlignment = param;
         }
         contextGL()->PixelStorei(pname, param);
       } else {
         synthesizeGLError(GL_INVALID_VALUE, "pixelStorei",
                           "invalid parameter for alignment");
         return;
       }
       break;
@@ skipping 1998 matching lines @@
 void WebGLRenderingContextBase::loseContextImpl(
     WebGLRenderingContextBase::LostContextMode mode,
     AutoRecoveryMethod autoRecoveryMethod) {
   if (isContextLost())
     return;
 
   m_contextLostMode = mode;
   ASSERT(m_contextLostMode != NotLostContext);
   m_autoRecoveryMethod = autoRecoveryMethod;
 
-  // Make absolutely sure we do not refer to an already-deleted texture or
-  // framebuffer.
-  drawingBuffer()->setTexture2DBinding(0);
-  drawingBuffer()->setFramebufferBinding(GL_FRAMEBUFFER, 0);
-  drawingBuffer()->setRenderbufferBinding(0);
-
   detachAndRemoveAllObjects();
 
   // Lose all the extensions.
   for (size_t i = 0; i < m_extensions.size(); ++i) {
     ExtensionTracker* tracker = m_extensions[i];
     tracker->loseExtension(false);
   }
 
   for (size_t i = 0; i < WebGLExtensionNameCount; ++i)
     m_extensionEnabled[i] = false;
@@ skipping 136 matching lines @@
   }
 }
 
 void WebGLRenderingContextBase::stop() {
   if (!isContextLost()) {
     // Never attempt to restore the context because the page is being torn down.
     forceLostContext(SyntheticLostContext, Manual);
   }
 }
 
+bool WebGLRenderingContextBase::DrawingBufferClientIsBoundForDraw() {
+  return !m_framebufferBinding;
+}
+
+void WebGLRenderingContextBase::DrawingBufferClientRestoreScissorTest() {
+  if (m_scissorEnabled)
+    contextGL()->Enable(GL_SCISSOR_TEST);
+  else
+    contextGL()->Disable(GL_SCISSOR_TEST);
+}
+
+void WebGLRenderingContextBase::DrawingBufferClientRestoreMaskAndClearValues() {
+  contextGL()->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2],
+                         m_colorMask[3]);
+  contextGL()->DepthMask(m_depthMask);
+  contextGL()->StencilMaskSeparate(GL_FRONT, m_stencilMask);
+
+  contextGL()->ClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2],
+                          m_clearColor[3]);
+  contextGL()->ClearDepthf(m_clearDepth);
+  contextGL()->ClearStencil(m_clearStencil);
+}
+
+void WebGLRenderingContextBase::DrawingBufferClientRestorePixelPackAlignment() {
+  contextGL()->PixelStorei(GL_PACK_ALIGNMENT, m_packAlignment);
+}
+
+void WebGLRenderingContextBase::DrawingBufferClientRestoreTexture2DBinding() {
+  if (m_activeTextureUnit < m_textureUnits.size()) {
+    contextGL()->BindTexture(
+        GL_TEXTURE_2D,
+        objectOrZero(
+            m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
+  }
+}
+
+void WebGLRenderingContextBase::
+    DrawingBufferClientRestoreRenderbufferBinding() {
+  contextGL()->BindRenderbuffer(GL_RENDERBUFFER,
+                                objectOrZero(m_renderbufferBinding.get()));
+}
+
+void WebGLRenderingContextBase::DrawingBufferClientRestoreFramebufferBinding() {
+  contextGL()->BindFramebuffer(GL_FRAMEBUFFER,
+                               objectOrZero(m_framebufferBinding.get()));
+}
+
+void WebGLRenderingContextBase::
+    DrawingBufferClientRestorePixelUnpackBufferBinding() {}
+
 ScriptValue WebGLRenderingContextBase::getBooleanParameter(
     ScriptState* scriptState,
     GLenum pname) {
   GLboolean value = 0;
   if (!isContextLost())
     contextGL()->GetBooleanv(pname, &value);
   return WebGLAny(scriptState, static_cast<bool>(value));
 }
 
 ScriptValue WebGLRenderingContextBase::getBooleanArrayParameter(
@@ skipping 1273 matching lines @@
 
 void WebGLRenderingContextBase::setFramebuffer(GLenum target,
                                                WebGLFramebuffer* buffer) {
   if (buffer)
     buffer->setHasEverBeenBound();
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) {
     m_framebufferBinding = buffer;
     applyStencilTest();
   }
-  drawingBuffer()->setFramebufferBinding(
-      target, objectOrZero(getFramebufferBinding(target)));
-
   if (!buffer) {
     // Instead of binding fb 0, bind the drawing buffer.
     drawingBuffer()->bind(target);
   } else {
     contextGL()->BindFramebuffer(target, buffer->object());
   }
 }
 
 void WebGLRenderingContextBase::restoreCurrentFramebuffer() {
   bindFramebuffer(GL_FRAMEBUFFER, m_framebufferBinding.get());
@@ skipping 105 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink