Save/restore PBO bindings in DrawingBuffer

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 1370 matching lines @@
     return ImageData::create(
         IntSize(width, height),
         DOMUint8ClampedArray::create(imageDataPixels, 0, imageDataPixels->byteLength()));
 }
 
 void WebGLRenderingContextBase::reshape(int width, int height)
 {
     if (isContextLost())
         return;
 
+    if (isWebGL2OrHigher()) {
+        contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    }
+
     // This is an approximation because at WebGLRenderingContextBase level we don't
     // know if the underlying FBO uses textures or renderbuffers.
     GLint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
     GLint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
     GLint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
     width = clamp(width, 1, maxWidth);
     height = clamp(height, 1, maxHeight);
 
     // Limit drawing buffer area to 4k*4k to avoid memory exhaustion. Width or height may be larger than
     // 4k as long as it's within the max viewport dimensions and total area remains within the limit.
     // For example: 5120x2880 should be fine.
     const int maxArea = 4096 * 4096;
     int currentArea = width * height;
     if (currentArea > maxArea) {
         // 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));
     restoreStateAfterClear();
 
     contextGL()->BindTexture(GL_TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
     contextGL()->BindRenderbuffer(GL_RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
     drawingBuffer()->restoreFramebufferBindings();
+    drawingBuffer()->restorePixelUnpackBufferBindings();
 }
 
 int WebGLRenderingContextBase::drawingBufferWidth() const
 {
     return isContextLost() ? 0 : drawingBuffer()->size().width();
 }
 
 int WebGLRenderingContextBase::drawingBufferHeight() const
 {
     return isContextLost() ? 0 : drawingBuffer()->size().height();
@@ skipping 84 matching lines @@
 void WebGLRenderingContextBase::bindBuffer(GLenum target, WebGLBuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     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)
@@ skipping 490 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);
@@ skipping 4392 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink