Add CSSFontSelector::removeFontFaceRule()

Source/core/css/CSSSegmentedFontFaceCache.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 48 matching lines @@
         return;
 
     unsigned traitsMask = fontFace->traitsMask();
     if (!traitsMask)
         return;
 
     RefPtr<CSSFontFace> cssFontFace = fontFace->createCSSFontFace(cssFontSelector->document());
     if (!cssFontFace || !cssFontFace->isValid())
         return;
 
-    OwnPtr<HashMap<unsigned, RefPtr<CSSSegmentedFontFace> > >& familyFontFaces = m_fontFaces.add(fontFace->family(), nullptr).iterator->value;
+    if (!m_styleRuleToFontFace.add(fontFaceRule, cssFontFace).isNewEntry)
+        return;
+
+    OwnPtr<TraitsMap>& familyFontFaces = m_fontFaces.add(fontFace->family(), nullptr).iterator->value;
     if (!familyFontFaces) {
-        familyFontFaces = adoptPtr(new HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >);
+        familyFontFaces = adoptPtr(new TraitsMap);
 
         ASSERT(!m_locallyInstalledFontFaces.contains(fontFace->family()));
 
         Vector<unsigned> locallyInstalledFontsTraitsMasks;
         fontCache()->getTraitsInFamily(fontFace->family(), locallyInstalledFontsTraitsMasks);
         if (unsigned numLocallyInstalledFaces = locallyInstalledFontsTraitsMasks.size()) {
             OwnPtr<Vector<RefPtr<CSSSegmentedFontFace> > > familyLocallyInstalledFaces = adoptPtr(new Vector<RefPtr<CSSSegmentedFontFace> >);
 
             for (unsigned i = 0; i < numLocallyInstalledFaces; ++i) {
                 RefPtr<CSSFontFace> locallyInstalledFontFace = CSSFontFace::create(0);
@@ skipping 11 matching lines @@
 
     RefPtr<CSSSegmentedFontFace>& segmentedFontFace = familyFontFaces->add(traitsMask, 0).iterator->value;
     if (!segmentedFontFace)
         segmentedFontFace = CSSSegmentedFontFace::create(cssFontSelector, static_cast<FontTraitsMask>(traitsMask), false);
 
     segmentedFontFace->appendFontFace(cssFontFace);
 
     ++m_version;
 }
 
+void CSSSegmentedFontFaceCache::removeFontFaceRule(const StyleRuleFontFace* fontFaceRule)
+{
+    StyleRuleToFontFace::iterator styleRuleToFontFaceIter = m_styleRuleToFontFace.find(fontFaceRule);
+    if (styleRuleToFontFaceIter == m_styleRuleToFontFace.end())
+        return;
+    RefPtr<CSSFontFace> cssFontFace = styleRuleToFontFaceIter->value;
+
+    ASSERT(cssFontFace->fontFace());
+    FamilyToTraitsMap::iterator fontFacesIter = m_fontFaces.find(cssFontFace->fontFace()->family());
+    if (fontFacesIter == m_fontFaces.end())
+        return;
+    TraitsMap* familyFontFaces = fontFacesIter->value.get();
+
+    TraitsMap::iterator familyFontFacesIter = familyFontFaces->find(cssFontFace->fontFace()->traitsMask());
+    if (familyFontFacesIter == familyFontFaces->end())
+        return;
+    RefPtr<CSSSegmentedFontFace> segmentedFontFace = familyFontFacesIter->value;
+
+    segmentedFontFace->removeFontFace(cssFontFace);
+    if (segmentedFontFace->isEmpty()) {
+        familyFontFaces->remove(familyFontFacesIter);
+        if (familyFontFaces->isEmpty()) {
+            m_fontFaces.remove(fontFacesIter);
+            m_locallyInstalledFontFaces.remove(cssFontFace->fontFace()->family());
+        }
+    }
+    m_styleRuleToFontFace.remove(styleRuleToFontFaceIter);
+    m_fonts.clear();
+}
 
 static PassRefPtr<FontData> fontDataForGenericFamily(Settings* settings, const FontDescription& fontDescription, const AtomicString& familyName)
 {
     if (!settings)
         return 0;
 
     AtomicString genericFamily;
     UScriptCode script = fontDescription.script();
 
 #if OS(ANDROID)
@@ skipping 120 matching lines @@
             return fontDataForGenericFamily(settings, fontDescription, "-webkit-standard");
         return fontDataForGenericFamily(settings, fontDescription, familyName);
     }
 
     // We have a face. Ask it for a font data. If it cannot produce one, it will fail, and the OS will take over.
     return face->getFontData(fontDescription);
 }
 
 CSSSegmentedFontFace* CSSSegmentedFontFaceCache::getFontFace(const FontDescription& fontDescription, const AtomicString& family)
 {
-    HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >* familyFontFaces = m_fontFaces.get(family);
+    TraitsMap* familyFontFaces = m_fontFaces.get(family);
     if (!familyFontFaces || familyFontFaces->isEmpty())
         return 0;
 
-    OwnPtr<HashMap<unsigned, RefPtr<CSSSegmentedFontFace> > >& segmentedFontFaceCache = m_fonts.add(family, nullptr).iterator->value;
+    OwnPtr<TraitsMap>& segmentedFontFaceCache = m_fonts.add(family, nullptr).iterator->value;
     if (!segmentedFontFaceCache)
-        segmentedFontFaceCache = adoptPtr(new HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >);
+        segmentedFontFaceCache = adoptPtr(new TraitsMap);
 
     FontTraitsMask traitsMask = fontDescription.traitsMask();
 
     RefPtr<CSSSegmentedFontFace>& face = segmentedFontFaceCache->add(traitsMask, 0).iterator->value;
     if (!face) {
-        for (HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >::const_iterator i = familyFontFaces->begin(); i != familyFontFaces->end(); ++i) {
+        for (TraitsMap::const_iterator i = familyFontFaces->begin(); i != familyFontFaces->end(); ++i) {
             CSSSegmentedFontFace* candidate = i->value.get();
             unsigned candidateTraitsMask = candidate->traitsMask();
             if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
                 continue;
             if ((traitsMask & FontVariantNormalMask) && !(candidateTraitsMask & FontVariantNormalMask))
                 continue;
             if (!face || compareFontFaces(candidate, face.get(), traitsMask))
                 face = candidate;
         }
 
         if (Vector<RefPtr<CSSSegmentedFontFace> >* familyLocallyInstalledFontFaces = m_locallyInstalledFontFaces.get(family)) {
             unsigned numLocallyInstalledFontFaces = familyLocallyInstalledFontFaces->size();
             for (unsigned i = 0; i < numLocallyInstalledFontFaces; ++i) {
                 CSSSegmentedFontFace* candidate = familyLocallyInstalledFontFaces->at(i).get();
                 unsigned candidateTraitsMask = candidate->traitsMask();
                 if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
                     continue;
                 if ((traitsMask & FontVariantNormalMask) && !(candidateTraitsMask & FontVariantNormalMask))
                     continue;
                 if (!face || compareFontFaces(candidate, face.get(), traitsMask))
                     face = candidate;
             }
         }
     }
     return face.get();
 }
 
 }