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;
 
+    contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);

[Zhenyao Mo, 2016/09/09 18:58:04]

You can't do this in WebGL1 because if it's implemented on top of ES2, then
PIXEL_UNPACK_BUFFER is invalid enum

Here and all other places.

[Kai Ninomiya, 2016/09/09 20:30:44]

Done.

+
     // 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 4443 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid usage");
         return false;
     }
 }
 
 void WebGLRenderingContextBase::removeBoundBuffer(WebGLBuffer* buffer)
 {
     if (m_boundArrayBuffer == buffer)
         m_boundArrayBuffer = nullptr;
 
+    drawingBuffer()->notifyBufferDeleted(objectOrZero(buffer));
     m_boundVertexArrayObject->unbindBuffer(buffer);
 }
 
 bool WebGLRenderingContextBase::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (!image || !image->cachedImage()) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no image");
         return false;
     }
     const KURL& url = image->cachedImage()->response().url();
@@ skipping 441 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink