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

Source/core/html/canvas/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 73 matching lines @@
 class WebGLDrawBuffers;
 class WebGLExtension;
 class WebGLFramebuffer;
 class WebGLLoseContext;
 class WebGLObject;
 class WebGLProgram;
 class WebGLRenderbuffer;
 class WebGLShader;
 class WebGLShaderPrecisionFormat;
 class WebGLSharedObject;
+class WebGLSharedWebGraphicsContext3D;
 class WebGLTexture;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
 
 class WebGLRenderingContextLostCallback;
 class WebGLRenderingContextErrorMessageCallback;
 
 class WebGLRenderingContextBase: public CanvasRenderingContext, public ActiveDOMObject, public Page::MultisamplingChangedObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(WebGLRenderingContextBase);
 public:
@@ skipping 36 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, ArrayBufferView* data);
     void compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* 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);
 
-    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);
 
     void deleteBuffer(WebGLBuffer*);
     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);
 
-    PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
-    PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
-    Nullable<Vector<RefPtr<WebGLShader> > > getAttachedShaders(WebGLProgram*);
+    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
+    PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
+    bool getAttachedShaders(WebGLProgram*, WillBeHeapVector<RefPtrWillBeMember<WebGLShader> >&);
+    Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader> > > getAttachedShaders(WebGLProgram*);
     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);
     String getProgramInfoLog(WebGLProgram*);
     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*);
     Nullable<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);
 
     void hint(GLenum target, GLenum mode);
     GLboolean isBuffer(WebGLBuffer*);
     bool isContextLost() const;
     GLboolean isEnabled(GLenum cap);
     GLboolean isFramebuffer(WebGLFramebuffer*);
     GLboolean isProgram(WebGLProgram*);
     GLboolean isRenderbuffer(WebGLRenderbuffer*);
@@ skipping 125 matching lines @@
     void removeSharedObject(WebGLSharedObject*);
     void removeContextObject(WebGLContextObject*);
 
     unsigned maxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // ActiveDOMObject notifications
     virtual bool hasPendingActivity() const OVERRIDE;
     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;
     friend class WebGLObject;
+    friend class WebGLContextObject;
     friend class OESVertexArrayObject;
     friend class WebGLDebugShaders;
     friend class WebGLCompressedTextureATC;
     friend class WebGLCompressedTextureETC1;
     friend class WebGLCompressedTexturePVRTC;
     friend class WebGLCompressedTextureS3TC;
     friend class WebGLRenderingContextErrorMessageCallback;
     friend class WebGLVertexArrayObjectOES;
     friend class ScopedTexture2DRestorer;
 
     WebGLRenderingContextBase(HTMLCanvasElement*, PassOwnPtr<blink::WebGraphicsContext3D>, WebGLContextAttributes*);
     PassRefPtr<DrawingBuffer> createDrawingBuffer(PassOwnPtr<blink::WebGraphicsContext3D>);
     void initializeNewContext();
     void setupFlags();
 
+#if ENABLE(OILPAN)
+    PassRefPtr<WebGLSharedWebGraphicsContext3D> sharedWebGraphicsContext3D();
+#endif
+
     void addSharedObject(WebGLSharedObject*);
     void addContextObject(WebGLContextObject*);
     void detachAndRemoveAllObjects();
 
     void destroyContext();
     void markContextChanged(ContentChangeType);
 
     // Query if the GL implementation is NPOT strict.
     bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
     // Query if depth_stencil buffer is supported.
@@ skipping 14 matching lines @@
 
     PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, const char* functionName);
 
     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy);
 
     WebGLRenderbuffer* ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer*);
 
     // Structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
     RefPtr<DrawingBuffer> m_drawingBuffer;
+#if ENABLE(OILPAN)
+    RefPtr<WebGLSharedWebGraphicsContext3D> m_sharedWebGraphicsContext3D;
+#endif
+
     RefPtr<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
     // 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_needsUpdate;
     bool m_markedCanvasDirty;
-    HashSet<WebGLContextObject*> m_contextObjects;
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject> > m_contextObjects;
 
-    OwnPtr<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
-    OwnPtr<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
+    OwnPtrWillBeMember<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
+    OwnPtrWillBeMember<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;
         else
             m_boundVertexArrayObject = m_defaultVertexArrayObject;
     }
 
     class VertexAttribValue {
     public:
         VertexAttribValue()
         {
             initValue();
         }
 
         void initValue()
         {
             value[0] = 0.0f;
             value[1] = 0.0f;
             value[2] = 0.0f;
             value[3] = 1.0f;
         }
 
         GLfloat value[4];
     };
     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;
 
     // 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 16 matching lines @@
     bool m_drawBuffersWebGLRequirementsChecked;
     bool m_drawBuffersSupported;
 
     GLint m_packAlignment;
     GLint m_unpackAlignment;
     bool m_unpackFlipY;
     bool m_unpackPremultiplyAlpha;
     GLenum m_unpackColorspaceConversion;
     bool m_contextLost;
     LostContextMode m_contextLostMode;
-    RefPtr<WebGLContextAttributes> m_requestedAttributes;
+    RefPtrWillBeMember<WebGLContextAttributes> m_requestedAttributes;
 
     bool m_layerCleared;
     GLfloat m_clearColor[4];
     bool m_scissorEnabled;
     GLfloat m_clearDepth;
     GLint m_clearStencil;
     GLboolean m_colorMask[4];
     GLboolean m_depthMask;
 
     bool m_stencilEnabled;
@@ skipping 16 matching lines @@
     OwnPtr<Extensions3DUtil> m_extensionsUtil;
 
     bool m_savingImage;
 
     enum ExtensionFlags {
         ApprovedExtension               = 0x00,
         // Extension that is behind the draft extensions runtime flag:
         DraftExtension                  = 0x01,
     };
 
-    class ExtensionTracker {
+    class ExtensionTracker : public NoBaseWillBeGarbageCollected<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 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;
     };
 
     template <typename T>
     class TypedExtensionTracker FINAL : public ExtensionTracker {
     public:
-        TypedExtensionTracker(RefPtr<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
-            : ExtensionTracker(flags, prefixes)
-            , m_extensionField(extensionField)
-            , m_extension(nullptr)
+        static PassOwnPtrWillBeRawPtr<TypedExtensionTracker<T> > create(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
         {
+            return adoptPtrWillBeNoop(new TypedExtensionTracker<T>(extensionField, flags, prefixes));
         }
 
+#if !ENABLE(OILPAN)
         virtual ~TypedExtensionTracker()
         {
             if (m_extension) {
                 m_extension->lose(true);
                 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);

[haraken, 2014/07/15 15:04:56]

Just to confirm: It's guaranteed that T holds a strong reference to the
WebGLRenderingContextBase, and thus it's guaranteed that the
WebGLRenderingContextBase, the Extensions and the ExtensionTrackers die
together. Right?

[sof, 2014/07/15 16:23:00]

No, the extension (a WebGLExtension) holds a weak reference. Its lifetime may
extend beyond the WebGLRenderingContextBase object it was created for, so that
reference must be cleared out when the latter goes away.

[haraken, 2014/07/16 02:08:19]

Then why don't we need to call m_extension->lose() in ~TypedExtensionTracker()?

[sof, 2014/07/16 05:02:48]

If the extension tracker dies, then WebGLRenderingContextBase dies. If the
WebGLExtension doesn't die at the same time, its weak reference will be cleared.
Which is what lose() does.

If WebGLExtension dies also at the same time, no need to call lose() either as
it wouldn't be observable.

                 m_extensionField = m_extension;
             }
 
             return m_extension;
         }
 
         virtual bool supported(WebGLRenderingContextBase* context) const OVERRIDE
         {
             return T::supported(context);
         }
 
         virtual const char* extensionName() const OVERRIDE
         {
             return T::extensionName();
         }
 
         virtual void loseExtension() OVERRIDE
         {
             if (m_extension) {
                 m_extension->lose(false);
                 if (m_extension->isLost())
                     m_extension = nullptr;
             }
         }
 
+        virtual void trace(Visitor* visitor) OVERRIDE
+        {
+            visitor->trace(m_extension);
+            visitor->trace(m_extensionField);
+            ExtensionTracker::trace(visitor);
+        }
+
     private:
-        RefPtr<T>& m_extensionField;
+        TypedExtensionTracker(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+            : ExtensionTracker(flags, prefixes)
+            , m_extensionField(extensionField)
+        {
+        }
+
+        RefPtrWillBeMember<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
-        RefPtr<T> m_extension;
+        RefPtrWillBeMember<T> m_extension;
     };
 
     bool m_extensionEnabled[WebGLExtensionNameCount];
-    Vector<ExtensionTracker*> m_extensions;
+    WillBeHeapVector<OwnPtrWillBeMember<ExtensionTracker> > m_extensions;
 
     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));
+        m_extensions.append(TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
     }
 
     bool extensionSupportedAndAllowed(const ExtensionTracker*);
 
     inline bool extensionEnabled(WebGLExtensionName name)
     {
         return m_extensionEnabled[name];
     }
 
     // Errors raised by synthesizeGLError() while the context is lost.
@@ skipping 253 matching lines @@
     // 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 WebCore
 
+WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(WebCore::WebGLRenderingContextBase::TextureUnitState);
+
 #endif // WebGLRenderingContextBase_h