Remove uses of base::hash_map from //chrome

chrome/browser/safe_browsing/threat_details_unittest.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 <stdint.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 252 matching lines @@
     EXPECT_EQ(expected_pb.referrer_url(), report_pb.referrer_url());
     EXPECT_EQ(expected_pb.did_proceed(), report_pb.did_proceed());
     EXPECT_EQ(expected_pb.has_repeat_visit(), report_pb.has_repeat_visit());
     if (expected_pb.has_repeat_visit() && report_pb.has_repeat_visit()) {
       EXPECT_EQ(expected_pb.repeat_visit(), report_pb.repeat_visit());
     }
 
     ASSERT_EQ(expected_pb.resources_size(), report_pb.resources_size());
     // Put the actual resources in a map, then iterate over the expected
     // resources, making sure each exists and is equal.
-    base::hash_map<int, const ClientSafeBrowsingReportRequest::Resource*>
+    std::map<int, const ClientSafeBrowsingReportRequest::Resource*>
         actual_resource_map;
     for (const ClientSafeBrowsingReportRequest::Resource& resource :
          report_pb.resources()) {
       actual_resource_map[resource.id()] = &resource;
     }
     // Make sure no resources disappeared when moving them to a map (IDs should
     // be unique).
     ASSERT_EQ(expected_pb.resources_size(),
               static_cast<int>(actual_resource_map.size()));
     for (const ClientSafeBrowsingReportRequest::Resource& expected_resource :
          expected_pb.resources()) {
       ASSERT_TRUE(actual_resource_map.count(expected_resource.id()) > 0);
       VerifyResource(*actual_resource_map[expected_resource.id()],
                      expected_resource);
     }
 
     ASSERT_EQ(expected_pb.dom_size(), report_pb.dom_size());
     // Put the actual elements in a map, then iterate over the expected
     // elements, making sure each exists and is equal.
-    base::hash_map<int, const HTMLElement*> actual_dom_map;
+    std::map<int, const HTMLElement*> actual_dom_map;
     for (const HTMLElement& element : report_pb.dom()) {
       actual_dom_map[element.id()] = &element;
     }
     // Make sure no elements disappeared when moving them to a map (IDs should
     // be unique).
     ASSERT_EQ(expected_pb.dom_size(), static_cast<int>(actual_dom_map.size()));
     for (const HTMLElement& expected_element : expected_pb.dom()) {
       ASSERT_TRUE(actual_dom_map.count(expected_element.id()) > 0);
       VerifyElement(*actual_dom_map[expected_element.id()], expected_element);
     }
@@ skipping 41 matching lines @@
     EXPECT_EQ(expected.response().remote_ip(), resource.response().remote_ip());
   }
 
   void VerifyElement(const HTMLElement& element, const HTMLElement& expected) {
     EXPECT_EQ(expected.id(), element.id());
     EXPECT_EQ(expected.tag(), element.tag());
     EXPECT_EQ(expected.resource_id(), element.resource_id());
     EXPECT_THAT(element.child_ids(),
                 UnorderedPointwise(Eq(), expected.child_ids()));
     ASSERT_EQ(expected.attribute_size(), element.attribute_size());
-    base::hash_map<std::string, std::string> actual_attributes_map;
+    std::map<std::string, std::string> actual_attributes_map;
     for (const HTMLElement::Attribute& attribute : element.attribute()) {
       actual_attributes_map[attribute.name()] = attribute.value();
     }
     ASSERT_EQ(expected.attribute_size(),
               static_cast<int>(actual_attributes_map.size()));
     for (const HTMLElement::Attribute& expected_attribute :
          expected.attribute()) {
       ASSERT_TRUE(actual_attributes_map.count(expected_attribute.name()) > 0);
       EXPECT_EQ(expected_attribute.value(),
                 actual_attributes_map[expected_attribute.name()]);
@@ skipping 997 matching lines @@
   pb_resource->set_parent_id(3);
   pb_resource->set_url(kSecondRedirectURL);
   pb_resource = expected.add_resources();
   pb_resource->set_id(3);
   pb_resource->set_url(kFirstRedirectURL);
 
   VerifyResults(actual, expected);
 }
 
 }  // namespace safe_browsing