[oilpan] Move 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 46 matching lines @@
         params.get("onsuccess", onsuccess);
         params.get("onerror", onerror);
         if (!onsuccess && !onerror)
             return 0;
         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*);
 private:
     LoadFontCallback(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
         : m_numLoading(numLoading)
         , m_errorOccured(false)
         , m_loadCallback(loadCallback)
         , m_errorCallback(errorCallback)
     { }
 
@@ skipping 17 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());
+    CSSFontSelector* fontSelector = face->fontSelector();
+    if (!fontSelector)
+        return;
+    loaded(fontSelector->document());
 }
 
-void LoadFontCallback::notifyError(CSSSegmentedFontFace* face)
+void LoadFontCallback::notifyError(Handle<CSSSegmentedFontFace> face)
 {
-    error(face->fontSelector()->document());
+    CSSFontSelector* fontSelector = face->fontSelector();
+    if (!fontSelector)
+        return;
+    error(fontSelector->document());
 }
 
 FontLoader::FontLoader(Document* document)
     : ActiveDOMObject(document)
     , m_document(document)
     , m_loadingCount(0)
     , m_timer(this, &FontLoader::timerFired)
 {
     suspendIfNeeded();
 }
@@ skipping 144 matching lines @@
     // 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());
 
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        Handle<CSSSegmentedFontFace> 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;
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = m_document->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        Handle<CSSSegmentedFontFace> 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 Handle<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