Remove uses of base::hash_map from //chrome

chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 
+#include <map>
+#include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 272 matching lines @@
     std::vector<int> list_ids;
     std::vector<SBPrefix> prefix_hits;
   };
 
   bool ContainsUrl(int list_id0,
                    int list_id1,
                    const std::vector<GURL>& urls,
                    std::vector<SBPrefix>* prefix_hits) {
     bool hit = false;
     for (const GURL& url : urls) {
-      base::hash_map<std::string, Hits>::const_iterator badurls_it =
-          badurls_.find(url.spec());
-
+      const auto badurls_it = badurls_.find(url.spec());
       if (badurls_it == badurls_.end())
         continue;
 
-      std::vector<int> list_ids_for_url = badurls_it->second.list_ids;
+      const std::vector<int>& list_ids_for_url = badurls_it->second.list_ids;
       if (base::ContainsValue(list_ids_for_url, list_id0) ||
           base::ContainsValue(list_ids_for_url, list_id1)) {
         prefix_hits->insert(prefix_hits->end(),
                             badurls_it->second.prefix_hits.begin(),
                             badurls_it->second.prefix_hits.end());
         hit = true;
       }
     }
     return hit;
   }
@@ skipping 19 matching lines @@
         if (entry.second == prefix &&
             (entry.first == list_id0 || entry.first == list_id1)) {
           prefix_hits->push_back(prefix);
           hit = true;
         }
       }
     }
     return hit;
   }
 
-  base::hash_map<std::string, Hits> badurls_;
-  base::hash_set<std::pair<int, SBPrefix>> bad_prefixes_;
-  base::hash_map<std::string, GURL> urls_by_hash_;
+  std::map<std::string, Hits> badurls_;
+  std::set<std::pair<int, SBPrefix>> bad_prefixes_;
+  std::map<std::string, GURL> urls_by_hash_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSafeBrowsingDatabase);
 };
 
 // Factory that creates TestSafeBrowsingDatabase instances.
 class TestSafeBrowsingDatabaseFactory : public SafeBrowsingDatabaseFactory {
  public:
   TestSafeBrowsingDatabaseFactory() : db_(nullptr) {}
   ~TestSafeBrowsingDatabaseFactory() override {}
 
@@ skipping 24 matching lines @@
                       net::URLRequestContextGetter* request_context_getter,
                       const SafeBrowsingProtocolConfig& config)
       : SafeBrowsingProtocolManager(delegate, request_context_getter, config) {
     create_count_++;
   }
 
   ~TestProtocolManager() override { delete_count_++; }
 
   // This function is called when there is a prefix hit in local safebrowsing
   // database and safebrowsing service issues a get hash request to backends.
-  // We return a result from the prefilled full_hashes_ hash_map to simulate
+  // We return a result from the prefilled full_hashes_ map to simulate
   // server's response. At the same time, latency is added to simulate real
   // life network issues.
   void GetFullHash(const std::vector<SBPrefix>& prefixes,
                    SafeBrowsingProtocolManager::FullHashCallback callback,
                    bool is_download,
                    ExtendedReportingLevel reporting_level) override {
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::BindOnce(InvokeFullHashCallback, callback, full_hashes_), delay_);
   }
@@ skipping 1940 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     MaybeSetMetadata,
     V4SafeBrowsingServiceMetadataTest,
     testing::Values(ThreatPatternType::NONE,
                     ThreatPatternType::MALWARE_LANDING,
                     ThreatPatternType::MALWARE_DISTRIBUTION));
 
 }  // namespace safe_browsing