Fixed expando-loss.html test.

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
@@ skipping 152 matching lines @@
 
     static unsigned getWebGLVersion(const CanvasRenderingContext*);
 
     static PassOwnPtr<WebGraphicsContext3D> createWebGraphicsContext3D(HTMLCanvasElement*, WebGLContextAttributes, unsigned webGLVersion);
     static void forceNextWebGLContextCreationToFail();
 
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
     void activeTexture(GLenum texture);
-    void attachShader(WebGLProgram*, WebGLShader*);
+    void attachShader(ScriptState*, WebGLProgram*, WebGLShader*);
     void bindAttribLocation(WebGLProgram*, GLuint index, const String& name);
-    void bindBuffer(GLenum target, WebGLBuffer*);
-    virtual void bindFramebuffer(GLenum target, WebGLFramebuffer*);
-    void bindRenderbuffer(GLenum target, WebGLRenderbuffer*);
-    void bindTexture(GLenum target, WebGLTexture*);
+    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 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(WebGLProgram*, WebGLShader*);
+    void detachShader(ScriptState*, 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(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer*);
-    void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture*, GLint level);
+    void framebufferRenderbuffer(ScriptState*, GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer*);
+    void framebufferTexture2D(ScriptState*, 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 92 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(WebGLProgram*);
+    void useProgram(ScriptState*, 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(GLuint index, GLint size, GLenum type, GLboolean normalized,
+    void vertexAttribPointer(ScriptState*, 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 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;
 
-    WebGLRenderingContextBase(HTMLCanvasElement*, PassOwnPtr<WebGraphicsContext3D>, const WebGLContextAttributes&);
+    WebGLRenderingContextBase(HTMLCanvasElement*, ScriptState*, PassOwnPtr<WebGraphicsContext3D>, const WebGLContextAttributes&);
     PassRefPtr<DrawingBuffer> createDrawingBuffer(PassOwnPtr<WebGraphicsContext3D>);
     void setupFlags();
 
     // CanvasRenderingContext implementation.
     bool is3d() const override { return true; }
     bool isAccelerated() const override { return true; }
     void setIsHidden(bool) override;
     bool paintRenderingResultsToCanvas(SourceDrawingBuffer) override;
     WebLayer* platformLayer() const override;
     void stop() override;
@@ skipping 22 matching lines @@
     // Adds a compressed texture format.
     void addCompressedTextureFormat(GLenum);
     void removeAllCompressedTextureFormats();
 
     PassRefPtr<Image> drawImageIntoBuffer(PassRefPtr<Image>, int width, int height, const char* functionName);
 
     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*);
 
     WebGLRenderbuffer* ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer*);
 
+    // ScriptState at the time the context was created.
+    RefPtr<ScriptState> m_scriptState;
+
     // 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;
 
     LostContextMode m_contextLostMode;
     AutoRecoveryMethod m_autoRecoveryMethod;
     // Dispatches a context lost event once it is determined that one is needed.
@@ skipping 18 matching lines @@
 #endif
 
     PersistentWillBeMember<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
     PersistentWillBeMember<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
     PersistentWillBeMember<WebGLBuffer> m_boundArrayBuffer;
 
     PersistentWillBeMember<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
     PersistentWillBeMember<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
-    void setBoundVertexArrayObject(WebGLVertexArrayObjectBase* arrayObject)
-    {
-        if (arrayObject)
-            m_boundVertexArrayObject = arrayObject;
-        else
-            m_boundVertexArrayObject = m_defaultVertexArrayObject;
-    }
+    void setBoundVertexArrayObject(ScriptState*, WebGLVertexArrayObjectBase*);
 
     enum VertexAttribValueType {
         Float32ArrayType,
         Int32ArrayType,
         Uint32ArrayType,
     };
 
     class VertexAttribValue {
     public:
         VertexAttribValue()
@@ skipping 546 matching lines @@
 
     virtual void restoreCurrentFramebuffer();
     void restoreCurrentTexture2D();
 
     void multisamplingChanged(bool) override;
 
     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.
+    static void preserveObjectWrapper(ScriptState*, ScriptWrappable* sourceObject, const char* baseName, unsigned long index, ScriptWrappable* targetObject);
+    void maybePreserveDefaultVAOObjectWrapper(ScriptState*);
+
     friend class WebGLStateRestorer;
     friend class WebGLRenderingContextEvictionManager;
 
     static Vector<WebGLRenderingContextBase*>& activeContexts();
     static Vector<WebGLRenderingContextBase*>& forciblyEvictedContexts();
 
     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.
     // If the vector is empty, return the maximum allowed active context number.
     static size_t oldestContextIndex();
     static IntSize oldestContextSize();
 };
 
 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