[oilpan] Move CSSFontFace and CSSSegmentedFontFace to the managed heap

Source/core/css/CSSSegmentedFontFace.h

 /*
  * Copyright (C) 2008 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSSegmentedFontFace_h
 #define CSSSegmentedFontFace_h
 
+#include "heap/Handle.h"
 #include <wtf/HashMap.h>
 #include <wtf/PassRefPtr.h>
-#include <wtf/RefCounted.h>
 #include <wtf/Vector.h>
 #include <wtf/unicode/Unicode.h>
 
 namespace WebCore {
 
 class CSSFontFace;
 class CSSFontSelector;
 class FontData;
 class FontDescription;
 class SegmentedFontData;
 
-class CSSSegmentedFontFace : public RefCounted<CSSSegmentedFontFace> {
+class CSSSegmentedFontFace : public HeapAllocatedFinalized<CSSSegmentedFontFace> {
+    DECLARE_GC_TYPE_MARKER
 public:
-    static PassRefPtr<CSSSegmentedFontFace> create(CSSFontSelector* selector) { return adoptRef(new CSSSegmentedFontFace(selector)); }
+    static Result<CSSSegmentedFontFace> create(CSSFontSelector* selector) { return adopt(new CSSSegmentedFontFace(selector)); }
     ~CSSSegmentedFontFace();
 
-    CSSFontSelector* fontSelector() const { return m_fontSelector; }
+    CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
 
-    void fontLoaded(CSSFontFace*);
+    void fontLoaded(Handle<CSSFontFace>);
 
-    void appendFontFace(PassRefPtr<CSSFontFace>);
+    void appendFontFace(Handle<CSSFontFace>);
 
     PassRefPtr<FontData> getFontData(const FontDescription&);
 
-    class LoadFontCallback : public RefCounted<LoadFontCallback> {
+    class LoadFontCallback : public HeapAllocatedFinalized<LoadFontCallback> {
+        DECLARE_GC_TYPE_MARKER
     public:
         virtual ~LoadFontCallback() { }
-        virtual void notifyLoaded(CSSSegmentedFontFace*) = 0;
-        virtual void notifyError(CSSSegmentedFontFace*) = 0;
+        virtual void notifyLoaded(Handle<CSSSegmentedFontFace>) = 0;
+        virtual void notifyError(Handle<CSSSegmentedFontFace>) = 0;
+        virtual void accept(Visitor*) const = 0;
     };
 
     bool checkFont() const;
-    void loadFont(const FontDescription&, PassRefPtr<LoadFontCallback> loadCallback);
+    void loadFont(const FontDescription&, Handle<LoadFontCallback> loadCallback);
+
+    void accept(Visitor*) const;
 
 private:
     CSSSegmentedFontFace(CSSFontSelector*);
 
     void pruneTable();
     bool isValid() const;
     bool isLoading() const;
 
-    CSSFontSelector* m_fontSelector;
+    RefPtr<CSSFontSelector> m_fontSelector;

[haraken, 2013/07/04 08:03:44]

Adding this RefPtr fixed the heap corruption in SVG tests. Given that
CSSSegmentedFontFace is responsible for keeping the lifetime of CSSFontSelector,
I think this should be a RefPtr.

My question is why the previous code had been working without the RefPtr... If
you think it's OK to land with the RefPtr, I'll land this CL. If you're
skeptical about the RefPtr, I'll look into why the previous code had been
working without the RefPtr.

     HashMap<unsigned, RefPtr<SegmentedFontData> > m_fontDataTable;
-    Vector<RefPtr<CSSFontFace>, 1> m_fontFaces;
-    Vector<RefPtr<LoadFontCallback> > m_callbacks;
+    Vector<Member<CSSFontFace>, 1> m_fontFaces;
+    Vector<Member<LoadFontCallback> > m_callbacks;
 };
 
 } // namespace WebCore
 
 #endif // CSSSegmentedFontFace_h