Fix content scripts that use WebGL.

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 303 matching lines @@
         contextGL()->FramebufferTextureLayer(target, GL_DEPTH_ATTACHMENT, objectOrZero(texture), level, layer);
         contextGL()->FramebufferTextureLayer(target, GL_STENCIL_ATTACHMENT, objectOrZero(texture), level, layer);
     } else {
         contextGL()->FramebufferTextureLayer(target, attachment, objectOrZero(texture), level, layer);
     }
     if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
         // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
         // We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, textarget, texture, level, layer);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, textarget, texture, level, layer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_DEPTH_ATTACHMENT, texture);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_STENCIL_ATTACHMENT, texture);
+        preserveObjectWrapper(scriptState, framebufferBinding, V8PrivateProperty::getWebGLFramebufferAttachments(scriptState->isolate()), GL_DEPTH_ATTACHMENT, texture);
+        preserveObjectWrapper(scriptState, framebufferBinding, V8PrivateProperty::getWebGLFramebufferAttachments(scriptState->isolate()), GL_STENCIL_ATTACHMENT, texture);
     } else {
         framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, textarget, texture, level, layer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, texture);
+        preserveObjectWrapper(scriptState, framebufferBinding, V8PrivateProperty::getWebGLFramebufferAttachments(scriptState->isolate()), attachment, texture);

[Yuki, 2016/06/02 13:07:22]

Could you tell us why you need to preserve the wrapper of |texture|?

Preserved wrapper objects seem never used.  If you only need to keep |texture|
alive, is it enough to keep Member<WebGLTexture> and let Oilpan know the
dependency through DEFINE_TRACE()?  Or do you need the wrapper object of
|texture| alive in addition to |texture| itself?

By the way, the following member variables seem not used.
    ScopedPersistent<v8::Array> m_samplerWrappers;
    ScopedPersistent<v8::Array> m_queryWrappers;

[Ken Russell (switch to Gerrit), 2016/06/03 00:59:19]

Yes, the wrapper objects need to be kept alive, per the WebGL specification and
the associated conformance tests.
Thanks for pointing that out; I missed them. The persistent caches had to be
reintroduced for performance reasons, so these are used again.

     }
     applyStencilTest();
 }
 
 ScriptValue WebGL2RenderingContextBase::getInternalformatParameter(ScriptState* scriptState, GLenum target, GLenum internalformat, GLenum pname)
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
 
     if (target != GL_RENDERBUFFER) {
@@ skipping 1432 matching lines @@
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "beginQuery", "invalid target");
         return;
     }
 
     if (!query->getTarget())
         query->setTarget(target);
 
     contextGL()->BeginQueryEXT(target, query->object());
-    preserveObjectWrapper(scriptState, this, V8HiddenValue::webglQueries(scriptState->isolate()), &m_queryWrappers, static_cast<uint32_t>(target), query);
+    preserveObjectWrapper(scriptState, this, V8PrivateProperty::getWebGLRenderingContextQueries(scriptState->isolate()), static_cast<uint32_t>(target), query);
 }
 
 void WebGL2RenderingContextBase::endQuery(GLenum target)
 {
     if (isContextLost())
         return;
 
     switch (target) {
     case GL_ANY_SAMPLES_PASSED:
     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
@@ skipping 139 matching lines @@
 
     if (unit >= m_samplerUnits.size()) {
         synthesizeGLError(GL_INVALID_VALUE, "bindSampler", "texture unit out of range");
         return;
     }
 
     m_samplerUnits[unit] = sampler;
 
     contextGL()->BindSampler(unit, objectOrZero(sampler));
 
-    preserveObjectWrapper(scriptState, this, V8HiddenValue::webglSamplers(scriptState->isolate()), &m_samplerWrappers, static_cast<uint32_t>(unit), sampler);
+    preserveObjectWrapper(scriptState, this, V8PrivateProperty::getWebGLRenderingContextSamplers(scriptState->isolate()), static_cast<uint32_t>(unit), sampler);
 }
 
 void WebGL2RenderingContextBase::samplerParameter(WebGLSampler* sampler, GLenum pname, GLfloat paramf, GLint parami, bool isFloat)
 {
     if (isContextLost() || !validateWebGLObject("samplerParameter", sampler))
         return;
 
     GLint param = isFloat ? static_cast<GLint>(paramf) : parami;
     switch (pname) {
     case GL_TEXTURE_MAX_LOD:
@@ skipping 238 matching lines @@
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTransformFeedback", "transform feedback is active and not paused");
         return;
     }
 
     m_transformFeedbackBinding = feedback;
 
     contextGL()->BindTransformFeedback(target, objectOrZero(feedback));
     if (feedback) {
         feedback->setTarget(target);
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedTransformFeedback), feedback);
+        preserveObjectWrapper(scriptState, this, V8PrivateProperty::getWebGLRenderingContextMisc(scriptState->isolate()), static_cast<uint32_t>(PreservedTransformFeedback), feedback);
     }
 
 }
 
 void WebGL2RenderingContextBase::beginTransformFeedback(GLenum primitiveMode)
 {
     if (isContextLost())
         return;
     if (!validateTransformFeedbackPrimitiveMode("beginTransformFeedback", primitiveMode))
         return;
@@ skipping 520 matching lines @@
     case GL_READ_FRAMEBUFFER:
         m_readFramebufferBinding = buffer;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "bindFramebuffer", "invalid target");
         return;
     }
 
     setFramebuffer(target, buffer);
     if (scriptState) {
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedFramebuffer), buffer);
+        preserveObjectWrapper(scriptState, this, V8PrivateProperty::getWebGLRenderingContextMisc(scriptState->isolate()), static_cast<uint32_t>(PreservedFramebuffer), buffer);
     }
 }
 
 void WebGL2RenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!deleteObject(framebuffer))
         return;
     GLenum target = 0;
     if (framebuffer == m_framebufferBinding) {
         if (framebuffer == m_readFramebufferBinding) {
@@ skipping 851 matching lines @@
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink