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

third_party/WebKit/Source/platform/heap/HeapTest.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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 2023 matching lines @@
     preciselyCollectGarbage();
     size_t afterAddAndGC = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterAddAndGC >= afterOneAdd);
 
     EXPECT_EQ(map->size(), 2u);  // Two different wrappings of '1' are distinct.
 
     preciselyCollectGarbage();
     EXPECT_TRUE(map->contains(one));
     EXPECT_TRUE(map->contains(anotherOne));
 
-    IntWrapper* gotten(map->get(one));
+    IntWrapper* gotten(map->at(one));
     EXPECT_EQ(gotten->value(), one->value());
     EXPECT_EQ(gotten, one);
 
     size_t afterGC2 = heap.objectPayloadSizeForTesting();
     EXPECT_EQ(afterGC2, afterAddAndGC);
 
     IntWrapper* dozen = 0;
 
     for (int i = 1; i < 1000; i++) {  // 999 iterations.
       IntWrapper* iWrapper(IntWrapper::create(i));
       IntWrapper* iSquared(IntWrapper::create(i * i));
       map->insert(iWrapper, iSquared);
       if (i == 12)
         dozen = iWrapper;
     }
     size_t afterAdding1000 = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterAdding1000 > afterGC2);
 
-    IntWrapper* gross(map->get(dozen));
+    IntWrapper* gross(map->at(dozen));
     EXPECT_EQ(gross->value(), 144);
 
     // This should clear out any junk backings created by all the adds.
     preciselyCollectGarbage();
     size_t afterGC3 = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterGC3 <= afterAdding1000);
   }
 
   preciselyCollectGarbage();
   // The objects 'one', anotherOne, and the 999 other pairs.
@@ skipping 445 matching lines @@
       set3->swap(cCountedSet);
       EXPECT_EQ(0u, set3->size());
       set3->swap(cCountedSet);
 
       // Triple swap.
       container->map.swap(*memberMember2);
       MemberMember& containedMap = container->map;
       memberMember3->swap(containedMap);
       memberMember3->swap(*memberMember);
 
-      EXPECT_TRUE(memberMember->get(one) == two);
-      EXPECT_TRUE(memberMember->get(two) == three);
-      EXPECT_TRUE(memberMember->get(three) == four);
-      EXPECT_TRUE(memberMember->get(four) == one);
-      EXPECT_TRUE(primitiveMember->get(1) == two);
-      EXPECT_TRUE(primitiveMember->get(2) == three);
-      EXPECT_TRUE(primitiveMember->get(3) == four);
-      EXPECT_TRUE(primitiveMember->get(4) == one);
-      EXPECT_EQ(1, memberPrimitive->get(four));
-      EXPECT_EQ(2, memberPrimitive->get(one));
-      EXPECT_EQ(3, memberPrimitive->get(two));
-      EXPECT_EQ(4, memberPrimitive->get(three));
+      EXPECT_TRUE(memberMember->at(one) == two);
+      EXPECT_TRUE(memberMember->at(two) == three);
+      EXPECT_TRUE(memberMember->at(three) == four);
+      EXPECT_TRUE(memberMember->at(four) == one);
+      EXPECT_TRUE(primitiveMember->at(1) == two);
+      EXPECT_TRUE(primitiveMember->at(2) == three);
+      EXPECT_TRUE(primitiveMember->at(3) == four);
+      EXPECT_TRUE(primitiveMember->at(4) == one);
+      EXPECT_EQ(1, memberPrimitive->at(four));
+      EXPECT_EQ(2, memberPrimitive->at(one));
+      EXPECT_EQ(3, memberPrimitive->at(two));
+      EXPECT_EQ(4, memberPrimitive->at(three));
       EXPECT_TRUE(set->contains(one));
       EXPECT_TRUE(set->contains(two));
       EXPECT_TRUE(set->contains(three));
       EXPECT_TRUE(set->contains(four));
       EXPECT_TRUE(set2->contains(oneB));
       EXPECT_TRUE(set3->contains(oneB));
       EXPECT_TRUE(vector->contains(threeB));
       EXPECT_TRUE(vector->contains(fourB));
       EXPECT_TRUE(dequeContains(*deque, threeE));
       EXPECT_TRUE(dequeContains(*deque, fourE));
@@ skipping 36 matching lines @@
     EXPECT_EQ(1u, set3->size());
     EXPECT_EQ(2u, vector->size());
     EXPECT_EQ(1u, vector2->size());
     EXPECT_EQ(3u, vectorUW->size());
     EXPECT_EQ(1u, vector2->size());
     EXPECT_EQ(2u, deque->size());
     EXPECT_EQ(1u, deque2->size());
     EXPECT_EQ(3u, dequeUW->size());
     EXPECT_EQ(1u, deque2->size());
 
-    EXPECT_TRUE(memberMember->get(one) == two);
-    EXPECT_TRUE(primitiveMember->get(1) == two);
-    EXPECT_TRUE(primitiveMember->get(4) == one);
-    EXPECT_EQ(2, memberPrimitive->get(one));
-    EXPECT_EQ(3, memberPrimitive->get(two));
+    EXPECT_TRUE(memberMember->at(one) == two);
+    EXPECT_TRUE(primitiveMember->at(1) == two);
+    EXPECT_TRUE(primitiveMember->at(4) == one);
+    EXPECT_EQ(2, memberPrimitive->at(one));
+    EXPECT_EQ(3, memberPrimitive->at(two));
     EXPECT_TRUE(set->contains(one));
     EXPECT_TRUE(set->contains(two));
     EXPECT_FALSE(set->contains(oneB));
     EXPECT_TRUE(set2->contains(oneB));
     EXPECT_TRUE(set3->contains(oneB));
     EXPECT_EQ(2u, set3->find(oneB)->value);
     EXPECT_EQ(3, vector->at(0)->value());
     EXPECT_EQ(4, vector->at(1)->value());
     EXPECT_EQ(3, deque->begin()->get()->value());
   }
@@ skipping 796 matching lines @@
 
       EXPECT_EQ(64u, weakStrong->size());
       EXPECT_EQ(64u, strongWeak->size());
       EXPECT_EQ(64u, weakWeak->size());
       EXPECT_EQ(64u, weakSet->size());
       EXPECT_EQ(64u, weakOrderedSet->size());
 
       for (int i = 0; i < 128; i += 2) {
         IntWrapper* wrapped = keepNumbersAlive[i];
         IntWrapper* wrapped2 = keepNumbersAlive[i + 1];
-        EXPECT_EQ(wrapped2, weakStrong->get(wrapped));
-        EXPECT_EQ(wrapped, strongWeak->get(wrapped2));
-        EXPECT_EQ(wrapped2, weakWeak->get(wrapped));
+        EXPECT_EQ(wrapped2, weakStrong->at(wrapped));
+        EXPECT_EQ(wrapped, strongWeak->at(wrapped2));
+        EXPECT_EQ(wrapped2, weakWeak->at(wrapped));
         EXPECT_TRUE(weakSet->contains(wrapped));
         EXPECT_TRUE(weakOrderedSet->contains(wrapped));
       }
 
       for (int i = 0; i < 128; i += 3)
         keepNumbersAlive[i] = nullptr;
 
       if (collectionNumber != weakStrongIndex)
         weakStrong->clear();
       if (collectionNumber != strongWeakIndex)
@@ skipping 457 matching lines @@
     EXPECT_EQ(1u, pSet.size());
     EXPECT_TRUE(pSet.contains(four));
 
     EXPECT_EQ(1u, pListSet.size());
     EXPECT_TRUE(pListSet.contains(eight));
 
     EXPECT_EQ(1u, pLinkedSet.size());
     EXPECT_TRUE(pLinkedSet.contains(nine));
 
     EXPECT_EQ(1u, pMap.size());
-    EXPECT_EQ(six, pMap.get(five));
+    EXPECT_EQ(six, pMap.at(five));
 
     EXPECT_EQ(1u, wpMap.size());
-    EXPECT_EQ(eleven, wpMap.get(ten));
+    EXPECT_EQ(eleven, wpMap.at(ten));
     ten.clear();
     preciselyCollectGarbage();
     EXPECT_EQ(0u, wpMap.size());
   }
 
   // Collect previous roots.
   preciselyCollectGarbage();
   EXPECT_EQ(11, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting) {
   clearOutOldGarbage();
   int* key = &IntWrapper::s_destructorCalls;
   IntWrapper::s_destructorCalls = 0;
   typedef HeapVector<Member<IntWrapper>> IntVector;
   typedef HeapDeque<Member<IntWrapper>> IntDeque;
   HeapHashMap<void*, IntVector>* map = new HeapHashMap<void*, IntVector>();
   HeapHashMap<void*, IntDeque>* map2 = new HeapHashMap<void*, IntDeque>();
   static_assert(WTF::IsTraceable<IntVector>::value,
                 "Failed to recognize HeapVector as traceable");
   static_assert(WTF::IsTraceable<IntDeque>::value,
                 "Failed to recognize HeapDeque as traceable");
 
   map->insert(key, IntVector());
   map2->insert(key, IntDeque());
 
   HeapHashMap<void*, IntVector>::iterator it = map->find(key);
-  EXPECT_EQ(0u, map->get(key).size());
+  EXPECT_EQ(0u, map->at(key).size());
 
   HeapHashMap<void*, IntDeque>::iterator it2 = map2->find(key);
-  EXPECT_EQ(0u, map2->get(key).size());
+  EXPECT_EQ(0u, map2->at(key).size());
 
   it->value.push_back(IntWrapper::create(42));
-  EXPECT_EQ(1u, map->get(key).size());
+  EXPECT_EQ(1u, map->at(key).size());
 
   it2->value.append(IntWrapper::create(42));
-  EXPECT_EQ(1u, map2->get(key).size());
+  EXPECT_EQ(1u, map2->at(key).size());
 
   Persistent<HeapHashMap<void*, IntVector>> keepAlive(map);
   Persistent<HeapHashMap<void*, IntDeque>> keepAlive2(map2);
 
   for (int i = 0; i < 100; i++) {
     map->insert(key + 1 + i, IntVector());
     map2->insert(key + 1 + i, IntDeque());
   }
 
   preciselyCollectGarbage();
 
-  EXPECT_EQ(1u, map->get(key).size());
-  EXPECT_EQ(1u, map2->get(key).size());
+  EXPECT_EQ(1u, map->at(key).size());
+  EXPECT_EQ(1u, map2->at(key).size());
   EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
   keepAlive = nullptr;
   preciselyCollectGarbage();
   EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, GarbageCollectedMixin) {
   clearOutOldGarbage();
 
@@ skipping 16 matching lines @@
 TEST(HeapTest, CollectionNesting2) {
   clearOutOldGarbage();
   void* key = &IntWrapper::s_destructorCalls;
   IntWrapper::s_destructorCalls = 0;
   typedef HeapHashSet<Member<IntWrapper>> IntSet;
   HeapHashMap<void*, IntSet>* map = new HeapHashMap<void*, IntSet>();
 
   map->insert(key, IntSet());
 
   HeapHashMap<void*, IntSet>::iterator it = map->find(key);
-  EXPECT_EQ(0u, map->get(key).size());
+  EXPECT_EQ(0u, map->at(key).size());
 
   it->value.insert(IntWrapper::create(42));
-  EXPECT_EQ(1u, map->get(key).size());
+  EXPECT_EQ(1u, map->at(key).size());
 
   Persistent<HeapHashMap<void*, IntSet>> keepAlive(map);
   preciselyCollectGarbage();
-  EXPECT_EQ(1u, map->get(key).size());
+  EXPECT_EQ(1u, map->at(key).size());
   EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting3) {
   clearOutOldGarbage();
   IntWrapper::s_destructorCalls = 0;
   typedef HeapVector<Member<IntWrapper>> IntVector;
   typedef HeapDeque<Member<IntWrapper>> IntDeque;
   HeapVector<IntVector>* vector = new HeapVector<IntVector>();
   HeapDeque<IntDeque>* deque = new HeapDeque<IntDeque>();
@@ skipping 966 matching lines @@
   typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> InnerMap;
   typedef HeapHashMap<WeakMember<IntWrapper>, InnerMap> OuterMap;
 
   for (int keepOuterAlive = 0; keepOuterAlive <= 1; keepOuterAlive++) {
     for (int keepInnerAlive = 0; keepInnerAlive <= 1; keepInnerAlive++) {
       Persistent<OuterMap> outer = new OuterMap();
       Persistent<IntWrapper> one = IntWrapper::create(1);
       Persistent<IntWrapper> two = IntWrapper::create(2);
       outer->insert(one, InnerMap());
       outer->begin()->value.insert(two, IntWrapper::create(3));
-      EXPECT_EQ(1u, outer->get(one).size());
+      EXPECT_EQ(1u, outer->at(one).size());
       if (!keepOuterAlive)
         one.clear();
       if (!keepInnerAlive)
         two.clear();
       preciselyCollectGarbage();
       if (keepOuterAlive) {
-        const InnerMap& inner = outer->get(one);
+        const InnerMap& inner = outer->at(one);
         if (keepInnerAlive) {
           EXPECT_EQ(1u, inner.size());
-          IntWrapper* three = inner.get(two);
+          IntWrapper* three = inner.at(two);
           EXPECT_EQ(3, three->value());
         } else {
           EXPECT_EQ(0u, inner.size());
         }
       } else {
         EXPECT_EQ(0u, outer->size());
       }
       outer->clear();
       Persistent<IntWrapper> deep = IntWrapper::create(42);
       Persistent<IntWrapper> home = IntWrapper::create(103);
       Persistent<IntWrapper> composite = IntWrapper::create(91);
       Persistent<HeapVector<Member<IntWrapper>>> keepAlive =
           new HeapVector<Member<IntWrapper>>();
       for (int i = 0; i < 10000; i++) {
         IntWrapper* value = IntWrapper::create(i);
         keepAlive->push_back(value);
         OuterMap::AddResult newEntry = outer->insert(value, InnerMap());
         newEntry.storedValue->value.insert(deep, home);
         newEntry.storedValue->value.insert(composite, home);
       }
       composite.clear();
       preciselyCollectGarbage();
       EXPECT_EQ(10000u, outer->size());
       for (int i = 0; i < 10000; i++) {
         IntWrapper* value = keepAlive->at(i);
-        EXPECT_EQ(1u, outer->get(value)
-                          .size());  // Other one was deleted by weak handling.
+        EXPECT_EQ(1u,
+                  outer->at(value)
+                      .size());  // Other one was deleted by weak handling.
         if (i & 1)
           keepAlive->at(i) = nullptr;
       }
       preciselyCollectGarbage();
       EXPECT_EQ(5000u, outer->size());
     }
   }
 }
 
 class EphemeronWrapper : public GarbageCollected<EphemeronWrapper> {
@@ skipping 21 matching lines @@
       chain->getMap().insert(key, oldHead);
     chain->getMap().insert(IntWrapper::create(103), new EphemeronWrapper());
   }
 
   preciselyCollectGarbage();
 
   EphemeronWrapper* wrapper = chain;
   for (int i = 0; i < 100; i++) {
     EXPECT_EQ(1u, wrapper->getMap().size());
     if (i == 49)
-      wrapper = wrapper->getMap().get(key2);
+      wrapper = wrapper->getMap().at(key2);
     else
-      wrapper = wrapper->getMap().get(key);
+      wrapper = wrapper->getMap().at(key);
   }
   EXPECT_EQ(nullptr, wrapper);
 
   key2.clear();
   preciselyCollectGarbage();
 
   wrapper = chain;
   for (int i = 0; i < 50; i++) {
     EXPECT_EQ(i == 49 ? 0u : 1u, wrapper->getMap().size());
-    wrapper = wrapper->getMap().get(key);
+    wrapper = wrapper->getMap().at(key);
   }
   EXPECT_EQ(nullptr, wrapper);
 
   key.clear();
   preciselyCollectGarbage();
   EXPECT_EQ(0u, chain->getMap().size());
 }
 
 TEST(HeapTest, Ephemeron) {
   typedef HeapHashMap<WeakMember<IntWrapper>, PairWithWeakHandling> WeakPairMap;
@@ skipping 93 matching lines @@
   typedef HeapHashMap<WeakMember<IntWrapper>, Member<Link1>> Map;
   Persistent<Map> map = new Map();
   Persistent<IntWrapper> deadObject =
       IntWrapper::create(100);  // Named for "Drowning by Numbers" (1988).
   Persistent<IntWrapper> lifeObject = IntWrapper::create(42);
   map->insert(deadObject, new Link1(deadObject));
   map->insert(lifeObject, new Link1(lifeObject));
   EXPECT_EQ(2u, map->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2u, map->size());
-  EXPECT_EQ(deadObject, map->get(deadObject)->link());
-  EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
+  EXPECT_EQ(deadObject, map->at(deadObject)->link());
+  EXPECT_EQ(lifeObject, map->at(lifeObject)->link());
   deadObject.clear();  // Now it can live up to its name.
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->size());
-  EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
+  EXPECT_EQ(lifeObject, map->at(lifeObject)->link());
   lifeObject.clear();  // Despite its name.
   preciselyCollectGarbage();
   EXPECT_EQ(0u, map->size());
 }
 
 static Mutex& mainThreadMutex() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mainMutex, new Mutex);
   return mainMutex;
 }
 
@@ skipping 1141 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink