[Oilpan]: Moving the FontSelector/FontCacheClient, CSSSegmentedFontFace, and FontFaceCache to the o…

Source/core/css/FontFaceCache.cpp

 /*
  * Copyright (C) 2007, 2008, 2011 Apple Inc. All rights reserved.
  * 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
@@ skipping 40 matching lines @@
     RefPtr<FontFace> fontFace = prpFontFace;
     if (!m_styleRuleToFontFace.add(fontFaceRule, fontFace).isNewEntry)
         return;
     addFontFace(cssFontSelector, fontFace, true);
 }
 
 void FontFaceCache::addFontFace(CSSFontSelector* cssFontSelector, PassRefPtr<FontFace> prpFontFace, bool cssConnected)
 {
     RefPtr<FontFace> fontFace = prpFontFace;
 
-    OwnPtr<TraitsMap>& familyFontFaces = m_fontFaces.add(fontFace->family(), nullptr).storedValue->value;
+    TraitsMap* familyFontFaces = m_fontFaces.get(fontFace->family());
     if (!familyFontFaces)
-        familyFontFaces = adoptPtr(new TraitsMap);
+        familyFontFaces = m_fontFaces.set(fontFace->family(), adoptPtrWillBeNoop(new TraitsMap)).storedValue->value.get();
 
-    RefPtr<CSSSegmentedFontFace>& segmentedFontFace = familyFontFaces->add(fontFace->traits().mask(), nullptr).storedValue->value;
+    CSSSegmentedFontFace* segmentedFontFace = familyFontFaces->get(fontFace->traits().mask());
     if (!segmentedFontFace)
-        segmentedFontFace = CSSSegmentedFontFace::create(cssFontSelector, fontFace->traits());
+        segmentedFontFace = familyFontFaces->set(fontFace->traits().mask(), CSSSegmentedFontFace::create(cssFontSelector, fontFace->traits())).storedValue->value.get();
 
     segmentedFontFace->addFontFace(fontFace, cssConnected);
     if (cssConnected)
         m_cssConnectedFontFaces.add(fontFace);
 
     ++m_version;
 }
 
 void FontFaceCache::remove(const StyleRuleFontFace* fontFaceRule)
 {
     StyleRuleToFontFace::iterator it = m_styleRuleToFontFace.find(fontFaceRule);
     if (it != m_styleRuleToFontFace.end()) {
         removeFontFace(it->value.get(), true);
         m_styleRuleToFontFace.remove(it);
     }
 }
 
 void FontFaceCache::removeFontFace(FontFace* fontFace, bool cssConnected)
 {
     FamilyToTraitsMap::iterator fontFacesIter = m_fontFaces.find(fontFace->family());
     if (fontFacesIter == m_fontFaces.end())
         return;
     TraitsMap* familyFontFaces = fontFacesIter->value.get();
 
     TraitsMap::iterator familyFontFacesIter = familyFontFaces->find(fontFace->traits().mask());
     if (familyFontFacesIter == familyFontFaces->end())
         return;
-    RefPtr<CSSSegmentedFontFace> segmentedFontFace = familyFontFacesIter->value;
+    RefPtrWillBeRawPtr<CSSSegmentedFontFace> segmentedFontFace = familyFontFacesIter->value;
 
     segmentedFontFace->removeFontFace(fontFace);
     if (segmentedFontFace->isEmpty()) {
         familyFontFaces->remove(familyFontFacesIter);
         if (familyFontFaces->isEmpty())
             m_fontFaces.remove(fontFacesIter);
     }
     m_fonts.clear();
     if (cssConnected)
         m_cssConnectedFontFaces.remove(fontFace);
@@ skipping 80 matching lines @@
 
     return false;
 }
 
 CSSSegmentedFontFace* FontFaceCache::get(const FontDescription& fontDescription, const AtomicString& family)
 {
     TraitsMap* familyFontFaces = m_fontFaces.get(family);
     if (!familyFontFaces || familyFontFaces->isEmpty())
         return 0;
 
-    OwnPtr<TraitsMap>& segmentedFontFaceCache = m_fonts.add(family, nullptr).storedValue->value;
+    TraitsMap* segmentedFontFaceCache = m_fonts.get(family);
     if (!segmentedFontFaceCache)
-        segmentedFontFaceCache = adoptPtr(new TraitsMap);
+        segmentedFontFaceCache = m_fonts.set(family, adoptPtrWillBeNoop(new TraitsMap)).storedValue->value.get();
 
     FontTraits traits = fontDescription.traits();
-    RefPtr<CSSSegmentedFontFace>& face = segmentedFontFaceCache->add(traits.mask(), nullptr).storedValue->value;
+    CSSSegmentedFontFace* face = segmentedFontFaceCache->get(traits.mask());
     if (!face) {
         for (TraitsMap::const_iterator i = familyFontFaces->begin(); i != familyFontFaces->end(); ++i) {
             CSSSegmentedFontFace* candidate = i->value.get();
             FontTraits candidateTraits = candidate->traits();
             if (traits.style() == FontStyleNormal && candidateTraits.style() != FontStyleNormal)
                 continue;
             if (traits.variant() == FontVariantNormal && candidateTraits.variant() != FontVariantNormal)
                 continue;
-            if (!face || compareFontFaces(candidate, face.get(), traits))
-                face = candidate;
+            if (!face || compareFontFaces(candidate, face, traits))
+                face = segmentedFontFaceCache->set(traits.mask(), candidate).storedValue->value.get();
         }
     }
-    return face.get();
+    return face;
+}
+
+void FontFaceCache::trace(Visitor* visitor)
+{
+    visitor->trace(m_fontFaces);
+    visitor->trace(m_fonts);
 }
 
 }