Use visitDOMWrapper to preserve WebGL JS object wrappers

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 374 matching lines @@
             return false;
         }
         break;
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
     return true;
 }
 
-void WebGL2RenderingContextBase::framebufferTextureLayer(ScriptState* scriptState, GLenum target, GLenum attachment, WebGLTexture* texture, GLint level, GLint layer)
+void WebGL2RenderingContextBase::framebufferTextureLayer(GLenum target, GLenum attachment, WebGLTexture* texture, GLint level, GLint layer)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferTextureLayer", target, attachment))
         return;
     if (texture && !texture->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_VALUE, "framebufferTextureLayer", "no texture or texture not from this context");
         return;
     }
     GLenum textarget = texture ? texture->getTarget() : 0;
     if (texture) {
         if (textarget != GL_TEXTURE_3D && textarget != GL_TEXTURE_2D_ARRAY) {
@@ skipping 15 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);
     } else {
         framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, textarget, texture, level, layer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, texture);
     }
     applyStencilTest();
 }
 
 ScriptValue WebGL2RenderingContextBase::getInternalformatParameter(ScriptState* scriptState, GLenum target, GLenum internalformat, GLenum pname)
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
 
     if (target != GL_RENDERBUFFER) {
@@ skipping 1373 matching lines @@
 }
 
 GLboolean WebGL2RenderingContextBase::isQuery(WebGLQuery* query)
 {
     if (isContextLost() || !query)
         return 0;
 
     return contextGL()->IsQueryEXT(query->object());
 }
 
-void WebGL2RenderingContextBase::beginQuery(ScriptState* scriptState, GLenum target, WebGLQuery* query)
+void WebGL2RenderingContextBase::beginQuery(GLenum target, WebGLQuery* query)
 {
     bool deleted;
     if (!query) {
         synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "query object is null");
         return;
     }
 
     if (!checkObjectToBeBound("beginQuery", query, deleted))
         return;
     if (deleted) {
@@ skipping 28 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);
 }
 
 void WebGL2RenderingContextBase::endQuery(GLenum target)
 {
     if (isContextLost())
         return;
 
     switch (target) {
     case GL_ANY_SAMPLES_PASSED:
     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
@@ skipping 117 matching lines @@
 }
 
 GLboolean WebGL2RenderingContextBase::isSampler(WebGLSampler* sampler)
 {
     if (isContextLost() || !sampler)
         return 0;
 
     return contextGL()->IsSampler(sampler->object());
 }
 
-void WebGL2RenderingContextBase::bindSampler(ScriptState* scriptState, GLuint unit, WebGLSampler* sampler)
+void WebGL2RenderingContextBase::bindSampler(GLuint unit, WebGLSampler* sampler)
 {
     if (isContextLost())
         return;
 
     bool deleted;
     if (!checkObjectToBeBound("bindSampler", sampler, deleted))
         return;
     if (deleted) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindSampler", "attempted to bind a deleted sampler");
         return;
     }
 
     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);
 }
 
 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 209 matching lines @@
 {
     if (isContextLost() || !feedback)
         return 0;
 
     if (!feedback->hasEverBeenBound())
         return 0;
 
     return contextGL()->IsTransformFeedback(feedback->object());
 }
 
-void WebGL2RenderingContextBase::bindTransformFeedback(ScriptState* scriptState, GLenum target, WebGLTransformFeedback* feedback)
+void WebGL2RenderingContextBase::bindTransformFeedback(GLenum target, WebGLTransformFeedback* feedback)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindTransformFeedback", feedback, deleted))
         return;
     if (deleted) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTransformFeedback", "attempted to bind a deleted transform feedback object");
         return;
     }
 
     if (target != GL_TRANSFORM_FEEDBACK) {
         synthesizeGLError(GL_INVALID_ENUM, "bindTransformFeedback", "target must be TRANSFORM_FEEDBACK");
         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);
     }
 
 }
 
 void WebGL2RenderingContextBase::beginTransformFeedback(GLenum primitiveMode)
 {
     if (isContextLost())
         return;
     if (!validateTransformFeedbackPrimitiveMode("beginTransformFeedback", primitiveMode))
         return;
@@ skipping 383 matching lines @@
 WebGLVertexArrayObject* WebGL2RenderingContextBase::createVertexArray()
 {
     if (isContextLost())
         return nullptr;
 
     WebGLVertexArrayObject* o = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeUser);
     addContextObject(o);
     return o;
 }
 
-void WebGL2RenderingContextBase::deleteVertexArray(ScriptState* scriptState, WebGLVertexArrayObject* vertexArray)
+void WebGL2RenderingContextBase::deleteVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return;
 
     if (!vertexArray->isDefaultObject() && vertexArray == m_boundVertexArrayObject)
-        setBoundVertexArrayObject(scriptState, nullptr);
+        setBoundVertexArrayObject(nullptr);
 
     vertexArray->deleteObject(contextGL());
 }
 
 GLboolean WebGL2RenderingContextBase::isVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return 0;
 
     if (!vertexArray->hasEverBeenBound())
         return 0;
 
     return contextGL()->IsVertexArrayOES(vertexArray->object());
 }
 
-void WebGL2RenderingContextBase::bindVertexArray(ScriptState* scriptState, WebGLVertexArrayObject* vertexArray)
+void WebGL2RenderingContextBase::bindVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost())
         return;
 
     if (vertexArray && (vertexArray->isDeleted() || !vertexArray->validate(0, this))) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindVertexArray", "invalid vertexArray");
         return;
     }
 
     if (vertexArray && !vertexArray->isDefaultObject() && vertexArray->object()) {
         contextGL()->BindVertexArrayOES(objectOrZero(vertexArray));
 
         vertexArray->setHasEverBeenBound();
-        setBoundVertexArrayObject(scriptState, vertexArray);
+        setBoundVertexArrayObject(vertexArray);
     } else {
         contextGL()->BindVertexArrayOES(0);
-        setBoundVertexArrayObject(scriptState, nullptr);
+        setBoundVertexArrayObject(nullptr);
     }
 }
 
-void WebGL2RenderingContextBase::bindFramebuffer(ScriptState* scriptState, GLenum target, WebGLFramebuffer* buffer)
+void WebGL2RenderingContextBase::bindFramebuffer(GLenum target, WebGLFramebuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
         return;
 
     if (deleted)
         buffer = 0;
 
     switch (target) {
     case GL_DRAW_FRAMEBUFFER:
         break;
     case GL_FRAMEBUFFER:
     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);
-    }
 }
 
 void WebGL2RenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!deleteObject(framebuffer))
         return;
     GLenum target = 0;
     if (framebuffer == m_framebufferBinding) {
         if (framebuffer == m_readFramebufferBinding) {
             target = GL_FRAMEBUFFER;
@@ skipping 821 matching lines @@
     if (m_boundTransformFeedbackBuffer == buffer)
         m_boundTransformFeedbackBuffer = nullptr;
     if (m_boundUniformBuffer == buffer)
         m_boundUniformBuffer = nullptr;
 
     WebGLRenderingContextBase::removeBoundBuffer(buffer);
 }
 
 void WebGL2RenderingContextBase::restoreCurrentFramebuffer()
 {
-    bindFramebuffer(nullptr, GL_DRAW_FRAMEBUFFER, m_framebufferBinding.get());
-    bindFramebuffer(nullptr, GL_READ_FRAMEBUFFER, m_readFramebufferBinding.get());
+    bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebufferBinding.get());
+    bindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding.get());
+}
+
+void WebGL2RenderingContextBase::visitChildDOMWrappers(v8::Isolate* isolate, const v8::Persistent<v8::Object>& wrapper)
+{
+    if (isContextLost()) {
+        return;
+    }
+
+    WebGLRenderingContextBase::visitChildDOMWrappers(isolate, wrapper);
+
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_transformFeedbackBinding, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_readFramebufferBinding, isolate);
+
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundCopyReadBuffer, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundCopyWriteBuffer, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundPixelPackBuffer, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundPixelUnpackBuffer, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundTransformFeedbackBuffer, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundUniformBuffer, isolate);
+
+    for (auto& buf : m_boundIndexedTransformFeedbackBuffers) {
+        DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, buf, isolate);
+    }
+
+    for (auto& buf : m_boundIndexedUniformBuffers) {
+        DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, buf, isolate);
+    }
+
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_currentBooleanOcclusionQuery, isolate);
+    DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_currentTransformFeedbackPrimitivesWrittenQuery, isolate);
+
+    for (auto& unit : m_samplerUnits) {
+        DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, unit, isolate);
+    }
 }
 
 WebGLImageConversion::PixelStoreParams WebGL2RenderingContextBase::getPackPixelStoreParams()
 {
     WebGLImageConversion::PixelStoreParams params;
     params.alignment = m_packAlignment;
     params.rowLength = m_packRowLength;
     params.skipPixels = m_packSkipPixels;
     params.skipRows = m_packSkipRows;
     return params;
 }
 
 WebGLImageConversion::PixelStoreParams WebGL2RenderingContextBase::getUnpackPixelStoreParams(TexImageDimension dimension)
 {
     WebGLImageConversion::PixelStoreParams params;
     params.alignment = m_unpackAlignment;
     params.rowLength = m_unpackRowLength;
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink