Reland 'Convert //net and //chromecast to std::unordered_*'

net/base/address_tracker_linux.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 "net/base/address_tracker_linux.h"
 
 #include <errno.h>
 #include <linux/if.h>
 #include <stdint.h>
 #include <sys/ioctl.h>
@@ skipping 109 matching lines @@
       connection_type_initialized_(false),
       connection_type_initialized_cv_(&connection_type_lock_),
       current_connection_type_(NetworkChangeNotifier::CONNECTION_NONE),
       tracking_(false),
       threads_waiting_for_connection_type_initialization_(0) {}
 
 AddressTrackerLinux::AddressTrackerLinux(
     const base::Closure& address_callback,
     const base::Closure& link_callback,
     const base::Closure& tunnel_callback,
-    const base::hash_set<std::string>& ignored_interfaces)
+    const std::unordered_set<std::string>& ignored_interfaces)
     : get_interface_name_(GetInterfaceName),
       address_callback_(address_callback),
       link_callback_(link_callback),
       tunnel_callback_(tunnel_callback),
       netlink_fd_(-1),
       ignored_interfaces_(ignored_interfaces),
       connection_type_initialized_(false),
       connection_type_initialized_cv_(&connection_type_lock_),
       current_connection_type_(NetworkChangeNotifier::CONNECTION_NONE),
       tracking_(true),
@@ skipping 102 matching lines @@
   current_connection_type_ = NetworkChangeNotifier::CONNECTION_UNKNOWN;
   connection_type_initialized_ = true;
   connection_type_initialized_cv_.Broadcast();
 }
 
 AddressTrackerLinux::AddressMap AddressTrackerLinux::GetAddressMap() const {
   AddressTrackerAutoLock lock(*this, address_map_lock_);
   return address_map_;
 }
 
-base::hash_set<int> AddressTrackerLinux::GetOnlineLinks() const {
+std::unordered_set<int> AddressTrackerLinux::GetOnlineLinks() const {
   AddressTrackerAutoLock lock(*this, online_links_lock_);
   return online_links_;
 }
 
 bool AddressTrackerLinux::IsInterfaceIgnored(int interface_index) const {
   if (ignored_interfaces_.empty())
     return false;
 
   char buf[IFNAMSIZ] = {0};
   const char* interface_name = get_interface_name_(interface_index, buf);
@@ skipping 171 matching lines @@
 }
 
 bool AddressTrackerLinux::IsTunnelInterface(int interface_index) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
   char buf[IFNAMSIZ] = {0};
   return strncmp(get_interface_name_(interface_index, buf), "tun", 3) == 0;
 }
 
 void AddressTrackerLinux::UpdateCurrentConnectionType() {
   AddressTrackerLinux::AddressMap address_map = GetAddressMap();
-  base::hash_set<int> online_links = GetOnlineLinks();
+  std::unordered_set<int> online_links = GetOnlineLinks();
 
   // Strip out tunnel interfaces from online_links
-  for (base::hash_set<int>::const_iterator it = online_links.begin();
+  for (std::unordered_set<int>::const_iterator it = online_links.begin();
        it != online_links.end();) {
     if (IsTunnelInterface(*it)) {
-      base::hash_set<int>::const_iterator tunnel_it = it;
+      std::unordered_set<int>::const_iterator tunnel_it = it;
       ++it;
       online_links.erase(*tunnel_it);
     } else {
       ++it;
     }
   }
 
   NetworkInterfaceList networks;
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::CONNECTION_NONE;
@@ skipping 28 matching lines @@
 
 AddressTrackerLinux::AddressTrackerAutoLock::~AddressTrackerAutoLock() {
   if (tracker_.tracking_) {
     lock_.AssertAcquired();
     lock_.Release();
   }
 }
 
 }  // namespace internal
 }  // namespace net