Remove uses of base::hash_map from //chrome

chrome/renderer/safe_browsing/phishing_dom_feature_extractor_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.
 
 #include "chrome/renderer/safe_browsing/phishing_dom_feature_extractor.h"
 
 #include <memory>
+#include <unordered_map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/renderer/safe_browsing/features.h"
 #include "chrome/renderer/safe_browsing/mock_feature_extractor_clock.h"
@@ skipping 25 matching lines @@
 // CompleteURL() functions. This is to work around the fact that
 // ChromeRenderViewTest object does not know where the html content is hosted.
 class TestPhishingDOMFeatureExtractor : public PhishingDOMFeatureExtractor {
  public:
   explicit TestPhishingDOMFeatureExtractor(FeatureExtractorClock* clock)
       : PhishingDOMFeatureExtractor(clock) {}
 
   void SetDocumentDomain(std::string domain) { base_domain_ = domain; }
 
   void SetURLToFrameDomainCheckingMap(
-      const base::hash_map<std::string, std::string>& checking_map) {
+      const std::unordered_map<std::string, std::string>& checking_map) {
     url_to_frame_domain_map_ = checking_map;
   }
 
   void Reset() {
     base_domain_.clear();
     url_to_frame_domain_map_.clear();
   }
 
  private:
   // LoadHTML() function in RenderViewTest only loads html as data,
@@ skipping 51 matching lines @@
     return blink::WebURL(full_url);
   }
 
   // If there is only main frame, we use base_domain_ to track where
   // the html content is hosted.
   std::string base_domain_;
 
   // If html contains multiple frame/iframe, we track domain of each frame by
   // using this map, where keys are the urls mentioned in the html content,
   // values are the domains of the corresponding frames.
-  base::hash_map<std::string, std::string> url_to_frame_domain_map_;
+  std::unordered_map<std::string, std::string> url_to_frame_domain_map_;
 };
 
 class TestChromeContentRendererClient : public ChromeContentRendererClient {
  public:
   TestChromeContentRendererClient() {}
   ~TestChromeContentRendererClient() override {}
   // Since visited_link_slave_ in ChromeContentRenderClient never get initiated,
   // overrides VisitedLinkedHash() function to prevent crashing.
   unsigned long long VisitedLinkHash(const char* canonical_url,
                                      size_t length) override {
@@ skipping 11 matching lines @@
   bool GetSuccess() { return success_; }
   void ResetTest() {
     success_ = false;
     message_loop_ = new content::MessageLoopRunner;
     extractor_->Reset();
   }
 
   void ExtractFeaturesAcrossFrames(
       const std::string& html_content,
       FeatureMap* features,
-      const base::hash_map<std::string, std::string>& url_frame_domain_map) {
+      const std::unordered_map<std::string, std::string>&
+          url_frame_domain_map) {
     extractor_->SetURLToFrameDomainCheckingMap(url_frame_domain_map);
     LoadHTML(html_content.c_str());
 
     extractor_->ExtractFeatures(
         GetMainFrame()->GetDocument(), features,
         base::Bind(&PhishingDOMFeatureExtractorTest::AnotherExtractionDone,
                    weak_factory_.GetWeakPtr()));
     message_loop_->Run();
   }
 
@@ skipping 200 matching lines @@
 // A page with nested iframes.
 //         html
 // iframe2 /  \ iframe1
 //              \ iframe3
 TEST_F(PhishingDOMFeatureExtractorTest, SubFrames) {
   // This test doesn't exercise the extraction timing.
   // Test that features are aggregated across all frames.
   EXPECT_CALL(clock_, Now()).WillRepeatedly(Return(base::TimeTicks::Now()));
 
   const char urlprefix[] = "data:text/html;charset=utf-8,";
-  base::hash_map<std::string, std::string> url_iframe_map;
+  std::unordered_map<std::string, std::string> url_iframe_map;
   std::string iframe1_nested_html(
       "<html><body><input type=password>"
       "<a href=\"https://host3.com/submit\">link</a>"
       "<a href=\"relative\">link</a>"
       "</body></html>");
   GURL iframe1_nested_url(urlprefix + iframe1_nested_html);
   // iframe1_nested is on host1.com.
   url_iframe_map["https://host3.com/submit"] = "host1.com";
   url_iframe_map["relative"] = "host1.com";
 
@@ skipping 180 matching lines @@
       "<html><head></head><body>"
       "<iframe src=\"" +
       net::EscapeForHTML(iframe1_url.spec()) +
       "\" id=\"frame1\"></iframe>"
       "<form></form></body></html>");
   ExtractFeatures("host.com", html, &features);
   ExpectFeatureMapsAreEqual(features, expected_features);
 }
 
 }  // namespace safe_browsing