Oilpan: move 2D Canvas and WebGL objects to the heap.

Source/core/html/canvas/WebGLRenderingContextBase.h

Index: Source/core/html/canvas/WebGLRenderingContextBase.h
diff --git a/Source/core/html/canvas/WebGLRenderingContextBase.h b/Source/core/html/canvas/WebGLRenderingContextBase.h
index afa9619774cb74963830b03384933c9c9343b893..b255f920e6c53df0363fc8ac8354610d4afee487 100644
--- a/Source/core/html/canvas/WebGLRenderingContextBase.h
+++ b/Source/core/html/canvas/WebGLRenderingContextBase.h
@@ -146,12 +146,12 @@ public:
     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);
 
-    PassRefPtr<WebGLBuffer> createBuffer();
-    PassRefPtr<WebGLFramebuffer> createFramebuffer();
-    PassRefPtr<WebGLProgram> createProgram();
-    PassRefPtr<WebGLRenderbuffer> createRenderbuffer();
-    PassRefPtr<WebGLShader> createShader(GLenum type);
-    PassRefPtr<WebGLTexture> createTexture();
+    PassRefPtrWillBeRawPtr<WebGLBuffer> createBuffer();
+    PassRefPtrWillBeRawPtr<WebGLFramebuffer> createFramebuffer();
+    PassRefPtrWillBeRawPtr<WebGLProgram> createProgram();
+    PassRefPtrWillBeRawPtr<WebGLRenderbuffer> createRenderbuffer();
+    PassRefPtrWillBeRawPtr<WebGLShader> createShader(GLenum type);
+    PassRefPtrWillBeRawPtr<WebGLTexture> createTexture();
 
     void cullFace(GLenum mode);
 
@@ -183,14 +183,14 @@ public:
     void frontFace(GLenum mode);
     void generateMipmap(GLenum target);
 
-    PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
-    PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
-    bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader> >&);
+    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
+    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
+    bool getAttachedShaders(WebGLProgram*, WillBeHeapVector<RefPtrWillBeMember<WebGLShader> >&);
     GLint getAttribLocation(WebGLProgram*, const String& name);
     WebGLGetInfo getBufferParameter(GLenum target, GLenum pname);
-    PassRefPtr<WebGLContextAttributes> getContextAttributes();
+    PassRefPtrWillBeRawPtr<WebGLContextAttributes> getContextAttributes();
     GLenum getError();
-    PassRefPtr<WebGLExtension> getExtension(const String& name);
+    PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(const String& name);
     WebGLGetInfo getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
     WebGLGetInfo getParameter(GLenum pname);
     WebGLGetInfo getProgramParameter(WebGLProgram*, GLenum pname);
@@ -198,12 +198,12 @@ public:
     WebGLGetInfo getRenderbufferParameter(GLenum target, GLenum pname);
     WebGLGetInfo getShaderParameter(WebGLShader*, GLenum pname);
     String getShaderInfoLog(WebGLShader*);
-    PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType);
+    PassRefPtrWillBeRawPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType);
     String getShaderSource(WebGLShader*);
     Vector<String> getSupportedExtensions();
     WebGLGetInfo getTexParameter(GLenum target, GLenum pname);
     WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*);
-    PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
+    PassRefPtrWillBeRawPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
     WebGLGetInfo getVertexAttrib(GLuint index, GLenum pname);
     long long getVertexAttribOffset(GLuint index, GLenum pname);
 
@@ -349,6 +349,18 @@ public:
     virtual void stop() OVERRIDE;
 
     void setSavingImage(bool isSaving) { m_savingImage = isSaving; }
+
+    virtual void trace(Visitor*) OVERRIDE;
+
+    class TextureUnitState {
+        ALLOW_ONLY_INLINE_ALLOCATION();
+    public:
+        RefPtrWillBeMember<WebGLTexture> m_texture2DBinding;
+        RefPtrWillBeMember<WebGLTexture> m_textureCubeMapBinding;
+
+        void trace(Visitor*);
+    };
+
 protected:
     friend class WebGLDrawBuffers;
     friend class WebGLFramebuffer;
@@ -402,7 +414,7 @@ protected:
     // Structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
     RefPtr<DrawingBuffer> m_drawingBuffer;
-    RefPtr<WebGLContextGroup> m_contextGroup;
+    RefPtrWillBeMember<WebGLContextGroup> m_contextGroup;
 
     // Dispatches a context lost event once it is determined that one is needed.
     // This is used both for synthetic and real context losses. For real ones, it's
@@ -415,17 +427,17 @@ protected:
 
     bool m_needsUpdate;
     bool m_markedCanvasDirty;
-    HashSet<WebGLContextObject*> m_contextObjects;
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject> > m_contextObjects;
 
     OwnPtr<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
     OwnPtr<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
-    RefPtr<WebGLBuffer> m_boundArrayBuffer;
+    RefPtrWillBeMember<WebGLBuffer> m_boundArrayBuffer;
 
-    RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
-    RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
-    void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> arrayObject)
+    RefPtrWillBeMember<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
+    RefPtrWillBeMember<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
+    void setBoundVertexArrayObject(PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> arrayObject)
     {
         if (arrayObject)
             m_boundVertexArrayObject = arrayObject;
@@ -452,25 +464,21 @@ protected:
     };
     Vector<VertexAttribValue> m_vertexAttribValue;
     unsigned m_maxVertexAttribs;
-    RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;
+    RefPtrWillBeMember<WebGLBuffer> m_vertexAttrib0Buffer;
     long m_vertexAttrib0BufferSize;
     GLfloat m_vertexAttrib0BufferValue[4];
     bool m_forceAttrib0BufferRefill;
     bool m_vertexAttrib0UsedBefore;
 
-    RefPtr<WebGLProgram> m_currentProgram;
-    RefPtr<WebGLFramebuffer> m_framebufferBinding;
-    RefPtr<WebGLRenderbuffer> m_renderbufferBinding;
-    class TextureUnitState {
-    public:
-        RefPtr<WebGLTexture> m_texture2DBinding;
-        RefPtr<WebGLTexture> m_textureCubeMapBinding;
-    };
-    Vector<TextureUnitState> m_textureUnits;
+    RefPtrWillBeMember<WebGLProgram> m_currentProgram;
+    RefPtrWillBeMember<WebGLFramebuffer> m_framebufferBinding;
+    RefPtrWillBeMember<WebGLRenderbuffer> m_renderbufferBinding;
+
+    WillBeHeapVector<TextureUnitState> m_textureUnits;
     unsigned long m_activeTextureUnit;
 
-    RefPtr<WebGLTexture> m_blackTexture2D;
-    RefPtr<WebGLTexture> m_blackTextureCubeMap;
+    RefPtrWillBeMember<WebGLTexture> m_blackTexture2D;
+    RefPtrWillBeMember<WebGLTexture> m_blackTextureCubeMap;
 
     Vector<GLenum> m_compressedTextureFormats;
 
@@ -507,7 +515,7 @@ protected:
     GLenum m_unpackColorspaceConversion;
     bool m_contextLost;
     LostContextMode m_contextLostMode;
-    RefPtr<WebGLContextAttributes> m_requestedAttributes;
+    RefPtrWillBeMember<WebGLContextAttributes> m_requestedAttributes;
 
     bool m_layerCleared;
     GLfloat m_clearColor[4];
@@ -544,7 +552,7 @@ protected:
         DraftExtension                  = 0x01,
     };
 
-    class ExtensionTracker {
+    class ExtensionTracker : public NoBaseWillBeGarbageCollected<ExtensionTracker> {
     public:
         ExtensionTracker(ExtensionFlags flags, const char* const* prefixes)
             : m_draft(flags & DraftExtension)
@@ -552,9 +560,11 @@ protected:
         {
         }
 
+#if !ENABLE(OILPAN)
         virtual ~ExtensionTracker()
         {
         }
+#endif
 
         bool draft() const
         {
@@ -564,11 +574,13 @@ protected:
         const char* const* prefixes() const;
         bool matchesNameWithPrefixes(const String&) const;
 
-        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContextBase*) = 0;
+        virtual PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase*) = 0;
         virtual bool supported(WebGLRenderingContextBase*) const = 0;
         virtual const char* extensionName() const = 0;
         virtual void loseExtension() = 0;
 
+        virtual void trace(Visitor*) { }
+
     private:
         bool m_draft;
         const char* const* m_prefixes;
@@ -577,13 +589,14 @@ protected:
     template <typename T>
     class TypedExtensionTracker FINAL : public ExtensionTracker {
     public:
-        TypedExtensionTracker(RefPtr<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+        TypedExtensionTracker(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
             : ExtensionTracker(flags, prefixes)
             , m_extensionField(extensionField)
             , m_extension(nullptr)
         {
         }
 
+#if !ENABLE(OILPAN)
         virtual ~TypedExtensionTracker()
         {
             if (m_extension) {
@@ -591,8 +604,9 @@ protected:
                 m_extension = nullptr;
             }
         }
+#endif
 
-        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context) OVERRIDE
+        virtual PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context) OVERRIDE
         {
             if (!m_extension) {
                 m_extension = T::create(context);
@@ -621,18 +635,25 @@ protected:
             }
         }
 
+        virtual void trace(Visitor* visitor) OVERRIDE
+        {
+            visitor->trace(m_extensionField);
+            visitor->trace(m_extension);
+            ExtensionTracker::trace(visitor);
+        }
+
     private:
-        RefPtr<T>& m_extensionField;
+        RefPtrWillBeMember<T>& m_extensionField;

[haraken, 2014/07/02 07:47:39]

It looks weird to use RefPtrWillBeMember<T>&...

Even if we need to use the reference, I guess we won't need to trace it, since a
real owner of the RefPtrWillBeMember should be tracing it.

[sof, 2014/07/02 11:43:53]

Dropped tracing off it; I don't see a ready way around "forwarding" the
extension to the underlying field once it is created.

         // ExtensionTracker holds it's own reference to the extension to ensure
         // that it is not deleted before this object's destructor is called
-        RefPtr<T> m_extension;
+        RefPtrWillBeMember<T> m_extension;
     };
 
     bool m_extensionEnabled[WebGLExtensionNameCount];
-    Vector<ExtensionTracker*> m_extensions;
+    WillBeHeapVector<RawPtrWillBeMember<ExtensionTracker> > m_extensions;

[haraken, 2014/07/02 07:47:39]

Not related to this CL, we should use OwnPtr<ExtensionTracker> in oilpan builds.
WebGLRenderingContextBase should own those extensions.

[sof, 2014/07/02 11:43:53]

That would be tidier (and not have to keep them on the heap); switched. That is,
an off-heap Vector of OwnPtrs (which we do trace.)

 
     template <typename T>
-    void registerExtension(RefPtr<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = 0)
+    void registerExtension(RefPtrWillBeMember<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = 0)
     {
         m_extensions.append(new TypedExtensionTracker<T>(extensionPtr, flags, prefixes));
     }
@@ -908,4 +929,6 @@ DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, co
 
 } // namespace WebCore
 
+WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(WebCore::WebGLRenderingContextBase::TextureUnitState);

[haraken, 2014/07/02 07:47:39]

Is it safe to move TextureUnitState with memcpy even though TextureUnitState
contains RefPtrs?

[sof, 2014/07/02 11:43:53]

Yes; under what conditions could a bit-preserving move be observable? I can't
think of any.

(The question suggests that there are some, however. :) )

+
 #endif // WebGLRenderingContextBase_h