Upgrade PixelStorei to ES3/WebGL2.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 145 matching lines @@
     webContext()->getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
     m_boundIndexedTransformFeedbackBuffers.clear();
     m_boundIndexedTransformFeedbackBuffers.resize(maxTransformFeedbackSeparateAttribs);
 
     GLint maxUniformBufferBindings = 0;
     webContext()->getIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
     m_boundIndexedUniformBuffers.clear();
     m_boundIndexedUniformBuffers.resize(maxUniformBufferBindings);
     m_maxBoundUniformBufferIndex = 0;
 
+    m_packRowLength = 0;
+    m_packSkipPixels = 0;
+    m_packSkipRows = 0;
+    m_unpackRowLength = 0;
+    m_unpackImageHeight = 0;
+    m_unpackSkipPixels = 0;
+    m_unpackSkipRows = 0;
+    m_unpackSkipImages = 0;
+
     WebGLRenderingContextBase::initializeNewContext();
 }
 
 void WebGL2RenderingContextBase::copyBufferSubData(GLenum readTarget, GLenum writeTarget, long long readOffset, long long writeOffset, long long size)
 {
     if (isContextLost())
         return;
 
     if (!validateValueFitNonNegInt32("copyBufferSubData", "readOffset", readOffset)
         || !validateValueFitNonNegInt32("copyBufferSubData", "writeOffset", writeOffset)
@@ skipping 266 matching lines @@
     } else {
         if (mode == GL_BACK) {
             synthesizeGLError(GL_INVALID_OPERATION, "readBuffer", "invalid read buffer");
             return;
         }
         readFramebufferBinding->readBuffer(mode);
     }
     webContext()->readBuffer(mode);
 }
 
+void WebGL2RenderingContextBase::pixelStorei(GLenum pname, GLint param)
+{
+    if (isContextLost())
+        return;
+    switch (pname) {
+    case GL_PACK_ROW_LENGTH:
+        m_packRowLength = param;
+        break;
+    case GL_PACK_SKIP_PIXELS:
+        m_packSkipPixels = param;
+        break;
+    case GL_PACK_SKIP_ROWS:
+        m_packSkipRows = param;
+        break;
+    case GL_UNPACK_ROW_LENGTH:
+        m_unpackRowLength = param;
+        break;
+    case GL_UNPACK_IMAGE_HEIGHT:
+        m_unpackImageHeight = param;
+        break;
+    case GL_UNPACK_SKIP_PIXELS:
+        m_unpackSkipPixels = param;
+        break;
+    case GL_UNPACK_SKIP_ROWS:
+        m_unpackSkipRows = param;
+        break;
+    case GL_UNPACK_SKIP_IMAGES:
+        m_unpackSkipImages = param;
+        break;
+    default:
+        WebGLRenderingContextBase::pixelStorei(pname, param);
+        return;
+    }
+    webContext()->pixelStorei(pname, param);
+}
+
 void WebGL2RenderingContextBase::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     if (m_boundPixelPackBuffer.get()) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "PIXEL_PACK buffer should not be bound");
         return;
     }
 
     WebGLRenderingContextBase::readPixels(x, y, width, height, format, type, pixels);
@@ skipping 136 matching lines @@
     if (!validateSize("renderbufferStorage", width, height))
         return;
     if (samples < 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "samples < 0");
         return;
     }
     renderbufferStorageImpl(target, samples, internalformat, width, height, functionName);
     applyStencilTest();
 }
 
+void WebGL2RenderingContextBase::resetUnpackParameters()
+{
+    if (m_unpackAlignment != 1)
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    if (!m_unpackRowLength)
+        webContext()->pixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    if (!m_unpackImageHeight)
+        webContext()->pixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
+    if (!m_unpackSkipPixels)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    if (!m_unpackSkipRows)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    if (!m_unpackSkipImages)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
+}
+
+void WebGL2RenderingContextBase::restoreUnpackParameters()
+{
+    if (m_unpackAlignment != 1)
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+    if (!m_unpackRowLength)
+        webContext()->pixelStorei(GL_UNPACK_ROW_LENGTH, m_unpackRowLength);
+    if (!m_unpackImageHeight)
+        webContext()->pixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_unpackImageHeight);
+    if (!m_unpackSkipPixels)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_PIXELS, m_unpackSkipPixels);
+    if (!m_unpackSkipRows)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_ROWS, m_unpackSkipRows);
+    if (!m_unpackSkipImages)
+        webContext()->pixelStorei(GL_UNPACK_SKIP_IMAGES, m_unpackSkipImages);
+}
+
 /* Texture objects */
 bool WebGL2RenderingContextBase::validateTexStorage(const char* functionName, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, TexStorageType functionType)
 {
     if (functionType == TexStorageType2D) {
         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP) {
             synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid 2D target");
             return false;
         }
     } else {
         if (target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY) {
@@ skipping 175 matching lines @@
     bool needConversion = true;
     if (type == GL_UNSIGNED_BYTE && sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 && format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing && !flipY) {
         needConversion = false;
     } else {
         if (!WebGLImageConversion::packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "bad image data");
             return;
         }
     }
 
-    if (m_unpackAlignment != 1)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    resetUnpackParameters();

[bajones, 2015/11/25 00:03:05]

There are several similar bits of code in WebGLRenderingContextBase, and it
seems like with WebGL2 they'll want to reset the full set of unpack params as
well. I think reset/restoreUnpackParameters should be a virtual method defined
by WebGLRenderingContextBase that only resets the unpack alignment, and then is
overridden in WebGL2 with the logic you have here.

[Ken Russell (switch to Gerrit), 2015/11/25 00:59:41]

Agree with this. It looks like WebGLRenderingContextBase will assume at least
that GL_ROW_WIDTH is reset to the default. Hopefully the already ported dEQP
tests will cover these code paths well.

[Zhenyao Mo, 2015/11/25 18:18:48]

Done.

     webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 1, format, type, needConversion ? data.data() : imagePixelData);
-    if (m_unpackAlignment != 1)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+    restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost() || !pixels || !validateTexSubImage3D("texSubImage3D", target, level, xoffset, yoffset, zoffset, format, type, width, height, depth)
         || !validateTexFuncData("texSubImage3D", level, width, height, format, type, pixels, NullAllowed))
         return;
 
     // FIXME: Ensure pixels is large enough to contain the desired texture dimensions.
 
     void* data = pixels->baseAddress();
     Vector<uint8_t> tempData;
-    bool changeUnpackAlignment = false;
+    bool changeUnpackParameters = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
-        if (!WebGLImageConversion::extractTextureData(width, height, format, type,
-            m_unpackAlignment,
-            m_unpackFlipY, m_unpackPremultiplyAlpha,
-            data,
-            tempData))
-            return;
-        data = tempData.data();
-        changeUnpackAlignment = true;
+        // FIXME: WebGLImageConversion needs to be updated to accept image depth.
+        notImplemented();
+        changeUnpackParameters = true;
     }
-    if (changeUnpackAlignment)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    if (changeUnpackParameters)
+        resetUnpackParameters();
     webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
-    if (changeUnpackAlignment)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+    if (changeUnpackParameters)
+        restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, ImageData* pixels)
 {
     if (isContextLost() || !pixels || !validateTexSubImage3D("texSubImage3D", target, level, xoffset, yoffset, zoffset, format, type, pixels->width(), pixels->height(), 1))
         return;
 
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
         // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
         type = GL_FLOAT;
     }
     Vector<uint8_t> data;
     bool needConversion = true;
     // The data from ImageData is always of format RGBA8.
     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
     if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha) {
         needConversion = false;
     } else {
         if (!WebGLImageConversion::extractImageData(pixels->data()->data(), pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "bad image data");
             return;
         }
     }
-    if (m_unpackAlignment != 1)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    resetUnpackParameters();
     webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, pixels->width(), pixels->height(), 1, format, type, needConversion ? data.data() : pixels->data()->data());
-    if (m_unpackAlignment != 1)
-        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+    restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (isContextLost() || !image || !validateHTMLImageElement("texSubImage3D", image, exceptionState))
         return;
 
     RefPtr<Image> imageForRender = image->cachedImage()->image();
     if (imageForRender->isSVGImage())
         imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), "texSubImage3D");
@@ skipping 1574 matching lines @@
         return getBooleanParameter(scriptState, pname);
     case GL_UNIFORM_BUFFER_BINDING:
         return WebGLAny(scriptState, m_boundUniformBuffer.get());
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_IMAGE_HEIGHT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_ROW_LENGTH:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_IMAGES:
-        return getBooleanParameter(scriptState, pname);
+        return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_PIXELS:
-        return getBooleanParameter(scriptState, pname);
+        return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_ROWS:
-        return getBooleanParameter(scriptState, pname);
+        return getIntParameter(scriptState, pname);
 
     default:
         return WebGLRenderingContextBase::getParameter(scriptState, pname);
     }
 }
 
 ScriptValue WebGL2RenderingContextBase::getInt64Parameter(ScriptState* scriptState, GLenum pname)
 {
     GLint64 value = 0;
     if (!isContextLost())
@@ skipping 652 matching lines @@
 GLenum WebGL2RenderingContextBase::boundFramebufferColorFormat()
 {
     if (m_readFramebufferBinding && m_readFramebufferBinding->object())
         return m_readFramebufferBinding->colorBufferFormat();
     if (m_requestedAttributes.alpha())
         return GL_RGBA;
     return GL_RGB;
 }
 
 } // namespace blink