Use visitDOMWrapper to preserve WebGL JS object wrappers

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

 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebGLRenderingContextBase_h
 #define WebGLRenderingContextBase_h
 
 #include "bindings/core/v8/Nullable.h"
-#include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/CoreExport.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/TypedFlexibleArrayBufferView.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/layout/ContentChangeType.h"
 #include "modules/webgl/WebGLContextAttributes.h"
@@ skipping 102 matching lines @@
     static std::unique_ptr<WebGraphicsContext3DProvider> createWebGraphicsContext3DProvider(HTMLCanvasElement*, const CanvasContextCreationAttributes&, unsigned webGLVersion);
     static std::unique_ptr<WebGraphicsContext3DProvider> createWebGraphicsContext3DProvider(ScriptState*, const CanvasContextCreationAttributes&, unsigned webGLVersion);
     static void forceNextWebGLContextCreationToFail();
 
     unsigned version() const { return m_version; }
 
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
     void activeTexture(GLenum texture);
-    void attachShader(ScriptState*, WebGLProgram*, WebGLShader*);
+    void attachShader(WebGLProgram*, WebGLShader*);
     void bindAttribLocation(WebGLProgram*, GLuint index, const String& name);
-    void bindBuffer(ScriptState*, GLenum target, WebGLBuffer*);
-    virtual void bindFramebuffer(ScriptState*, GLenum target, WebGLFramebuffer*);
-    void bindRenderbuffer(ScriptState*, GLenum target, WebGLRenderbuffer*);
-    void bindTexture(ScriptState*, GLenum target, WebGLTexture*);
+    void bindBuffer(GLenum target, WebGLBuffer*);
+    virtual void bindFramebuffer(GLenum target, WebGLFramebuffer*);
+    void bindRenderbuffer(GLenum target, WebGLRenderbuffer*);
+    void bindTexture(GLenum target, WebGLTexture*);
     void blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
     void blendEquation(GLenum mode);
     void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
     void blendFunc(GLenum sfactor, GLenum dfactor);
     void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
 
     void bufferData(GLenum target, long long size, GLenum usage);
     void bufferData(GLenum target, DOMArrayBuffer* data, GLenum usage);
     void bufferData(GLenum target, DOMArrayBufferView* data, GLenum usage);
     void bufferSubData(GLenum target, long long offset, DOMArrayBuffer* data);
@@ skipping 25 matching lines @@
     void deleteBuffer(WebGLBuffer*);
     virtual void deleteFramebuffer(WebGLFramebuffer*);
     void deleteProgram(WebGLProgram*);
     void deleteRenderbuffer(WebGLRenderbuffer*);
     void deleteShader(WebGLShader*);
     void deleteTexture(WebGLTexture*);
 
     void depthFunc(GLenum);
     void depthMask(GLboolean);
     void depthRange(GLfloat zNear, GLfloat zFar);
-    void detachShader(ScriptState*, WebGLProgram*, WebGLShader*);
+    void detachShader(WebGLProgram*, WebGLShader*);
     void disable(GLenum cap);
     void disableVertexAttribArray(GLuint index);
     void drawArrays(GLenum mode, GLint first, GLsizei count);
     void drawElements(GLenum mode, GLsizei count, GLenum type, long long offset);
 
     void drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
     void drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei primcount);
 
     void enable(GLenum cap);
     void enableVertexAttribArray(GLuint index);
     void finish();
     void flush();
-    void framebufferRenderbuffer(ScriptState*, GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer*);
-    void framebufferTexture2D(ScriptState*, GLenum target, GLenum attachment, GLenum textarget, WebGLTexture*, GLint level);
+    void framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer*);
+    void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture*, GLint level);
     void frontFace(GLenum mode);
     void generateMipmap(GLenum target);
 
     WebGLActiveInfo* getActiveAttrib(WebGLProgram*, GLuint index);
     WebGLActiveInfo* getActiveUniform(WebGLProgram*, GLuint index);
     bool getAttachedShaders(WebGLProgram*, HeapVector<Member<WebGLShader>>&);
     Nullable<HeapVector<Member<WebGLShader>>> getAttachedShaders(WebGLProgram*);
     GLint getAttribLocation(WebGLProgram*, const String& name);
     ScriptValue getBufferParameter(ScriptState*, GLenum target, GLenum pname);
     void getContextAttributes(Nullable<WebGLContextAttributes>&);
@@ skipping 96 matching lines @@
     void uniform4i(const WebGLUniformLocation*, GLint x, GLint y, GLint z, GLint w);
     void uniform4iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
     void uniform4iv(const WebGLUniformLocation*, Vector<GLint>&);
     void uniformMatrix2fv(const WebGLUniformLocation*, GLboolean transpose, DOMFloat32Array* value);
     void uniformMatrix2fv(const WebGLUniformLocation*, GLboolean transpose, Vector<GLfloat>& value);
     void uniformMatrix3fv(const WebGLUniformLocation*, GLboolean transpose, DOMFloat32Array* value);
     void uniformMatrix3fv(const WebGLUniformLocation*, GLboolean transpose, Vector<GLfloat>& value);
     void uniformMatrix4fv(const WebGLUniformLocation*, GLboolean transpose, DOMFloat32Array* value);
     void uniformMatrix4fv(const WebGLUniformLocation*, GLboolean transpose, Vector<GLfloat>& value);
 
-    void useProgram(ScriptState*, WebGLProgram*);
+    void useProgram(WebGLProgram*);
     void validateProgram(WebGLProgram*);
 
     void vertexAttrib1f(GLuint index, GLfloat x);
     void vertexAttrib1fv(GLuint index, const DOMFloat32Array* values);
     void vertexAttrib1fv(GLuint index, const Vector<GLfloat>& values);
     void vertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
     void vertexAttrib2fv(GLuint index, const DOMFloat32Array* values);
     void vertexAttrib2fv(GLuint index, const Vector<GLfloat>& values);
     void vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
     void vertexAttrib3fv(GLuint index, const DOMFloat32Array* values);
     void vertexAttrib3fv(GLuint index, const Vector<GLfloat>& values);
     void vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
     void vertexAttrib4fv(GLuint index, const DOMFloat32Array* values);
     void vertexAttrib4fv(GLuint index, const Vector<GLfloat>& values);
-    void vertexAttribPointer(ScriptState*, GLuint index, GLint size, GLenum type, GLboolean normalized,
+    void vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized,
         GLsizei stride, long long offset);
 
     void vertexAttribDivisorANGLE(GLuint index, GLuint divisor);
 
     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
 
     // WEBGL_lose_context support
     enum AutoRecoveryMethod {
         // Don't restore automatically.
         Manual,
@@ skipping 66 matching lines @@
     friend class WebGLDebugShaders;
     friend class WebGLCompressedTextureASTC;
     friend class WebGLCompressedTextureATC;
     friend class WebGLCompressedTextureETC1;
     friend class WebGLCompressedTexturePVRTC;
     friend class WebGLCompressedTextureS3TC;
     friend class WebGLRenderingContextErrorMessageCallback;
     friend class WebGLVertexArrayObjectBase;
     friend class ScopedTexture2DRestorer;
     friend class ScopedFramebufferRestorer;
+    // To allow V8WebGL[2]RenderingContext to call visitChildDOMWrappers.
+    friend class V8WebGLRenderingContext;
 
     WebGLRenderingContextBase(HTMLCanvasElement*, std::unique_ptr<WebGraphicsContext3DProvider>, const CanvasContextCreationAttributes&, unsigned);
     WebGLRenderingContextBase(OffscreenCanvas*, std::unique_ptr<WebGraphicsContext3DProvider>, const CanvasContextCreationAttributes&, unsigned);
     PassRefPtr<DrawingBuffer> createDrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider>);
     void setupFlags();
 
     // CanvasRenderingContext implementation.
     bool is3d() const override { return true; }
     bool isAccelerated() const override { return true; }
     void setIsHidden(bool) override;
@@ skipping 26 matching lines @@
 
     // Adds a compressed texture format.
     void addCompressedTextureFormat(GLenum);
     void removeAllCompressedTextureFormats();
 
     // Set UNPACK_ALIGNMENT to 1, all other parameters to 0.
     virtual void resetUnpackParameters();
     // Restore the client unpack parameters.
     virtual void restoreUnpackParameters();
 
+    static void trySetWrapperReferencesInAllWorlds(const v8::Persistent<v8::Object>&, ScriptWrappable*, v8::Isolate*);
+    virtual void visitChildDOMWrappers(v8::Isolate*, const v8::Persistent<v8::Object>&);
+
     PassRefPtr<Image> drawImageIntoBuffer(PassRefPtr<Image>, int width, int height, const char* functionName);
 
     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*);
 
     // Structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
     RefPtr<DrawingBuffer> m_drawingBuffer;
     DrawingBuffer* drawingBuffer() const;
 
     RefPtr<WebGLContextGroup> m_contextGroup;
@@ skipping 11 matching lines @@
     Timer<WebGLRenderingContextBase> m_restoreTimer;
 
     bool m_markedCanvasDirty;
     HeapHashSet<WeakMember<WebGLContextObject>> m_contextObjects;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
     Member<WebGLBuffer> m_boundArrayBuffer;
 
     Member<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
     Member<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
-    bool m_preservedDefaultVAOObjectWrapper;
-    void setBoundVertexArrayObject(ScriptState*, WebGLVertexArrayObjectBase*);
+    void setBoundVertexArrayObject(WebGLVertexArrayObjectBase*);
 
     enum VertexAttribValueType {
         Float32ArrayType,
         Int32ArrayType,
         Uint32ArrayType,
     };
 
     Vector<VertexAttribValueType> m_vertexAttribType;
     unsigned m_maxVertexAttribs;
     void setVertexAttribType(GLuint index, VertexAttribValueType);
@@ skipping 85 matching lines @@
         }
 
         const char* const* prefixes() const;
         bool matchesNameWithPrefixes(const String&) const;
 
         virtual WebGLExtension* getExtension(WebGLRenderingContextBase*) = 0;
         virtual bool supported(WebGLRenderingContextBase*) const = 0;
         virtual const char* extensionName() const = 0;
         virtual void loseExtension(bool) = 0;
 
+        // This is only used for keeping the JS wrappers of extensions alive.
+        virtual WebGLExtension* getExtensionObjectIfAlreadyEnabled() = 0;
+
         DEFINE_INLINE_VIRTUAL_TRACE() { }
 
     private:
         bool m_draft;
         const char* const* m_prefixes;
     };
 
     template <typename T>
     class TypedExtensionTracker final : public ExtensionTracker {
     public:
@@ skipping 24 matching lines @@
 
         void loseExtension(bool force) override
         {
             if (m_extension) {
                 m_extension->lose(force);
                 if (m_extension->isLost())
                     m_extension = nullptr;
             }
         }
 
+        WebGLExtension* getExtensionObjectIfAlreadyEnabled() override
+        {
+            return m_extension;
+        }
+
         DEFINE_INLINE_VIRTUAL_TRACE()
         {
             visitor->trace(m_extension);
             ExtensionTracker::trace(visitor);
         }
 
     private:
         TypedExtensionTracker(Member<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
             : ExtensionTracker(flags, prefixes)
             , m_extensionField(extensionField)
@@ skipping 372 matching lines @@
     void setBackDrawBuffer(GLenum);
     void setFramebuffer(GLenum, WebGLFramebuffer*);
 
     virtual void restoreCurrentFramebuffer();
     void restoreCurrentTexture2D();
 
     void findNewMaxNonDefaultTextureUnit();
 
     virtual void renderbufferStorageImpl(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, const char* functionName);
 
-    // Ensures that the JavaScript wrappers for objects that are
-    // latched into the context's state, or which are implicitly
-    // linked together (like programs and their attached shaders), are
-    // not garbage collected before they should be.
-    ScopedPersistent<v8::Array> m_wrappersOf2DTextures;
-    ScopedPersistent<v8::Array> m_wrappersOf2DArrayTextures;
-    ScopedPersistent<v8::Array> m_wrappersOf3DTextures;
-    ScopedPersistent<v8::Array> m_cubeMapTextureWrappers;
-    ScopedPersistent<v8::Array> m_extensionWrappers;
-
-    // The "catch-all" array for the rest of the preserved object
-    // wrappers. The enum below defines how the indices in this array
-    // are used.
-    enum PreservedWrapperIndex {
-        PreservedArrayBuffer,
-        PreservedElementArrayBuffer,
-        PreservedFramebuffer,
-        PreservedProgram,
-        PreservedRenderbuffer,
-        PreservedDefaultVAO,
-        PreservedVAO,
-        PreservedTransformFeedback,
-    };
-    ScopedPersistent<v8::Array> m_miscWrappers;
-
-    static void preserveObjectWrapper(ScriptState*, ScriptWrappable* sourceObject, v8::Local<v8::String> hiddenValueName, ScopedPersistent<v8::Array>* persistentCache, uint32_t index, ScriptWrappable* targetObject);
-
-    // Called to lazily instantiate the wrapper for the default VAO
-    // during calls to bindBuffer and vertexAttribPointer (from
-    // JavaScript).
-    void maybePreserveDefaultVAOObjectWrapper(ScriptState*);
-
     friend class WebGLStateRestorer;
     friend class WebGLRenderingContextEvictionManager;
 
     static void activateContext(WebGLRenderingContextBase*);
     static void deactivateContext(WebGLRenderingContextBase*);
     static void addToEvictedList(WebGLRenderingContextBase*);
     static void removeFromEvictedList(WebGLRenderingContextBase*);
     static void willDestroyContext(WebGLRenderingContextBase*);
     static void forciblyLoseOldestContext(const String& reason);
     // Return the least recently used context's position in the active context vector.
@@ skipping 23 matching lines @@
     bool isPaintable() const final { return drawingBuffer(); }
 };
 
 DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, context->is3d(), context.is3d());
 
 } // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif // WebGLRenderingContextBase_h