Use visitDOMWrapper to preserve WebGL JS object wrappers

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

 // 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.
 
 #ifndef WebGL2RenderingContextBase_h
 #define WebGL2RenderingContextBase_h
 
 #include "modules/webgl/WebGLExtension.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
 #include <memory>
@@ skipping 28 matching lines @@
     void bufferSubData(GLenum target, long long offset, const FlexibleArrayBufferView& data);
 
     void copyBufferSubData(GLenum, GLenum, long long, long long, long long);
     void getBufferSubData(GLenum, long long, DOMArrayBufferView*, GLuint, GLuint);
     // TODO(zmo): Obsolete, remove after WebGL2 conformance tests are updated.
     void getBufferSubData(GLenum, long long, DOMArrayBuffer*);
 
     /* Framebuffer objects */
     bool validateTexFuncLayer(const char*, GLenum texTarget, GLint layer);
     void blitFramebuffer(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum);
-    void framebufferTextureLayer(ScriptState*, GLenum, GLenum, WebGLTexture*, GLint, GLint);
+    void framebufferTextureLayer(GLenum, GLenum, WebGLTexture*, GLint, GLint);
     ScriptValue getInternalformatParameter(ScriptState*, GLenum, GLenum, GLenum);
     void invalidateFramebuffer(GLenum, const Vector<GLenum>&);
     void invalidateSubFramebuffer(GLenum, const Vector<GLenum>&, GLint, GLint, GLsizei, GLsizei);
     void readBuffer(GLenum);
 
     /* Renderbuffer objects */
     void renderbufferStorageMultisample(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
 
     /* Texture objects */
     void texImage2D(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLintptr);
@@ skipping 106 matching lines @@
     void clearBufferuiv(GLenum, GLint, DOMUint32Array*);
     void clearBufferuiv(GLenum, GLint, const Vector<GLuint>&);
     void clearBufferfv(GLenum, GLint, DOMFloat32Array*);
     void clearBufferfv(GLenum, GLint, const Vector<GLfloat>&);
     void clearBufferfi(GLenum, GLint, GLfloat, GLint);
 
     /* Query Objects */
     WebGLQuery* createQuery();
     void deleteQuery(WebGLQuery*);
     GLboolean isQuery(WebGLQuery*);
-    void beginQuery(ScriptState*, GLenum, WebGLQuery*);
+    void beginQuery(GLenum, WebGLQuery*);
     void endQuery(GLenum);
     WebGLQuery* getQuery(GLenum, GLenum);
     ScriptValue getQueryParameter(ScriptState*, WebGLQuery*, GLenum);
 
     /* Sampler Objects */
     WebGLSampler* createSampler();
     void deleteSampler(WebGLSampler*);
     GLboolean isSampler(WebGLSampler*);
-    void bindSampler(ScriptState*, GLuint, WebGLSampler*);
+    void bindSampler(GLuint, WebGLSampler*);
     void samplerParameteri(WebGLSampler*, GLenum, GLint);
     void samplerParameterf(WebGLSampler*, GLenum, GLfloat);
     ScriptValue getSamplerParameter(ScriptState*, WebGLSampler*, GLenum);
 
     /* Sync objects */
     WebGLSync* fenceSync(GLenum, GLbitfield);
     GLboolean isSync(WebGLSync*);
     void deleteSync(WebGLSync*);
     GLenum clientWaitSync(WebGLSync*, GLbitfield, GLint64);
     void waitSync(WebGLSync*, GLbitfield, GLint64);
 
     ScriptValue getSyncParameter(ScriptState*, WebGLSync*, GLenum);
 
     /* Transform Feedback */
     WebGLTransformFeedback* createTransformFeedback();
     void deleteTransformFeedback(WebGLTransformFeedback*);
     GLboolean isTransformFeedback(WebGLTransformFeedback*);
-    void bindTransformFeedback(ScriptState*, GLenum, WebGLTransformFeedback*);
+    void bindTransformFeedback(GLenum, WebGLTransformFeedback*);
     void beginTransformFeedback(GLenum);
     void endTransformFeedback();
     void transformFeedbackVaryings(WebGLProgram*, const Vector<String>&, GLenum);
     WebGLActiveInfo* getTransformFeedbackVarying(WebGLProgram*, GLuint);
     void pauseTransformFeedback();
     void resumeTransformFeedback();
     bool validateTransformFeedbackPrimitiveMode(const char* functionName, GLenum primitiveMode);
 
     /* Uniform Buffer Objects and Transform Feedback Buffers */
     void bindBufferBase(GLenum, GLuint, WebGLBuffer*);
     void bindBufferRange(GLenum, GLuint, WebGLBuffer*, long long, long long);
     ScriptValue getIndexedParameter(ScriptState*, GLenum, GLuint);
     Vector<GLuint> getUniformIndices(WebGLProgram*, const Vector<String>&);
     ScriptValue getActiveUniforms(ScriptState*, WebGLProgram*, const Vector<GLuint>&, GLenum);
     GLuint getUniformBlockIndex(WebGLProgram*, const String&);
     ScriptValue getActiveUniformBlockParameter(ScriptState*, WebGLProgram*, GLuint, GLenum);
     String getActiveUniformBlockName(WebGLProgram*, GLuint);
     void uniformBlockBinding(WebGLProgram*, GLuint, GLuint);
 
     /* Vertex Array Objects */
     WebGLVertexArrayObject* createVertexArray();
-    void deleteVertexArray(ScriptState*, WebGLVertexArrayObject*);
+    void deleteVertexArray(WebGLVertexArrayObject*);
     GLboolean isVertexArray(WebGLVertexArrayObject*);
-    void bindVertexArray(ScriptState*, WebGLVertexArrayObject*);
+    void bindVertexArray(WebGLVertexArrayObject*);
 
     /* Reading */
     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, long long offset);
 
     /* WebGLRenderingContextBase overrides */
     void initializeNewContext() override;
-    void bindFramebuffer(ScriptState*, GLenum target, WebGLFramebuffer*) override;
+    void bindFramebuffer(GLenum target, WebGLFramebuffer*) override;
     void deleteFramebuffer(WebGLFramebuffer*) override;
     ScriptValue getParameter(ScriptState*, GLenum pname) override;
     ScriptValue getTexParameter(ScriptState*, GLenum target, GLenum pname) override;
     ScriptValue getFramebufferAttachmentParameter(ScriptState*, GLenum target, GLenum attachment, GLenum pname) override;
     void pixelStorei(GLenum pname, GLint param) override;
     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels) override;
     void restoreCurrentFramebuffer() override;
 
     EAGERLY_FINALIZE();
     DECLARE_VIRTUAL_TRACE();
 
 protected:
+    friend class V8WebGL2RenderingContext;
+
     WebGL2RenderingContextBase(HTMLCanvasElement*, std::unique_ptr<WebGraphicsContext3DProvider>, const CanvasContextCreationAttributes& requestedAttributes);
 
     // Helper function to validate target and the attachment combination for getFramebufferAttachmentParameters.
     // Generate GL error and return false if parameters are illegal.
     bool validateGetFramebufferAttachmentParameterFunc(const char* functionName, GLenum target, GLenum attachment);
 
     bool validateClearBuffer(const char* functionName, GLenum buffer, GLsizei length);
 
     enum TexStorageType {
         TexStorageType2D,
@@ skipping 41 matching lines @@
     WebGLBuffer* validateBufferDataTarget(const char* functionName, GLenum target) override;
     bool validateBufferDataUsage(const char* functionName, GLenum usage) override;
 
     bool canUseTexImageByGPU(TexImageFunctionID, GLint internalformat, GLenum type) override;
 
     void removeBoundBuffer(WebGLBuffer*) override;
 
     void resetUnpackParameters() override;
     void restoreUnpackParameters() override;
 
+    void visitChildDOMWrappers(v8::Isolate*, const v8::Persistent<v8::Object>&) override;
+
     void renderbufferStorageHelper(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, const char* functionName);
 
     Member<WebGLFramebuffer> m_readFramebufferBinding;
     Member<WebGLTransformFeedback> m_transformFeedbackBinding;
 
     std::set<GLenum> m_supportedInternalFormatsStorage;
     std::set<GLenum> m_compressedTextureFormatsETC2EAC;
 
     Member<WebGLBuffer> m_boundCopyReadBuffer;
     Member<WebGLBuffer> m_boundCopyWriteBuffer;
@@ skipping 12 matching lines @@
     HeapVector<Member<WebGLSampler>> m_samplerUnits;
 
     GLint m_packRowLength;
     GLint m_packSkipPixels;
     GLint m_packSkipRows;
     GLint m_unpackRowLength;
     GLint m_unpackImageHeight;
     GLint m_unpackSkipPixels;
     GLint m_unpackSkipRows;
     GLint m_unpackSkipImages;
-
-    ScopedPersistent<v8::Array> m_samplerWrappers;
-    ScopedPersistent<v8::Array> m_queryWrappers;
 };
 
 DEFINE_TYPE_CASTS(WebGL2RenderingContextBase, CanvasRenderingContext, context,
     context->is3d() && WebGLRenderingContextBase::getWebGLVersion(context) >= 2,
     context.is3d() && WebGLRenderingContextBase::getWebGLVersion(&context) >= 2);
 
 } // namespace blink
 
 #endif