[Oilpan] Migrate classes under module/webgl onto oilpan heap

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 155 matching lines @@
     void clearStencil(GLint);
     void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
     void compileShader(WebGLShader*);
 
     void compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, DOMArrayBufferView* data);
     void compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, DOMArrayBufferView* data);
 
     void copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
     void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 
-    PassRefPtrWillBeRawPtr<WebGLBuffer> createBuffer();
-    PassRefPtrWillBeRawPtr<WebGLFramebuffer> createFramebuffer();
-    PassRefPtrWillBeRawPtr<WebGLProgram> createProgram();
-    PassRefPtrWillBeRawPtr<WebGLRenderbuffer> createRenderbuffer();
-    PassRefPtrWillBeRawPtr<WebGLShader> createShader(GLenum type);
-    PassRefPtrWillBeRawPtr<WebGLTexture> createTexture();
+    WebGLBuffer* createBuffer();
+    WebGLFramebuffer* createFramebuffer();
+    WebGLProgram* createProgram();
+    WebGLRenderbuffer* createRenderbuffer();
+    WebGLShader* createShader(GLenum type);
+    WebGLTexture* createTexture();
 
     void cullFace(GLenum mode);
 
     void deleteBuffer(WebGLBuffer*);
     virtual void deleteFramebuffer(WebGLFramebuffer*);
     void deleteProgram(WebGLProgram*);
     void deleteRenderbuffer(WebGLRenderbuffer*);
     void deleteShader(WebGLShader*);
     void deleteTexture(WebGLTexture*);
 
@@ skipping 11 matching lines @@
 
     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 frontFace(GLenum mode);
     void generateMipmap(GLenum target);
 
-    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
-    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
-    bool getAttachedShaders(WebGLProgram*, WillBeHeapVector<RefPtrWillBeMember<WebGLShader>>&);
-    Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader>>> getAttachedShaders(WebGLProgram*);
+    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>&);
     GLenum getError();
     ScriptValue getExtension(ScriptState*, const String& name);
     virtual ScriptValue getFramebufferAttachmentParameter(ScriptState*, GLenum target, GLenum attachment, GLenum pname);
     virtual ScriptValue getParameter(ScriptState*, GLenum pname);
     ScriptValue getProgramParameter(ScriptState*, WebGLProgram*, GLenum pname);
     String getProgramInfoLog(WebGLProgram*);
     ScriptValue getRenderbufferParameter(ScriptState*, GLenum target, GLenum pname);
     ScriptValue getShaderParameter(ScriptState*, WebGLShader*, GLenum pname);
     String getShaderInfoLog(WebGLShader*);
-    PassRefPtrWillBeRawPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType);
+    WebGLShaderPrecisionFormat* getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType);
     String getShaderSource(WebGLShader*);
     Nullable<Vector<String>> getSupportedExtensions();
     virtual ScriptValue getTexParameter(ScriptState*, GLenum target, GLenum pname);
     ScriptValue getUniform(ScriptState*, WebGLProgram*, const WebGLUniformLocation*);
-    PassRefPtrWillBeRawPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
+    WebGLUniformLocation* getUniformLocation(WebGLProgram*, const String&);
     ScriptValue getVertexAttrib(ScriptState*, GLuint index, GLenum pname);
     long long getVertexAttribOffset(GLuint index, GLenum pname);
 
     void hint(GLenum target, GLenum mode);
     GLboolean isBuffer(WebGLBuffer*);
     bool isContextLost() const override;
     GLboolean isEnabled(GLenum cap);
     GLboolean isFramebuffer(WebGLFramebuffer*);
     GLboolean isProgram(WebGLProgram*);
     GLboolean isRenderbuffer(WebGLRenderbuffer*);
@@ skipping 120 matching lines @@
 
     void markLayerComposited() override;
     ImageData* paintRenderingResultsToImageData(SourceDrawingBuffer) override;
 
     void removeSharedObject(WebGLSharedObject*);
     void removeContextObject(WebGLContextObject*);
 
     unsigned maxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // GL_CHROMIUM_subscribe_uniform
-    PassRefPtrWillBeRawPtr<CHROMIUMValuebuffer> createValuebufferCHROMIUM();
+    CHROMIUMValuebuffer* createValuebufferCHROMIUM();
     void deleteValuebufferCHROMIUM(CHROMIUMValuebuffer*);
     GLboolean isValuebufferCHROMIUM(CHROMIUMValuebuffer*);
     void bindValuebufferCHROMIUM(GLenum target, CHROMIUMValuebuffer*);
     void subscribeValueCHROMIUM(GLenum target, GLenum subscription);
     void populateSubscribedValuesCHROMIUM(GLenum target);
     void uniformValuebufferCHROMIUM(const WebGLUniformLocation*, GLenum target, GLenum subscription);
 
     // Eagerly finalize WebGLRenderingContextBase in order for it
     // to (first) be able to detach its WebGLContextObjects, before
     // they're later swept and finalized.
     EAGERLY_FINALIZE();

[haraken, 2015/08/04 00:06:52]

Sigbjorn: It looks like the destructor of WebGLRenderingContextBase is touching
a lot of on-heap objects (I couldn't verify that they are not touching
eagerly-finalized objects). Maybe it would be safer to make it a pre-finalizer
given that the number of WebGLRenderingContextBase should be limited.

[sof, 2015/08/04 05:11:56]

They're all WebGLObjects (and WebGLSharedObjects), and there's no
conflict/problematic access on finalization. WebGLRenderingContextBase was one
of the motivations for introducing eager finalization. Having it in place
allowed us to remove the involved finalization protocol that was used prior to
that for Oilpan.

     DECLARE_VIRTUAL_TRACE();
 
     // Returns approximate gpu memory allocated per pixel.
     int externallyAllocatedBytesPerPixel() override;
 
     class TextureUnitState {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        RefPtrWillBeMember<WebGLTexture> m_texture2DBinding;
-        RefPtrWillBeMember<WebGLTexture> m_textureCubeMapBinding;
-        RefPtrWillBeMember<WebGLTexture> m_texture3DBinding;
-        RefPtrWillBeMember<WebGLTexture> m_texture2DArrayBinding;
+        Member<WebGLTexture> m_texture2DBinding;
+        Member<WebGLTexture> m_textureCubeMapBinding;
+        Member<WebGLTexture> m_texture3DBinding;
+        Member<WebGLTexture> m_texture2DArrayBinding;
 
         DECLARE_TRACE();
     };
 
     void setFilterQuality(SkFilterQuality) override;
     bool isWebGL2OrHigher() { return version() >= 2; }
 
 protected:
     friend class WebGLDrawBuffers;
     friend class WebGLFramebuffer;
@@ skipping 65 matching lines @@
     // Dispatches a context lost event once it is determined that one is needed.
     // This is used for synthetic, WEBGL_lose_context and real context losses. For real ones, it's
     // likely that there's no JavaScript on the stack, but that might be dependent
     // on how exactly the platform discovers that the context was lost. For better
     // portability we always defer the dispatch of the event.
     Timer<WebGLRenderingContextBase> m_dispatchContextLostEventTimer;
     bool m_restoreAllowed;
     Timer<WebGLRenderingContextBase> m_restoreTimer;
 
     bool m_markedCanvasDirty;
-    WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject>> m_contextObjects;
+    PersistentHeapHashSetWillBeHeapHashSet<WeakMember<WebGLContextObject>> m_contextObjects;
 
-    OwnPtrWillBeMember<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
-    OwnPtrWillBeMember<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
+    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
-    RefPtrWillBeMember<WebGLBuffer> m_boundArrayBuffer;
+    PersistentWillBeMember<WebGLBuffer> m_boundArrayBuffer;
 
-    RefPtrWillBeMember<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
-    RefPtrWillBeMember<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
-    void setBoundVertexArrayObject(PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectBase> arrayObject)
+    PersistentWillBeMember<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
+    PersistentWillBeMember<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
+    void setBoundVertexArrayObject(WebGLVertexArrayObjectBase* arrayObject)
     {
         if (arrayObject)
             m_boundVertexArrayObject = arrayObject;
         else
             m_boundVertexArrayObject = m_defaultVertexArrayObject;
     }
 
     enum VertexAttribValueType {
         Float32ArrayType,
         Int32ArrayType,
@@ skipping 18 matching lines @@
 
         VertexAttribValueType type;
         union {
             GLfloat floatValue[4];
             GLint intValue[4];
             GLuint uintValue[4];
         } value;
     };
     Vector<VertexAttribValue> m_vertexAttribValue;
     unsigned m_maxVertexAttribs;
-    RefPtrWillBeMember<WebGLBuffer> m_vertexAttrib0Buffer;
+    PersistentWillBeMember<WebGLBuffer> m_vertexAttrib0Buffer;
     long m_vertexAttrib0BufferSize;
     GLfloat m_vertexAttrib0BufferValue[4];
     bool m_forceAttrib0BufferRefill;
     bool m_vertexAttrib0UsedBefore;
 
-    RefPtrWillBeMember<WebGLProgram> m_currentProgram;
-    RefPtrWillBeMember<WebGLFramebuffer> m_framebufferBinding;
-    RefPtrWillBeMember<WebGLRenderbuffer> m_renderbufferBinding;
-    RefPtrWillBeMember<CHROMIUMValuebuffer> m_valuebufferBinding;
+    PersistentWillBeMember<WebGLProgram> m_currentProgram;
+    PersistentWillBeMember<WebGLFramebuffer> m_framebufferBinding;
+    PersistentWillBeMember<WebGLRenderbuffer> m_renderbufferBinding;
+    PersistentWillBeMember<CHROMIUMValuebuffer> m_valuebufferBinding;
 
     GC_PLUGIN_IGNORE("crbug.com/496496")

[haraken, 2015/08/04 00:06:52]

I think we should remove the GC_PLUGIN_IGNORE by removing the code that clears
m_textureUnits[i] in WebGLRenderingContextBase's destructor.

Let's address it in a follow-up CL.

[peria, 2015/08/04 09:10:26]

Acknowledged.
http://crbug.com/516604

-    WillBeHeapVector<TextureUnitState> m_textureUnits;
+    PersistentHeapVectorWillBeHeapVector<TextureUnitState> m_textureUnits;
     unsigned long m_activeTextureUnit;
 
-    RefPtrWillBeMember<WebGLTexture> m_blackTexture2D;
-    RefPtrWillBeMember<WebGLTexture> m_blackTextureCubeMap;
+    PersistentWillBeMember<WebGLTexture> m_blackTexture2D;
+    PersistentWillBeMember<WebGLTexture> m_blackTextureCubeMap;

[haraken, 2015/08/04 00:06:52]

Ditto. Let's move CanvasRenderingContext to the oilpan heap and remove these
persistent handles in a follow-up CL.

[peria, 2015/08/04 09:10:26]

Acknowledged.

 
     Vector<GLenum> m_compressedTextureFormats;
 
     // Fixed-size cache of reusable image buffers for video texImage2D calls.
     class LRUImageBufferCache {
     public:
         LRUImageBufferCache(int capacity);
         // The pointer returned is owned by the image buffer map.
         ImageBuffer* imageBuffer(const IntSize& size);
     private:
@@ skipping 48 matching lines @@
     unsigned long m_onePlusMaxNonDefaultTextureUnit;
 
     OwnPtr<Extensions3DUtil> m_extensionsUtil;
 
     enum ExtensionFlags {
         ApprovedExtension               = 0x00,
         // Extension that is behind the draft extensions runtime flag:
         DraftExtension                  = 0x01,
     };
 
-    class ExtensionTracker : public NoBaseWillBeGarbageCollected<ExtensionTracker> {
+    class ExtensionTracker : public GarbageCollected<ExtensionTracker> {
     public:
         ExtensionTracker(ExtensionFlags flags, const char* const* prefixes)
             : m_draft(flags & DraftExtension)
             , m_prefixes(prefixes)
         {
         }
 
-#if !ENABLE(OILPAN)
-        virtual ~ExtensionTracker()
-        {
-        }
-#endif
-
         bool draft() const
         {
             return m_draft;
         }
 
         const char* const* prefixes() const;
         bool matchesNameWithPrefixes(const String&) const;
 
-        virtual PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase*) = 0;
+        virtual WebGLExtension* getExtension(WebGLRenderingContextBase*) = 0;
         virtual bool supported(WebGLRenderingContextBase*) const = 0;
         virtual const char* extensionName() const = 0;
         virtual void loseExtension() = 0;
 
         DEFINE_INLINE_VIRTUAL_TRACE() { }
 
     private:
         bool m_draft;
         const char* const* m_prefixes;
     };
 
     template <typename T>
     class TypedExtensionTracker final : public ExtensionTracker {
     public:
-        static PassOwnPtrWillBeRawPtr<TypedExtensionTracker<T>> create(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+        static TypedExtensionTracker<T>* create(PersistentWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
         {
-            return adoptPtrWillBeNoop(new TypedExtensionTracker<T>(extensionField, flags, prefixes));
+            return new TypedExtensionTracker<T>(extensionField, flags, prefixes);
         }
 
-#if !ENABLE(OILPAN)
-        ~TypedExtensionTracker() override
-        {
-            if (m_extension) {
-                m_extension->lose(true);
-                m_extension = nullptr;
-            }
-        }
-#endif
-
-        PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context) override
+        WebGLExtension* getExtension(WebGLRenderingContextBase* context) override
         {
             if (!m_extension) {
                 m_extension = T::create(context);
                 m_extensionField = m_extension;
             }
 
             return m_extension;
         }
 
         bool supported(WebGLRenderingContextBase* context) const override
@@ skipping 15 matching lines @@
             }
         }
 
         DEFINE_INLINE_VIRTUAL_TRACE()
         {
             visitor->trace(m_extension);
             ExtensionTracker::trace(visitor);
         }
 
     private:
-        TypedExtensionTracker(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+        TypedExtensionTracker(PersistentWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
             : ExtensionTracker(flags, prefixes)
             , m_extensionField(extensionField)
         {
         }
 
-        RefPtrWillBeMember<T>& m_extensionField;
+        PersistentWillBeMember<T>& m_extensionField;

[haraken, 2015/08/04 00:06:52]

It looks really nasty to keep a reference to a PersistentWillBeMember. BTW, what
is m_extensionField used for? Maybe we can just remove it?

[Ken Russell (switch to Gerrit), 2015/08/04 00:34:11]

I'm pretty sure that this is intended to keep the JavaScript-side extension
object alive for the lifetime of the WebGLRenderingContext. The spec says that
once you fetch a particular extension for a context (e.g.
gl.getExtension("OES_texture_float"), the same exact object is returned for all
future getExtension calls. There are conformance tests that verify that
user-defined expando properties on these objects continue to exist over time.

[haraken, 2015/08/04 00:47:05]

Maybe a better idea would be:

- make TypedExtensionTracker hold a strong reference to WebGL2RenderingContext.
- call WebGL2RenderingContext::setExtension(extension) when the
TypedExtensionTracker needs to set the extension on the things on the
WebGL2RenderingContext.

[Ken Russell (switch to Gerrit), 2015/08/04 00:54:19]

I'm not sure I understand the second suggestion.

To be clear: WebGLRenderingContext::getExtension maps strings to objects. See
https://www.khronos.org/registry/webgl/specs/latest/1.0/ . The invariant is that
for a particular extension string, the same exact extension object must always
be returned for the life of the WebGL context. So long as that invariant is
maintained, the structure can be changed however you like for Oilpan.

         // ExtensionTracker holds it's own reference to the extension to ensure
         // that it is not deleted before this object's destructor is called
-        RefPtrWillBeMember<T> m_extension;
+        Member<T> m_extension;
     };
 
     bool m_extensionEnabled[WebGLExtensionNameCount];
-    WillBeHeapVector<OwnPtrWillBeMember<ExtensionTracker>> m_extensions;
+    PersistentHeapVectorWillBeHeapVector<Member<ExtensionTracker>> m_extensions;
 
     template <typename T>
-    void registerExtension(RefPtrWillBeMember<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = 0)
+    void registerExtension(PersistentWillBeMember<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = nullptr)
     {
         m_extensions.append(TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
     }
 
     bool extensionSupportedAndAllowed(const ExtensionTracker*);
 
     inline bool extensionEnabled(WebGLExtensionName name)
     {
         return m_extensionEnabled[name];
     }
@@ skipping 317 matching lines @@
     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