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

third_party/WebKit/Source/core/events/EventPath.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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 156 matching lines @@
 }
 
 void EventPath::calculateTreeOrderAndSetNearestAncestorClosedTree() {
   // Precondition:
   //   - TreeScopes in m_treeScopeEventContexts must be *connected* in the same
   //     composed tree.
   //   - The root tree must be included.
   HeapHashMap<Member<const TreeScope>, Member<TreeScopeEventContext>>
       treeScopeEventContextMap;
   for (const auto& treeScopeEventContext : m_treeScopeEventContexts)
-    treeScopeEventContextMap.add(&treeScopeEventContext->treeScope(),
-                                 treeScopeEventContext.get());
+    treeScopeEventContextMap.insert(&treeScopeEventContext->treeScope(),
+                                    treeScopeEventContext.get());
   TreeScopeEventContext* rootTree = nullptr;
   for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
     // Use olderShadowRootOrParentTreeScope here for parent-child relationships.
     // See the definition of trees of trees in the Shadow DOM spec:
     // http://w3c.github.io/webcomponents/spec/shadow/
     TreeScope* parent = treeScopeEventContext.get()
                             ->treeScope()
                             .olderShadowRootOrParentTreeScope();
     if (!parent) {
       DCHECK(!rootTree);
@@ skipping 12 matching lines @@
 TreeScopeEventContext* EventPath::ensureTreeScopeEventContext(
     Node* currentTarget,
     TreeScope* treeScope,
     TreeScopeEventContextMap& treeScopeEventContextMap) {
   if (!treeScope)
     return nullptr;
   TreeScopeEventContext* treeScopeEventContext;
   bool isNewEntry;
   {
     TreeScopeEventContextMap::AddResult addResult =
-        treeScopeEventContextMap.add(treeScope, nullptr);
+        treeScopeEventContextMap.insert(treeScope, nullptr);
     isNewEntry = addResult.isNewEntry;
     if (isNewEntry)
       addResult.storedValue->value = TreeScopeEventContext::create(*treeScope);
     treeScopeEventContext = addResult.storedValue->value.get();
   }
   if (isNewEntry) {
     TreeScopeEventContext* parentTreeScopeEventContext =
         ensureTreeScopeEventContext(
             0, treeScope->olderShadowRootOrParentTreeScope(),
             treeScopeEventContextMap);
@@ skipping 31 matching lines @@
       treeScopeEventContextMap.values().begin(),
       treeScopeEventContextMap.values().end());
 }
 
 void EventPath::buildRelatedNodeMap(const Node& relatedNode,
                                     RelatedTargetMap& relatedTargetMap) {
   EventPath* relatedTargetEventPath =
       new EventPath(const_cast<Node&>(relatedNode));
   for (const auto& treeScopeEventContext :
        relatedTargetEventPath->m_treeScopeEventContexts) {
-    relatedTargetMap.add(&treeScopeEventContext->treeScope(),
-                         treeScopeEventContext->target());
+    relatedTargetMap.insert(&treeScopeEventContext->treeScope(),
+                            treeScopeEventContext->target());
   }
   // Oilpan: It is important to explicitly clear the vectors to reuse
   // the memory in subsequent event dispatchings.
   relatedTargetEventPath->clear();
 }
 
 EventTarget* EventPath::findRelatedNode(TreeScope& scope,
                                         RelatedTargetMap& relatedTargetMap) {
   HeapVector<Member<TreeScope>, 32> parentTreeScopes;
   EventTarget* relatedNode = nullptr;
   for (TreeScope* current = &scope; current;
        current = current->olderShadowRootOrParentTreeScope()) {
     parentTreeScopes.push_back(current);
     RelatedTargetMap::const_iterator iter = relatedTargetMap.find(current);
     if (iter != relatedTargetMap.end() && iter->value) {
       relatedNode = iter->value;
       break;
     }
   }
   DCHECK(relatedNode);
   for (const auto& entry : parentTreeScopes)
-    relatedTargetMap.add(entry, relatedNode);
+    relatedTargetMap.insert(entry, relatedNode);
 
   return relatedNode;
 }
 
 void EventPath::adjustForRelatedTarget(Node& target,
                                        EventTarget* relatedTarget) {
   if (!relatedTarget)
     return;
   Node* relatedNode = relatedTarget->toNode();
   if (!relatedNode)
@@ skipping 121 matching lines @@
 
 DEFINE_TRACE(EventPath) {
   visitor->trace(m_nodeEventContexts);
   visitor->trace(m_node);
   visitor->trace(m_event);
   visitor->trace(m_treeScopeEventContexts);
   visitor->trace(m_windowEventContext);
 }
 
 }  // namespace blink