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

third_party/WebKit/Source/platform/loader/fetch/MemoryCache.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008 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.
@@ skipping 109 matching lines @@
   return emptyString;
 }
 
 MemoryCache::ResourceMap* MemoryCache::ensureResourceMap(
     const String& cacheIdentifier) {
   if (!m_resourceMaps.contains(cacheIdentifier)) {
     ResourceMapIndex::AddResult result =
         m_resourceMaps.insert(cacheIdentifier, new ResourceMap);
     CHECK(result.isNewEntry);
   }
-  return m_resourceMaps.get(cacheIdentifier);
+  return m_resourceMaps.at(cacheIdentifier);
 }
 
 void MemoryCache::add(Resource* resource) {
   DCHECK(resource);
   ResourceMap* resources = ensureResourceMap(resource->cacheIdentifier());
   addInternal(resources, MemoryCacheEntry::create(resource));
   RESOURCE_LOADING_DVLOG(1) << "MemoryCache::add Added "
                             << resource->url().getString() << ", resource "
                             << resource;
 }
@@ skipping 20 matching lines @@
 }
 
 void MemoryCache::remove(Resource* resource) {
   DCHECK(WTF::isMainThread());
   DCHECK(resource);
   RESOURCE_LOADING_DVLOG(1) << "Evicting resource " << resource << " for "
                             << resource->url().getString() << " from cache";
   TRACE_EVENT1("blink", "MemoryCache::evict", "resource",
                resource->url().getString().utf8());
 
-  ResourceMap* resources = m_resourceMaps.get(resource->cacheIdentifier());
+  ResourceMap* resources = m_resourceMaps.at(resource->cacheIdentifier());
   if (!resources)
     return;
 
   KURL url = removeFragmentIdentifierIfNeeded(resource->url());
   ResourceMap::iterator it = resources->find(url);
   if (it == resources->end() || it->value->resource() != resource)
     return;
   removeInternal(resources, it);
 }
 
 void MemoryCache::removeInternal(ResourceMap* resourceMap,
                                  const ResourceMap::iterator& it) {
   DCHECK(WTF::isMainThread());
   DCHECK(resourceMap);
 
   Resource* resource = it->value->resource();
   DCHECK(resource);
 
   update(resource, resource->size(), 0);
   resourceMap->remove(it);
 }
 
 bool MemoryCache::contains(const Resource* resource) const {
   if (!resource || resource->url().isEmpty())
     return false;
-  const ResourceMap* resources =
-      m_resourceMaps.get(resource->cacheIdentifier());
+  const ResourceMap* resources = m_resourceMaps.at(resource->cacheIdentifier());
   if (!resources)
     return false;
   KURL url = removeFragmentIdentifierIfNeeded(resource->url());
-  MemoryCacheEntry* entry = resources->get(url);
+  MemoryCacheEntry* entry = resources->at(url);
   return entry && resource == entry->resource();
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL) const {
   return resourceForURL(resourceURL, defaultCacheIdentifier());
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL,
                                       const String& cacheIdentifier) const {
   DCHECK(WTF::isMainThread());
   if (!resourceURL.isValid() || resourceURL.isNull())
     return nullptr;
   DCHECK(!cacheIdentifier.isNull());
-  const ResourceMap* resources = m_resourceMaps.get(cacheIdentifier);
+  const ResourceMap* resources = m_resourceMaps.at(cacheIdentifier);
   if (!resources)
     return nullptr;
   MemoryCacheEntry* entry =
-      resources->get(removeFragmentIdentifierIfNeeded(resourceURL));
+      resources->at(removeFragmentIdentifierIfNeeded(resourceURL));
   if (!entry)
     return nullptr;
   return entry->resource();
 }
 
 HeapVector<Member<Resource>> MemoryCache::resourcesForURL(
     const KURL& resourceURL) const {
   DCHECK(WTF::isMainThread());
   KURL url = removeFragmentIdentifierIfNeeded(resourceURL);
   HeapVector<Member<Resource>> results;
   for (const auto& resourceMapIter : m_resourceMaps) {
-    if (MemoryCacheEntry* entry = resourceMapIter.value->get(url)) {
+    if (MemoryCacheEntry* entry = resourceMapIter.value->at(url)) {
       Resource* resource = entry->resource();
       DCHECK(resource);
       results.push_back(resource);
     }
   }
   return results;
 }
 
 void MemoryCache::pruneResources(PruneStrategy strategy) {
   DCHECK(!m_prunePending);
@@ skipping 215 matching lines @@
     }
   }
   return true;
 }
 
 void MemoryCache::onMemoryPressure(WebMemoryPressureLevel level) {
   pruneAll();
 }
 
 }  // namespace blink