[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();
     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")
-    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;
 
     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> {
+    // TODO(Oilpan): GarbageCollectedFinalized<> can be GarbageCollected<> if
+    // WebGLRenderingContextBase becomes a GCed class.
+    class ExtensionTracker : public GarbageCollectedFinalized<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 {
+        // TODO(Oilpan): We can remove this EAGERLY_FINALIZE() if
+        // WebGLRenderingContextBase becomes a GCed class.

[sof, 2015/08/06 06:46:30]

Isn't this always handled by the (eager) finalizer for WebGLRenderingContextBase
already? I don't understand why a change is needed.

[sof, 2015/08/06 07:38:39]

If you do need eager finalization in some form here, that annotation needs to be
moved up to ExtensionTracker. But I still don't understand its purpose.

[peria, 2015/08/06 07:38:46]

On non-Oilpan build, WebGLRendingContextBase's finalizer (dtor)
does not handle lifetime of this class, though it releases
persistent pointers to this class.

[sof, 2015/08/06 07:43:29]

If so, then I think it would be preferable to explicitly dispose the extensions
from its dtor. 

[peria, 2015/08/06 08:04:22]

SGTM!
Done.

+        EAGERLY_FINALIZE();
     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;
         // 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