Make OffscreenCanvas WebGL(2) context consider taintedness of image source

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 1171 matching lines @@
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperImageData(kTexImage2D, target, level, internalformat, 0, format,
                           type, 1, 0, 0, 0, pixels,
                           GetTextureSourceSubRectangle(width, height), 0);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLImageElement* image,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLImageElement(kTexImage2D, target, level, internalformat,
+  TexImageHelperHTMLImageElement(execution_context->GetSecurityOrigin(),
+                                 kTexImage2D, target, level, internalformat,
                                  format, type, 0, 0, 0, image,
                                  GetTextureSourceSubRectangle(width, height), 1,
                                  unpack_image_height_, exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLCanvasElement* canvas,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
+
   TexImageHelperHTMLCanvasElement(
-      kTexImage2D, target, level, internalformat, format, type, 0, 0, 0, canvas,
+      execution_context->GetSecurityOrigin(), kTexImage2D, target, level,
+      internalformat, format, type, 0, 0, 0, canvas,
       GetTextureSourceSubRectangle(width, height), 1, 0, exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLVideoElement* video,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
+
   TexImageHelperHTMLVideoElement(
-      kTexImage2D, target, level, internalformat, format, type, 0, 0, 0, video,
+      execution_context->GetSecurityOrigin(), kTexImage2D, target, level,
+      internalformat, format, type, 0, 0, 0, video,
       GetTextureSourceSubRectangle(width, height), 1, 0, exception_state);
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
@@ skipping 23 matching lines @@
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
                                         type, image_data);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLenum format,
                                             GLenum type,
                                             HTMLImageElement* image,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
-                                        type, image, exception_state);
+
+  WebGLRenderingContextBase::texImage2D(execution_context, target, level,
+                                        internalformat, format, type, image,
+                                        exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLenum format,
                                             GLenum type,
                                             HTMLCanvasElement* canvas,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
-                                        type, canvas, exception_state);
+
+  WebGLRenderingContextBase::texImage2D(execution_context, target, level,
+                                        internalformat, format, type, canvas,
+                                        exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
+void WebGL2RenderingContextBase::texImage2D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLenum format,
                                             GLenum type,
                                             HTMLVideoElement* video,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
-                                        type, video, exception_state);
+
+  WebGLRenderingContextBase::texImage2D(execution_context, target, level,
+                                        internalformat, format, type, video,
+                                        exception_state);
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLenum format,
                                             GLenum type,
                                             ImageBitmap* image_bit_map,
                                             ExceptionState& exception_state) {
   if (isContextLost())
@@ skipping 65 matching lines @@
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperImageData(kTexSubImage2D, target, level, 0, 0, format, type, 1,
                           xoffset, yoffset, 0, pixels,
                           GetTextureSourceSubRectangle(width, height), 0);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     HTMLImageElement* image,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLImageElement(kTexSubImage2D, target, level, 0, format, type,
-                                 xoffset, yoffset, 0, image,
-                                 GetTextureSourceSubRectangle(width, height), 1,
-                                 0, exception_state);
+
+  TexImageHelperHTMLImageElement(
+      execution_context->GetSecurityOrigin(), kTexSubImage2D, target, level, 0,
+      format, type, xoffset, yoffset, 0, image,
+      GetTextureSourceSubRectangle(width, height), 1, 0, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     HTMLCanvasElement* canvas,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLCanvasElement(kTexSubImage2D, target, level, 0, format,
-                                  type, xoffset, yoffset, 0, canvas,
-                                  GetTextureSourceSubRectangle(width, height),
-                                  1, 0, exception_state);
+
+  TexImageHelperHTMLCanvasElement(
+      execution_context->GetSecurityOrigin(), kTexSubImage2D, target, level, 0,
+      format, type, xoffset, yoffset, 0, canvas,
+      GetTextureSourceSubRectangle(width, height), 1, 0, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     HTMLVideoElement* video,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLVideoElement(kTexSubImage2D, target, level, 0, format, type,
-                                 xoffset, yoffset, 0, video,
-                                 GetTextureSourceSubRectangle(width, height), 1,
-                                 0, exception_state);
+
+  TexImageHelperHTMLVideoElement(
+      execution_context->GetSecurityOrigin(), kTexSubImage2D, target, level, 0,
+      format, type, xoffset, yoffset, 0, video,
+      GetTextureSourceSubRectangle(width, height), 1, 0, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
@@ skipping 26 matching lines @@
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texSubImage2D(target, level, xoffset, yoffset,
                                            format, type, pixels);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLenum format,
     GLenum type,
     HTMLImageElement* image,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  WebGLRenderingContextBase::texSubImage2D(
-      target, level, xoffset, yoffset, format, type, image, exception_state);
+
+  WebGLRenderingContextBase::texSubImage2D(execution_context, target, level,
+                                           xoffset, yoffset, format, type,
+                                           image, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLenum format,
     GLenum type,
     HTMLCanvasElement* canvas,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  WebGLRenderingContextBase::texSubImage2D(
-      target, level, xoffset, yoffset, format, type, canvas, exception_state);
+
+  WebGLRenderingContextBase::texSubImage2D(execution_context, target, level,
+                                           xoffset, yoffset, format, type,
+                                           canvas, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLenum format,
     GLenum type,
     HTMLVideoElement* video,
     ExceptionState& exception_state) {
-  WebGLRenderingContextBase::texSubImage2D(
-      target, level, xoffset, yoffset, format, type, video, exception_state);
+  WebGLRenderingContextBase::texSubImage2D(execution_context, target, level,
+                                           xoffset, yoffset, format, type,
+                                           video, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLenum format,
     GLenum type,
     ImageBitmap* bitmap,
@@ skipping 120 matching lines @@
   DCHECK(pixels);
   IntRect source_image_rect;
   source_image_rect.SetLocation(
       IntPoint(unpack_skip_pixels_, unpack_skip_rows_));
   source_image_rect.SetSize(IntSize(width, height));
   TexImageHelperImageData(kTexImage3D, target, level, internalformat, 0, format,
                           type, depth, 0, 0, 0, pixels, source_image_rect,
                           unpack_image_height_);
 }
 
-void WebGL2RenderingContextBase::texImage3D(GLenum target,
+void WebGL2RenderingContextBase::texImage3D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLImageElement* image,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLImageElement(kTexImage3D, target, level, internalformat,
+
+  TexImageHelperHTMLImageElement(execution_context->GetSecurityOrigin(),
+                                 kTexImage3D, target, level, internalformat,
                                  format, type, 0, 0, 0, image,
                                  GetTextureSourceSubRectangle(width, height),
                                  depth, unpack_image_height_, exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage3D(GLenum target,
+void WebGL2RenderingContextBase::texImage3D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLCanvasElement* canvas,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLCanvasElement(kTexImage3D, target, level, internalformat,
+
+  TexImageHelperHTMLCanvasElement(execution_context->GetSecurityOrigin(),
+                                  kTexImage3D, target, level, internalformat,
                                   format, type, 0, 0, 0, canvas,
                                   GetTextureSourceSubRectangle(width, height),
                                   depth, unpack_image_height_, exception_state);
 }
 
-void WebGL2RenderingContextBase::texImage3D(GLenum target,
+void WebGL2RenderingContextBase::texImage3D(ExecutionContext* execution_context,
+                                            GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             HTMLVideoElement* video,
                                             ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLVideoElement(kTexImage3D, target, level, internalformat,
+
+  TexImageHelperHTMLVideoElement(execution_context->GetSecurityOrigin(),
+                                 kTexImage3D, target, level, internalformat,
                                  format, type, 0, 0, 0, video,
                                  GetTextureSourceSubRectangle(width, height),
                                  depth, unpack_image_height_, exception_state);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
@@ skipping 91 matching lines @@
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperImageData(kTexSubImage3D, target, level, 0, 0, format, type,
                           depth, xoffset, yoffset, zoffset, pixels,
                           GetTextureSourceSubRectangle(width, height),
                           unpack_image_height_);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLenum type,
     HTMLImageElement* image,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLImageElement(kTexSubImage3D, target, level, 0, format, type,
+
+  TexImageHelperHTMLImageElement(execution_context->GetSecurityOrigin(),
+                                 kTexSubImage3D, target, level, 0, format, type,
                                  xoffset, yoffset, zoffset, image,
                                  GetTextureSourceSubRectangle(width, height),
                                  depth, unpack_image_height_, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLenum type,
     HTMLCanvasElement* canvas,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLCanvasElement(kTexSubImage3D, target, level, 0, format,
+
+  TexImageHelperHTMLCanvasElement(execution_context->GetSecurityOrigin(),
+                                  kTexSubImage3D, target, level, 0, format,
                                   type, xoffset, yoffset, zoffset, canvas,
                                   GetTextureSourceSubRectangle(width, height),
                                   depth, unpack_image_height_, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(
+    ExecutionContext* execution_context,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLenum type,
     HTMLVideoElement* video,
     ExceptionState& exception_state) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperHTMLVideoElement(kTexSubImage3D, target, level, 0, format, type,
+
+  TexImageHelperHTMLVideoElement(execution_context->GetSecurityOrigin(),
+                                 kTexSubImage3D, target, level, 0, format, type,
                                  xoffset, yoffset, zoffset, video,
                                  GetTextureSourceSubRectangle(width, height),
                                  depth, unpack_image_height_, exception_state);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
@@ skipping 3674 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink