Use visitDOMWrapper to preserve WebGL JS object wrappers

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

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 890 matching lines @@
 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas,
     OffscreenCanvas* passedOffscreenCanvas, std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
     : CanvasRenderingContext(passedCanvas, passedOffscreenCanvas, requestedAttributes)
     , m_isHidden(false)
     , m_contextLostMode(NotLostContext)
     , m_autoRecoveryMethod(Manual)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
-    , m_preservedDefaultVAOObjectWrapper(false)
     , m_generatedImageCache(4)
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
     , m_onePlusMaxNonDefaultTextureUnit(0)
     , m_isWebGL2FormatsTypesAdded(false)
     , m_isWebGL2InternalFormatsCopyTexImageAdded(false)
     , m_isOESTextureFloatFormatsTypesAdded(false)
     , m_isOESTextureHalfFloatFormatsTypesAdded(false)
     , m_isWebGLDepthTextureFormatsTypesAdded(false)
     , m_isEXTsRGBFormatsTypesAdded(false)
@@ skipping 120 matching lines @@
     // These two values from EXT_draw_buffers are lazily queried.
     m_maxDrawBuffers = 0;
     m_maxColorAttachments = 0;
 
     m_backDrawBuffer = GL_BACK;
 
     m_readBufferOfDefaultFramebuffer = GL_BACK;
 
     m_defaultVertexArrayObject = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeDefault);
     addContextObject(m_defaultVertexArrayObject.get());
-    // It's not convenient or necessary to pass a ScriptState this far down; while one is available
-    // during WebGLRenderingContext construction, the wrapper for the context itself hasn't been
-    // created yet. It's simpler to instead lazily instantiate and preserve the JavaScript wrapper
-    // for the default VAO. (This object is never exposed to JavaScript, but we need to link other
-    // JavaScript wrappers to it.)
-    m_preservedDefaultVAOObjectWrapper = false;
+
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribType.resize(m_maxVertexAttribs);
 
     contextGL()->Viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
     contextGL()->Scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
 
     drawingBuffer()->contextProvider()->setLostContextCallback(
         WebClosure(WTF::bind(
             &WebGLRenderingContextBase::forceLostContext,
@@ skipping 353 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "activeTexture", "texture unit out of range");
         return;
     }
     m_activeTextureUnit = texture - GL_TEXTURE0;
     contextGL()->ActiveTexture(texture);
 
     drawingBuffer()->setActiveTextureUnit(texture);
 
 }
 
-void WebGLRenderingContextBase::attachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
+void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))
         return;
     if (!program->attachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "attachShader", "shader attachment already has shader");
         return;
     }
     contextGL()->AttachShader(objectOrZero(program), objectOrZero(shader));
     shader->onAttached();
-    preserveObjectWrapper(scriptState, program, V8HiddenValue::webglShaders(scriptState->isolate()), program->getPersistentCache(), static_cast<uint32_t>(shader->type()), shader);
 }
 
 void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GLuint index, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("bindAttribLocation", program))
         return;
     if (!validateLocationLength("bindAttribLocation", name))
         return;
     if (isPrefixReserved(name)) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindAttribLocation", "reserved prefix");
@@ skipping 37 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 
     if (buffer && !buffer->getInitialTarget())
         buffer->setInitialTarget(target);
     return true;
 }
 
-void WebGLRenderingContextBase::bindBuffer(ScriptState* scriptState, GLenum target, WebGLBuffer* buffer)
+void WebGLRenderingContextBase::bindBuffer(GLenum target, WebGLBuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     if (!validateAndUpdateBufferBindTarget("bindBuffer", target, buffer))
         return;
 
     contextGL()->BindBuffer(target, objectOrZero(buffer));
-    PreservedWrapperIndex idx = PreservedArrayBuffer;
-    switch (target) {
-    case GL_ARRAY_BUFFER:
-        idx = PreservedArrayBuffer;
-        break;
-    case GL_ELEMENT_ARRAY_BUFFER:
-        idx = PreservedElementArrayBuffer;
-        break;
-    }
-
-    preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(idx), buffer);
-    maybePreserveDefaultVAOObjectWrapper(scriptState);
 }
 
-void WebGLRenderingContextBase::bindFramebuffer(ScriptState* scriptState, GLenum target, WebGLFramebuffer* buffer)
+void WebGLRenderingContextBase::bindFramebuffer(GLenum target, WebGLFramebuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
         return;
 
     if (deleted)
         buffer = 0;
 
     if (target != GL_FRAMEBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindFramebuffer", "invalid target");
         return;
     }
 
     setFramebuffer(target, buffer);
-    // This is called both internally and externally (from JavaScript). We only update which wrapper
-    // is preserved when it's called from JavaScript.
-    if (scriptState) {
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedFramebuffer), buffer);
-    }
 }
 
-void WebGLRenderingContextBase::bindRenderbuffer(ScriptState* scriptState, GLenum target, WebGLRenderbuffer* renderBuffer)
+void WebGLRenderingContextBase::bindRenderbuffer(GLenum target, WebGLRenderbuffer* renderBuffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
         return;
     if (deleted)
         renderBuffer = 0;
     if (target != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindRenderbuffer", "invalid target");
         return;
     }
     m_renderbufferBinding = renderBuffer;
     contextGL()->BindRenderbuffer(target, objectOrZero(renderBuffer));
-    preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, PreservedRenderbuffer, renderBuffer);
 
     drawingBuffer()->setRenderbufferBinding(objectOrZero(renderBuffer));
 
     if (renderBuffer)
         renderBuffer->setHasEverBeenBound();
 }
 
-void WebGLRenderingContextBase::bindTexture(ScriptState* scriptState, GLenum target, WebGLTexture* texture)
+void WebGLRenderingContextBase::bindTexture(GLenum target, WebGLTexture* texture)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindTexture", texture, deleted))
         return;
     if (deleted)
         texture = 0;
     if (texture && texture->getTarget() && texture->getTarget() != target) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
         return;
     }
 
-    // ScriptState may be null if this method is called internally
-    // during restoration of texture unit bindings. Skip the
-    // preserveObjectWrapper work in this case.
-    v8::Local<v8::String> hiddenValueName;
-    ScopedPersistent<v8::Array>* persistentCache = nullptr;
     if (target == GL_TEXTURE_2D) {
         m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
 
         if (!m_activeTextureUnit)
             drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
-        if (scriptState) {
-            hiddenValueName = V8HiddenValue::webgl2DTextures(scriptState->isolate());
-            persistentCache = &m_wrappersOf2DTextures;
-        }
     } else if (target == GL_TEXTURE_CUBE_MAP) {
         m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
-        if (scriptState) {
-            hiddenValueName = V8HiddenValue::webglCubeMapTextures(scriptState->isolate());
-            persistentCache = &m_cubeMapTextureWrappers;
-        }
     } else if (isWebGL2OrHigher() && target == GL_TEXTURE_2D_ARRAY) {
         m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding = texture;
-        if (scriptState) {
-            hiddenValueName = V8HiddenValue::webgl2DArrayTextures(scriptState->isolate());
-            persistentCache = &m_wrappersOf2DArrayTextures;
-        }
     } else if (isWebGL2OrHigher() && target == GL_TEXTURE_3D) {
         m_textureUnits[m_activeTextureUnit].m_texture3DBinding = texture;
-        if (scriptState) {
-            hiddenValueName = V8HiddenValue::webgl3DTextures(scriptState->isolate());
-            persistentCache = &m_wrappersOf3DTextures;
-        }
     } else {
         synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
         return;
     }
 
     contextGL()->BindTexture(target, objectOrZero(texture));
-    // This is called both internally and externally (from JavaScript). We only update which wrapper
-    // is preserved when it's called from JavaScript.
-    if (scriptState) {
-        preserveObjectWrapper(scriptState, this, hiddenValueName, persistentCache, m_activeTextureUnit, texture);
-    }
     if (texture) {
         texture->setTarget(target);
         m_onePlusMaxNonDefaultTextureUnit = max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
     } else {
         // If the disabled index is the current maximum, trace backwards to find the new max enabled texture index
         if (m_onePlusMaxNonDefaultTextureUnit == m_activeTextureUnit + 1) {
             findNewMaxNonDefaultTextureUnit();
         }
     }
 
@@ skipping 374 matching lines @@
 
 WebGLRenderbuffer* WebGLRenderingContextBase::createRenderbuffer()
 {
     if (isContextLost())
         return nullptr;
     WebGLRenderbuffer* o = WebGLRenderbuffer::create(this);
     addSharedObject(o);
     return o;
 }
 
-void WebGLRenderingContextBase::setBoundVertexArrayObject(ScriptState* scriptState, WebGLVertexArrayObjectBase* arrayObject)
+void WebGLRenderingContextBase::setBoundVertexArrayObject(WebGLVertexArrayObjectBase* arrayObject)
 {
     if (arrayObject)
         m_boundVertexArrayObject = arrayObject;
     else
         m_boundVertexArrayObject = m_defaultVertexArrayObject;
-
-    preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedVAO), arrayObject);
 }
 
 WebGLShader* WebGLRenderingContextBase::createShader(GLenum type)
 {
     if (isContextLost())
         return nullptr;
     if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
         synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
         return nullptr;
     }
@@ skipping 130 matching lines @@
     if (isContextLost())
         return;
     // Check required by WebGL spec section 6.12
     if (zNear > zFar) {
         synthesizeGLError(GL_INVALID_OPERATION, "depthRange", "zNear > zFar");
         return;
     }
     contextGL()->DepthRangef(zNear, zFar);
 }
 
-void WebGLRenderingContextBase::detachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
+void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
         return;
     if (!program->detachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "detachShader", "shader not attached");
         return;
     }
     contextGL()->DetachShader(objectOrZero(program), objectOrZero(shader));
     shader->onDetached(contextGL());
-    preserveObjectWrapper(scriptState, program, V8HiddenValue::webglShaders(scriptState->isolate()), program->getPersistentCache(), static_cast<uint32_t>(shader->type()), nullptr);
 }
 
 void WebGLRenderingContextBase::disable(GLenum cap)
 {
     if (isContextLost() || !validateCapability("disable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = false;
         applyStencilTest();
         return;
@@ skipping 142 matching lines @@
     contextGL()->Flush(); // Intentionally a flush, not a finish.
 }
 
 void WebGLRenderingContextBase::flush()
 {
     if (isContextLost())
         return;
     contextGL()->Flush();
 }
 
-void WebGLRenderingContextBase::framebufferRenderbuffer(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
+void WebGLRenderingContextBase::framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
         return;
     if (renderbuffertarget != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "framebufferRenderbuffer", "invalid target");
         return;
     }
     if (buffer && !buffer->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");
         return;
     }
     // Don't allow the default framebuffer to be mutated; all current
     // implementations use an FBO internally in place of the default
     // FBO.
     WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
     if (!framebufferBinding || !framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");
         return;
     }
     GLuint bufferObject = objectOrZero(buffer);
     if (isWebGL2OrHigher() && 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.
         contextGL()->FramebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
         contextGL()->FramebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, buffer);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, buffer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_DEPTH_ATTACHMENT, buffer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_STENCIL_ATTACHMENT, buffer);
     } else {
         contextGL()->FramebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, buffer);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, buffer);
     }
     applyStencilTest();
 }
 
-void WebGLRenderingContextBase::framebufferTexture2D(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
+void WebGLRenderingContextBase::framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
         return;
     if (texture && !texture->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");
         return;
     }
     // Don't allow the default framebuffer to be mutated; all current
     // implementations use an FBO internally in place of the default
     // FBO.
     WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
     if (!framebufferBinding || !framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");
         return;
     }
     GLuint textureObject = objectOrZero(texture);
     if (isWebGL2OrHigher() && 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.
         contextGL()->FramebufferTexture2D(target, GL_DEPTH_ATTACHMENT, textarget, textureObject, level);
         contextGL()->FramebufferTexture2D(target, GL_STENCIL_ATTACHMENT, textarget, textureObject, level);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, textarget, texture, level, 0);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, textarget, texture, level, 0);
-        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 {
         contextGL()->FramebufferTexture2D(target, attachment, textarget, textureObject, level);
         framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, textarget, texture, level, 0);
-        preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, texture);
     }
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::frontFace(GLenum mode)
 {
     if (isContextLost())
         return;
     contextGL()->FrontFace(mode);
 }
@@ skipping 185 matching lines @@
     if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
         return false;
     if (!tracker->supported(this))
         return false;
     return true;
 }
 
 ScriptValue WebGLRenderingContextBase::getExtension(ScriptState* scriptState, const String& name)
 {
     WebGLExtension* extension = nullptr;
-    bool linkContextToExtension = false;
 
     if (!isContextLost()) {
         for (size_t i = 0; i < m_extensions.size(); ++i) {
             ExtensionTracker* tracker = m_extensions[i];
             if (tracker->matchesNameWithPrefixes(name)) {
                 if (extensionSupportedAndAllowed(tracker)) {
                     extension = tracker->getExtension(this);
                     if (extension) {
                         if (!m_extensionEnabled[extension->name()]) {
-                            linkContextToExtension = true;
                             m_extensionEnabled[extension->name()] = true;
                         }
                     }
                 }
                 break;
             }
         }
     }
 
     v8::Local<v8::Value> wrappedExtension = toV8(extension, scriptState->context()->Global(), scriptState->isolate());
 
-    if (linkContextToExtension) {
-        // Keep the extension's JavaScript wrapper alive as long as the context is alive, so that
-        // expando properties that are added to the extension persist.
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglExtensions(scriptState->isolate()), &m_extensionWrappers, static_cast<uint32_t>(extension->name()), extension);
-    }
-
     return ScriptValue(scriptState, wrappedExtension);
 }
 
 ScriptValue WebGLRenderingContextBase::getFramebufferAttachmentParameter(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum pname)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return ScriptValue::createNull(scriptState);
 
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");
@@ skipping 2281 matching lines @@
     contextGL()->UniformMatrix4fv(location->location(), v->length() >> 4, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v.data(), v.size(), 16))
         return;
     contextGL()->UniformMatrix4fv(location->location(), v.size() >> 4, transpose, v.data());
 }
 
-void WebGLRenderingContextBase::useProgram(ScriptState* scriptState, WebGLProgram* program)
+void WebGLRenderingContextBase::useProgram(WebGLProgram* program)
 {
     bool deleted;
     if (!checkObjectToBeBound("useProgram", program, deleted))
         return;
     if (deleted)
         program = 0;
     if (program && !program->linkStatus(this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "program not valid");
         return;
     }
 
     if (m_currentProgram != program) {
         if (m_currentProgram)
             m_currentProgram->onDetached(contextGL());
         m_currentProgram = program;
         contextGL()->UseProgram(objectOrZero(program));
         if (program)
             program->onAttached();
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedProgram), program);
     }
 }
 
 void WebGLRenderingContextBase::validateProgram(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("validateProgram", program))
         return;
     contextGL()->ValidateProgram(objectOrZero(program));
 }
 
@@ skipping 124 matching lines @@
     if (isContextLost())
         return;
     if (v.size() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
         return;
     }
     contextGL()->VertexAttrib4fv(index, v.data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttribPointer(ScriptState* scriptState, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
+void WebGLRenderingContextBase::vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribPointer", "index out of range");
         return;
     }
     if (!validateValueFitNonNegInt32("vertexAttribPointer", "offset", offset))
         return;
     if (!m_boundArrayBuffer) {
         synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");
         return;
     }
 
     m_boundVertexArrayObject->setArrayBufferForAttrib(index, m_boundArrayBuffer.get());
     contextGL()->VertexAttribPointer(index, size, type, normalized, stride, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
-    maybePreserveDefaultVAOObjectWrapper(scriptState);
-    preserveObjectWrapper(scriptState, m_boundVertexArrayObject, V8HiddenValue::webglBuffers(scriptState->isolate()), m_boundVertexArrayObject->getPersistentCache(), index, m_boundArrayBuffer);
 }
 
 void WebGLRenderingContextBase::vertexAttribDivisorANGLE(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisorANGLE", "index out of range");
         return;
@@ skipping 119 matching lines @@
 {
     ASSERT(!isContextLost());
     m_contextGroup->addObject(object);
 }
 
 void WebGLRenderingContextBase::removeContextObject(WebGLContextObject* object)
 {
     m_contextObjects.remove(object);
 }
 
+void WebGLRenderingContextBase::trySetWrapperReferencesInAllWorlds(const v8::Persistent<v8::Object>& wrapper, ScriptWrappable* scriptWrappable, v8::Isolate* isolate)
+{
+    if (scriptWrappable) {
+        DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, scriptWrappable, isolate);
+    }
+}
+
+void WebGLRenderingContextBase::visitChildDOMWrappers(v8::Isolate* isolate, const v8::Persistent<v8::Object>& wrapper)
+{
+    if (isContextLost()) {
+        return;
+    }
+    trySetWrapperReferencesInAllWorlds(wrapper, m_boundArrayBuffer, isolate);
+    trySetWrapperReferencesInAllWorlds(wrapper, m_renderbufferBinding, isolate);
+
+    for (auto& unit : m_textureUnits) {
+        trySetWrapperReferencesInAllWorlds(wrapper, unit.m_texture2DBinding, isolate);
+        trySetWrapperReferencesInAllWorlds(wrapper, unit.m_textureCubeMapBinding, isolate);
+        trySetWrapperReferencesInAllWorlds(wrapper, unit.m_texture3DBinding, isolate);
+        trySetWrapperReferencesInAllWorlds(wrapper, unit.m_texture2DArrayBinding, isolate);
+    }
+
+    if (m_framebufferBinding) {
+        m_framebufferBinding->visitChildDOMWrappers(isolate, wrapper);
+    }
+    if (m_currentProgram) {
+        m_currentProgram->visitChildDOMWrappers(isolate, wrapper);
+    }
+
+    if (m_boundVertexArrayObject) {
+        m_boundVertexArrayObject->visitChildDOMWrappers(isolate, wrapper);
+    }
+
+    for (ExtensionTracker* tracker : m_extensions) {
+        WebGLExtension* extension = tracker->getExtensionObjectIfAlreadyEnabled();
+        if (extension) {
+            trySetWrapperReferencesInAllWorlds(wrapper, extension, isolate);
+        }
+    }
+}
+
 void WebGLRenderingContextBase::addContextObject(WebGLContextObject* object)
 {
     ASSERT(!isContextLost());
     m_contextObjects.add(object);
 }
 
 void WebGLRenderingContextBase::detachAndRemoveAllObjects()
 {
     while (m_contextObjects.size() > 0) {
         // Following detachContext() will remove the iterated object from
@@ skipping 1074 matching lines @@
     if (!buffer) {
         // Instead of binding fb 0, bind the drawing buffer.
         drawingBuffer()->bind(target);
     } else {
         contextGL()->BindFramebuffer(target, buffer->object());
     }
 }
 
 void WebGLRenderingContextBase::restoreCurrentFramebuffer()
 {
-    bindFramebuffer(nullptr, GL_FRAMEBUFFER, m_framebufferBinding.get());
+    bindFramebuffer(GL_FRAMEBUFFER, m_framebufferBinding.get());
 }
 
 void WebGLRenderingContextBase::restoreCurrentTexture2D()
 {
-    bindTexture(nullptr, GL_TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());
+    bindTexture(GL_TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());
 }
 
 void WebGLRenderingContextBase::findNewMaxNonDefaultTextureUnit()
 {
     // Trace backwards from the current max to find the new max non-default texture unit
     int startIndex = m_onePlusMaxNonDefaultTextureUnit - 1;
     for (int i = startIndex; i >= 0; --i) {
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
-void WebGLRenderingContextBase::preserveObjectWrapper(ScriptState* scriptState, ScriptWrappable* sourceObject, v8::Local<v8::String> hiddenValueName, ScopedPersistent<v8::Array>* persistentCache, uint32_t index, ScriptWrappable* targetObject)
-{
-    v8::Isolate* isolate = scriptState->isolate();
-    if (persistentCache->isEmpty()) {
-        // TODO(kbr): eliminate the persistent caches and just use
-        // V8HiddenValue::getHiddenValue. Unfortunately, it's
-        // currently too slow to use. crbug.com/611864
-        persistentCache->set(isolate, v8::Array::New(isolate));
-        V8HiddenValue::setHiddenValue(
-            scriptState,
-            sourceObject->mainWorldWrapper(isolate),
-            hiddenValueName,
-            persistentCache->newLocal(isolate));
-        // It is important to mark the persistent cache as weak
-        // (phantom, actually). Otherwise there will be a reference
-        // cycle between it and its JavaScript wrapper, and currently
-        // there are problems collecting such cycles.
-        persistentCache->setPhantom();
-    }
-
-    v8::Local<v8::Array> localCache = persistentCache->newLocal(isolate);
-    if (targetObject) {
-        localCache->Set(scriptState->context(), index, targetObject->mainWorldWrapper(isolate)).ToChecked();
-    } else {
-        localCache->Set(scriptState->context(), index, v8::Null(isolate)).ToChecked();
-    }
-}
-
-void WebGLRenderingContextBase::maybePreserveDefaultVAOObjectWrapper(ScriptState* scriptState)
-{
-    ASSERT(scriptState);
-
-    if (!m_preservedDefaultVAOObjectWrapper) {
-        // The default VAO does not have a JavaScript wrapper created for it, but one is needed to
-        // link up the WebGLBuffers associated with the vertex attributes.
-        toV8(m_defaultVertexArrayObject, scriptState->context()->Global(), scriptState->isolate());
-        preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedDefaultVAO), m_defaultVertexArrayObject);
-        m_preservedDefaultVAOObjectWrapper = true;
-    }
-}
-
 DEFINE_TRACE(WebGLRenderingContextBase::TextureUnitState)
 {
     visitor->trace(m_texture2DBinding);
     visitor->trace(m_textureCubeMapBinding);
     visitor->trace(m_texture3DBinding);
     visitor->trace(m_texture2DArrayBinding);
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase)
 {
@@ skipping 54 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink