Migrate WTF::HashMap::get() to ::at()

third_party/WebKit/Source/core/layout/LayoutCounter.cpp

 /**
  * Copyright (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 352 matching lines @@
       currentLayoutObject =
           previousInPreOrderRespectingContainment(*currentLayoutObject);
   }
   return false;
 }
 
 static CounterNode* makeCounterNodeIfNeeded(LayoutObject& object,
                                             const AtomicString& identifier,
                                             bool alwaysCreateCounter) {
   if (object.hasCounterNodeMap()) {
-    if (CounterMap* nodeMap = counterMaps().get(&object)) {
-      if (CounterNode* node = nodeMap->get(identifier))
+    if (CounterMap* nodeMap = counterMaps().at(&object)) {
+      if (CounterNode* node = nodeMap->at(identifier))
         return node;
     }
   }
 
   bool isReset = false;
   int value = 0;
   if (!planCounter(object, identifier, isReset, value) && !alwaysCreateCounter)
     return nullptr;
 
   RefPtr<CounterNode> newParent = nullptr;
   RefPtr<CounterNode> newPreviousSibling = nullptr;
   RefPtr<CounterNode> newNode = CounterNode::create(object, isReset, value);
   if (findPlaceForCounter(object, identifier, isReset, newParent,
                           newPreviousSibling))
     newParent->insertAfter(newNode.get(), newPreviousSibling.get(), identifier);
   CounterMap* nodeMap;
   if (object.hasCounterNodeMap()) {
-    nodeMap = counterMaps().get(&object);
+    nodeMap = counterMaps().at(&object);
   } else {
     nodeMap = new CounterMap;
     counterMaps().set(&object, WTF::wrapUnique(nodeMap));
     object.setHasCounterNodeMap(true);
   }
   nodeMap->set(identifier, newNode);
   if (newNode->parent())
     return newNode.get();
   // Checking if some nodes that were previously counter tree root nodes
   // should become children of this node now.
   CounterMaps& maps = counterMaps();
   Element* stayWithin = parentElement(object);
   bool skipDescendants;
   for (LayoutObject* currentLayoutObject = nextInPreOrder(object, stayWithin);
        currentLayoutObject;
        currentLayoutObject =
            nextInPreOrder(*currentLayoutObject, stayWithin, skipDescendants)) {
     skipDescendants = false;
     if (!currentLayoutObject->hasCounterNodeMap())
       continue;
-    CounterNode* currentCounter =
-        maps.get(currentLayoutObject)->get(identifier);
+    CounterNode* currentCounter = maps.at(currentLayoutObject)->at(identifier);
     if (!currentCounter)
       continue;
     skipDescendants = true;
     if (currentCounter->parent())
       continue;
     if (stayWithin == parentElement(*currentLayoutObject) &&
         currentCounter->hasResetType())
       break;
     newNode->insertAfter(currentCounter, newNode->lastChild(), identifier);
   }
@@ skipping 72 matching lines @@
       LayoutInvalidationReason::CountersChanged);
 }
 
 static void destroyCounterNodeWithoutMapRemoval(const AtomicString& identifier,
                                                 CounterNode* node) {
   CounterNode* previous;
   for (RefPtr<CounterNode> child = node->lastDescendant();
        child && child != node; child = previous) {
     previous = child->previousInPreOrder();
     child->parent()->removeChild(child.get());
-    ASSERT(counterMaps().get(&child->owner())->get(identifier) == child);
-    counterMaps().get(&child->owner())->erase(identifier);
+    ASSERT(counterMaps().at(&child->owner())->at(identifier) == child);
+    counterMaps().at(&child->owner())->erase(identifier);
   }
   if (CounterNode* parent = node->parent())
     parent->removeChild(node);
 }
 
 void LayoutCounter::destroyCounterNodes(LayoutObject& owner) {
   CounterMaps& maps = counterMaps();
   CounterMaps::iterator mapsIterator = maps.find(&owner);
   if (mapsIterator == maps.end())
     return;
   CounterMap* map = mapsIterator->value.get();
   CounterMap::const_iterator end = map->end();
   for (CounterMap::const_iterator it = map->begin(); it != end; ++it) {
     destroyCounterNodeWithoutMapRemoval(it->key, it->value.get());
   }
   maps.remove(mapsIterator);
   owner.setHasCounterNodeMap(false);
 }
 
 void LayoutCounter::destroyCounterNode(LayoutObject& owner,
                                        const AtomicString& identifier) {
-  CounterMap* map = counterMaps().get(&owner);
+  CounterMap* map = counterMaps().at(&owner);
   if (!map)
     return;
   CounterMap::iterator mapIterator = map->find(identifier);
   if (mapIterator == map->end())
     return;
   destroyCounterNodeWithoutMapRemoval(identifier, mapIterator->value.get());
   map->remove(mapIterator);
   // We do not delete "map" here even if empty because we expect to reuse
   // it soon. In order for a layoutObject to lose all its counters permanently,
   // a style change for the layoutObject involving removal of all counter
@@ skipping 31 matching lines @@
       layoutObject.style()->counterDirectives();
   if (!directiveMap)
     return;
   CounterDirectiveMap::const_iterator end = directiveMap->end();
   if (!layoutObject.hasCounterNodeMap()) {
     for (CounterDirectiveMap::const_iterator it = directiveMap->begin();
          it != end; ++it)
       makeCounterNodeIfNeeded(layoutObject, it->key, false);
     return;
   }
-  CounterMap* counterMap = counterMaps().get(&layoutObject);
+  CounterMap* counterMap = counterMaps().at(&layoutObject);
   ASSERT(counterMap);
   for (CounterDirectiveMap::const_iterator it = directiveMap->begin();
        it != end; ++it) {
-    RefPtr<CounterNode> node = counterMap->get(it->key);
+    RefPtr<CounterNode> node = counterMap->at(it->key);
     if (!node) {
       makeCounterNodeIfNeeded(layoutObject, it->key, false);
       continue;
     }
     RefPtr<CounterNode> newParent = nullptr;
     RefPtr<CounterNode> newPreviousSibling = nullptr;
 
     findPlaceForCounter(layoutObject, it->key, node->hasResetType(), newParent,
                         newPreviousSibling);
-    if (node != counterMap->get(it->key))
+    if (node != counterMap->at(it->key))
       continue;
     CounterNode* parent = node->parent();
     if (newParent == parent && newPreviousSibling == node->previousSibling())
       continue;
     if (parent)
       parent->removeChild(node.get());
     if (newParent)
       newParent->insertAfter(node.get(), newPreviousSibling.get(), it->key);
   }
 }
@@ skipping 86 matching lines @@
   while (root->parent())
     root = root->parent();
 
   AtomicString identifier(counterName);
   for (const blink::LayoutObject* current = root; current;
        current = current->nextInPreOrder()) {
     fprintf(stderr, "%c", (current == layoutObject) ? '*' : ' ');
     for (const blink::LayoutObject* parent = current; parent && parent != root;
          parent = parent->parent())
       fprintf(stderr, "    ");
-    fprintf(
-        stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n", current, current->node(),
-        current->parent(), current->previousSibling(), current->nextSibling(),
-        current->hasCounterNodeMap()
-            ? counterName ? blink::counterMaps().get(current)->get(identifier)
-                          : (blink::CounterNode*)1
-            : (blink::CounterNode*)0);
+    fprintf(stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n", current, current->node(),
+            current->parent(), current->previousSibling(),
+            current->nextSibling(),
+            current->hasCounterNodeMap()
+                ? counterName ? blink::counterMaps().at(current)->at(identifier)
+                              : (blink::CounterNode*)1
+                : (blink::CounterNode*)0);
   }
   fflush(stderr);
 }
 
 #endif  // NDEBUG