Remove blink side texture status caching.

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 "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 787 matching lines @@
             synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid 2D target");
             return false;
         }
     } else {
         if (target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY) {
             synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid 3D target");
             return false;
         }
     }
 
-    WebGLTexture* tex = validateTextureBinding(functionName, target, false);
-    if (!tex)
-        return false;
-
     if (functionType == TexStorageType3D && target != GL_TEXTURE_2D_ARRAY && m_compressedTextureFormatsETC2EAC.find(internalformat) != m_compressedTextureFormatsETC2EAC.end()) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "target for ETC2/EAC internal formats must be TEXTURE_2D_ARRAY");
         return false;
     }
 
     if (m_supportedInternalFormatsStorage.find(internalformat) == m_supportedInternalFormatsStorage.end()) {
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid internalformat");
         return false;
     }
 
-    if (tex->isImmutable()) {
-        synthesizeGLError(GL_INVALID_OPERATION, functionName, "attempted to modify immutable texture");
-        return false;
-    }
-
     if (width <= 0 || height <= 0 || depth <= 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid dimensions");
         return false;
     }
 
     if (levels <= 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid levels");
         return false;
     }
 
@@ skipping 10 matching lines @@
     }
 
     return true;
 }
 
 void WebGL2RenderingContextBase::texStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
     if (isContextLost() || !validateTexStorage("texStorage2D", target, levels, internalformat, width, height, 1, TexStorageType2D))
         return;
 
-    WebGLTexture* tex = validateTextureBinding("texStorage2D", target, false);
     webContext()->texStorage2DEXT(target, levels, internalformat, width, height);
-    tex->setTexStorageInfo(target, levels, internalformat, width, height, 1);
 }
 
 void WebGL2RenderingContextBase::texStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
     if (isContextLost() || !validateTexStorage("texStorage3D", target, levels, internalformat, width, height, depth, TexStorageType3D))
         return;
 
-    WebGLTexture* tex = validateTextureBinding("texStorage3D", target, false);
     webContext()->texStorage3D(target, levels, internalformat, width, height, depth);
-    tex->setTexStorageInfo(target, levels, internalformat, width, height, depth);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost() || !validateTexFunc3DTarget("texImage3D", target)
         || !validateTexFunc("texImage3D", TexImage, SourceArrayBufferView, target, level, internalformat, width, height, depth, border, format, type, 0, 0, 0)
         || !validateTexFuncData("texImage3D", level, width, height, depth, format, type, pixels, NullAllowed))
         return;
 
     void* data = pixels ? pixels->baseAddress() : 0;
     Vector<uint8_t> tempData;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         // FIXME: WebGLImageConversion needs to be updated to accept image depth.
         notImplemented();
         return;
     }
 
-    WebGLTexture* tex = validateTextureBinding("texImage3D", target, true);
-    ASSERT(tex);
     webContext()->texImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, data);
-    tex->setLevelInfo(target, level, internalformat, width, height, depth, type);
 }
 
 void WebGL2RenderingContextBase::texSubImage3DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, Image* image, WebGLImageConversion::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     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;
@@ skipping 94 matching lines @@
     texSubImage3DImpl(target, level, xoffset, yoffset, zoffset, format, type, imageForRender.get(), WebGLImageConversion::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLCanvasElement* canvas, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateHTMLCanvasElement("texSubImage3D", canvas, exceptionState)
         || !validateTexFunc3DTarget("texSubImage3D", target)
         || !validateTexFunc("texSubImage3D", TexSubImage, SourceHTMLCanvasElement, target, level, 0, canvas->width(), canvas->height(), 1, 0, format, type, xoffset, yoffset, zoffset))
         return;
 
-    WebGLTexture* texture = validateTextureBinding("texSubImage3D", target, false);
-    ASSERT(texture);
-    GLenum internalformat = texture->getInternalFormat(target, level);
-
-    if (!canvas->renderingContext() || !canvas->renderingContext()->isAccelerated() || !canUseTexImageCanvasByGPU(internalformat, type)) {
-        // 2D canvas has only FrontBuffer.
-        texSubImage3DImpl(target, level, xoffset, yoffset, zoffset, format, type, canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
-            WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
-        return;
-    }
-
-    texImageCanvasByGPU(TexSubImage3DByGPU, texture, target, level, GL_RGBA, type, xoffset, yoffset, zoffset, canvas);
+    // FIXME: Implement GPU-to-GPU copy path.

[Ken Russell (switch to Gerrit), 2016/02/11 01:25:01]

Could you provide more details about exactly what's been removed, or is
otherwise unknown, after this patch? That way others could possibly contribute
to putting back in the GPU-to-GPU copy path.

[Zhenyao Mo, 2016/02/11 02:16:46]

Sure, I'll create a bug with more details.  But let me land as is now to avoid
rebasing.  I'll update with the bug ID in a followup CL.

+    texSubImage3DImpl(target, level, xoffset, yoffset, zoffset, format, type, canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
+        WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLVideoElement* video, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateHTMLVideoElement("texSubImage3D", video, exceptionState)
         || !validateTexFunc3DTarget("texSubImage3D", target)
         || !validateTexFunc("texSubImage3D", TexSubImage, SourceHTMLVideoElement, target, level, 0, video->videoWidth(), video->videoHeight(), 1, 0, format, type, xoffset, yoffset, zoffset))
         return;
 
     RefPtr<Image> image = videoFrameToImage(video);
@@ skipping 16 matching lines @@
 
 void WebGL2RenderingContextBase::copyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
     WebGLFramebuffer* readFramebufferBinding = nullptr;
     if (!validateCopyTexSubImage("copyTexSubImage3D", target, level, xoffset, yoffset, zoffset, x, y, width, height))
         return;
     if (!validateReadBufferAndGetInfo("copyTexSubImage3D", readFramebufferBinding))
         return;
-    WebGLTexture* tex = validateTextureBinding("copyTexSubImage3D", target, true);
-    ASSERT(tex);
-    if (!isTexInternalFormatColorBufferCombinationValid(tex->getInternalFormat(target, level), boundFramebufferColorFormat())) {
-        synthesizeGLError(GL_INVALID_OPERATION, "copyTexSubImage3D", "framebuffer is incompatible format");
-        return;
-    }
     clearIfComposited();
     ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
     webContext()->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, DOMArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFunc3DTarget("compressedTexImage3D", target))
         return;
     if (!validateTexFuncLevel("compressedTexImage3D", target, level))
         return;
     if (!validateCompressedTexFormat("compressedTexImage3D", internalformat))
         return;
     if (border) {
         synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D", "border not 0");
         return;
     }
     if (!validateCompressedTexDimensions("compressedTexImage3D", CompressedTexImage, target, level, width, height, depth, internalformat))
         return;
     if (!validateCompressedTexFuncData("compressedTexImage3D", width, height, depth, internalformat, data))
         return;
 
-    WebGLTexture* tex = validateTextureBinding("compressedTexImage3D", target, true);
-    if (!tex)
-        return;
-    if (tex->isImmutable()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "compressedTexImage3D", "attempted to modify immutable texture");
-        return;
-    }
-
     webContext()->compressedTexImage3D(target, level, internalformat, width, height, depth, border, data->byteLength(), data->baseAddress());
-    tex->setLevelInfo(target, level, internalformat, width, height, depth, GL_UNSIGNED_BYTE);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, DOMArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFunc3DTarget("compressedTexSubImage3D", target))
         return;
     WebGLTexture* tex = validateTextureBinding("compressedTexSubImage3D", target, true);
     if (!tex)
         return;
     if (!validateTexFuncLevel("compressedTexSubImage3D", target, level))
         return;
     if (!validateCompressedTexFormat("compressedTexSubImage3D", format))
         return;
-    if (format != tex->getInternalFormat(target, level)) {
-        synthesizeGLError(GL_INVALID_OPERATION, "compressedTexSubImage3D", "format does not match texture format");
-        return;
-    }
     if (!validateCompressedTexSubDimensions("compressedTexSubImage3D", target, level, xoffset, yoffset, zoffset, width, height, depth, format, tex))
         return;
     if (!validateCompressedTexFuncData("compressedTexSubImage3D", width, height, depth, format, data))
         return;
     webContext()->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset,
         width, height, depth, format, data->byteLength(), data->baseAddress());
 }
 
 GLint WebGL2RenderingContextBase::getFragDataLocation(WebGLProgram* program, const String& name)
 {
@@ skipping 2336 matching lines @@
 
     WebGLRenderingContextBase::removeBoundBuffer(buffer);
 }
 
 void WebGL2RenderingContextBase::restoreCurrentFramebuffer()
 {
     bindFramebuffer(nullptr, GL_DRAW_FRAMEBUFFER, m_framebufferBinding.get());
     bindFramebuffer(nullptr, GL_READ_FRAMEBUFFER, m_readFramebufferBinding.get());
 }
 
-GLenum WebGL2RenderingContextBase::boundFramebufferColorFormat()
-{
-    if (m_readFramebufferBinding && m_readFramebufferBinding->object())
-        return m_readFramebufferBinding->colorBufferFormat();
-    if (m_requestedAttributes.alpha())
-        return GL_RGBA;
-    return GL_RGB;
-}
-
 const WebGLSamplerState* WebGL2RenderingContextBase::getTextureUnitSamplerState(GLenum target, GLuint unit) const
 {
     ASSERT(unit < m_samplerUnits.size());
 
     WebGLSampler* sampler = m_samplerUnits[unit];
 
     if (sampler)
         return sampler->getSamplerState();
 
     return WebGLRenderingContextBase::getTextureUnitSamplerState(target, unit);
@@ skipping 15 matching lines @@
     params.alignment = m_unpackAlignment;
     params.rowLength = m_unpackRowLength;
     params.imageHeight = m_unpackImageHeight;
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     params.skipImages = m_unpackSkipImages;
     return params;
 }
 
 } // namespace blink