[oilpan] Move CSSFontFace and CSSSegmentedFontFace to the managed heap

Source/core/css/FontLoader.cpp

 /*
  * Copyright (C) 2013 Google 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 27 matching lines @@
 #include "core/dom/Document.h"
 #include "core/page/FrameView.h"
 
 namespace WebCore {
 
 static const int defaultFontSize = 10;
 static const char* const defaultFontFamily = "sans-serif";
 
 class LoadFontCallback : public CSSSegmentedFontFace::LoadFontCallback {
 public:
-    static PassRefPtr<LoadFontCallback> create(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
+    static Result<LoadFontCallback> create(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
     {
-        return adoptRef<LoadFontCallback>(new LoadFontCallback(numLoading, loadCallback, errorCallback));
+        return adopt(new LoadFontCallback(numLoading, loadCallback, errorCallback));
     }
 
-    static PassRefPtr<LoadFontCallback> createFromParams(const Dictionary& params, const FontFamily& family)
+    static Result<LoadFontCallback> createFromParams(const Dictionary& params, const FontFamily& family)
     {
         RefPtr<VoidCallback> onsuccess;
         RefPtr<VoidCallback> onerror;
         params.get("onsuccess", onsuccess);
         params.get("onerror", onerror);
         if (!onsuccess && !onerror)
-            return 0;
+            return nullptr;
         int numFamilies = 0;
         for (const FontFamily* f = &family; f; f = f->next())
             numFamilies++;
         return LoadFontCallback::create(numFamilies, onsuccess, onerror);
     }
 
-    virtual void notifyLoaded(CSSSegmentedFontFace*) OVERRIDE;
-    virtual void notifyError(CSSSegmentedFontFace*) OVERRIDE;
+    virtual void notifyLoaded(Handle<CSSSegmentedFontFace>) OVERRIDE;
+    virtual void notifyError(Handle<CSSSegmentedFontFace>) OVERRIDE;
     void loaded(Document*);
     void error(Document*);
+
+    virtual void accept(Visitor*) const { }
+
 private:
     LoadFontCallback(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
         : m_numLoading(numLoading)
         , m_errorOccured(false)
         , m_loadCallback(loadCallback)
         , m_errorCallback(errorCallback)
     { }
 
     int m_numLoading;
     bool m_errorOccured;
@@ skipping 15 matching lines @@
             document->fontloader()->scheduleCallback(m_loadCallback.release());
     }
 }
 
 void LoadFontCallback::error(Document* document)
 {
     m_errorOccured = true;
     loaded(document);
 }
 
-void LoadFontCallback::notifyLoaded(CSSSegmentedFontFace* face)
+void LoadFontCallback::notifyLoaded(Handle<CSSSegmentedFontFace> face)
 {
     loaded(face->fontSelector()->document());
 }
 
-void LoadFontCallback::notifyError(CSSSegmentedFontFace* face)
+void LoadFontCallback::notifyError(Handle<CSSSegmentedFontFace> face)
 {
     error(face->fontSelector()->document());
 }
 
 FontLoader::FontLoader(Document* document)
     : ActiveDOMObject(document)
     , m_document(document)
     , m_loadingCount(0)
     , m_timer(this, &FontLoader::timerFired)
 {
@@ skipping 143 matching lines @@
 
 void FontLoader::loadFont(const Dictionary& params)
 {
     // FIXME: The text member of params is ignored.
     String fontString;
     if (!params.get("font", fontString))
         return;
     Font font;
     if (!resolveFontStyle(fontString, font))
         return;
-    RefPtr<LoadFontCallback> callback = LoadFontCallback::createFromParams(params, font.family());
+    Handle<LoadFontCallback> callback = LoadFontCallback::createFromParams(params, font.family());
 
+    Handle<CSSSegmentedFontFace> face;
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
         if (!face) {
             if (callback)
                 callback->error(m_document);
             continue;
         }
         face->loadFont(font.fontDescription(), callback);
     }
 }
 
 bool FontLoader::checkFont(const String& fontString, const String&)
 {
     // FIXME: The second parameter (text) is ignored.
     Font font;
     if (!resolveFontStyle(fontString, font))
         return false;
+    Handle<CSSSegmentedFontFace> face;
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
         if (!face || !face->checkFont())
             return false;
     }
     return true;
 }
 
 static void applyPropertyToCurrentStyle(StyleResolver* styleResolver, CSSPropertyID id, const RefPtr<StylePropertySet>& parsedStyle)
 {
     styleResolver->applyPropertyToCurrentStyle(id, Handle<CSSValue>(parsedStyle->getPropertyCSSValue(id)).raw());
 }
@@ skipping 38 matching lines @@
     applyPropertyToCurrentStyle(styleResolver, CSSPropertyFontSize, parsedStyle);
     styleResolver->updateFont();
     applyPropertyToCurrentStyle(styleResolver, CSSPropertyLineHeight, parsedStyle);
 
     font = style->font();
     font.update(styleResolver->fontSelector());
     return true;
 }
 
 } // namespace WebCore