Migrate WTF::HashMap::add() to ::insert()

third_party/WebKit/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 29 matching lines @@
 
 namespace blink {
 
 static unsigned s_version = 0;
 
 FontFaceCache::FontFaceCache() : m_version(0) {}
 
 void FontFaceCache::add(CSSFontSelector* cssFontSelector,
                         const StyleRuleFontFace* fontFaceRule,
                         FontFace* fontFace) {
-  if (!m_styleRuleToFontFace.add(fontFaceRule, fontFace).isNewEntry)
+  if (!m_styleRuleToFontFace.insert(fontFaceRule, fontFace).isNewEntry)
     return;
   addFontFace(cssFontSelector, fontFace, true);
 }
 
 void FontFaceCache::addFontFace(CSSFontSelector* cssFontSelector,
                                 FontFace* fontFace,
                                 bool cssConnected) {
   FamilyToTraitsMap::AddResult traitsResult =
-      m_fontFaces.add(fontFace->family(), nullptr);
+      m_fontFaces.insert(fontFace->family(), nullptr);
   if (!traitsResult.storedValue->value)
     traitsResult.storedValue->value = new TraitsMap;
 
   TraitsMap::AddResult segmentedFontFaceResult =
-      traitsResult.storedValue->value->add(fontFace->traits().bitfield(),
-                                           nullptr);
+      traitsResult.storedValue->value->insert(fontFace->traits().bitfield(),
+                                              nullptr);
   if (!segmentedFontFaceResult.storedValue->value)
     segmentedFontFaceResult.storedValue->value =
         CSSSegmentedFontFace::create(cssFontSelector, fontFace->traits());
 
   segmentedFontFaceResult.storedValue->value->addFontFace(fontFace,
                                                           cssConnected);
   if (cssConnected)
     m_cssConnectedFontFaces.add(fontFace);
 
   m_fonts.erase(fontFace->family());
@@ skipping 54 matching lines @@
 void FontFaceCache::incrementVersion() {
   m_version = ++s_version;
 }
 
 CSSSegmentedFontFace* FontFaceCache::get(const FontDescription& fontDescription,
                                          const AtomicString& family) {
   TraitsMap* familyFontFaces = m_fontFaces.get(family);
   if (!familyFontFaces || familyFontFaces->isEmpty())
     return nullptr;
 
-  FamilyToTraitsMap::AddResult traitsResult = m_fonts.add(family, nullptr);
+  FamilyToTraitsMap::AddResult traitsResult = m_fonts.insert(family, nullptr);
   if (!traitsResult.storedValue->value)
     traitsResult.storedValue->value = new TraitsMap;
 
   FontTraits traits = fontDescription.traits();
   TraitsMap::AddResult faceResult =
-      traitsResult.storedValue->value->add(traits.bitfield(), nullptr);
+      traitsResult.storedValue->value->insert(traits.bitfield(), nullptr);
   if (!faceResult.storedValue->value) {
     for (const auto& item : *familyFontFaces) {
       CSSSegmentedFontFace* candidate = item.value.get();
       FontStyleMatcher styleMatcher(traits);
       if (!faceResult.storedValue->value ||
           styleMatcher.isCandidateBetter(candidate,
                                          faceResult.storedValue->value.get()))
         faceResult.storedValue->value = candidate;
     }
   }
   return faceResult.storedValue->value.get();
 }
 
 DEFINE_TRACE(FontFaceCache) {
   visitor->trace(m_fontFaces);
   visitor->trace(m_fonts);
   visitor->trace(m_styleRuleToFontFace);
   visitor->trace(m_cssConnectedFontFaces);
 }
 
 }  // namespace blink