Replace uses of hash_map in //base

base/files/file_path_watcher_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 "base/files/file_path_watcher.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/containers/hash_tables.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/posix/eintr_wrapper.h"
@@ skipping 32 matching lines @@
   friend struct LazyInstanceTraitsBase<InotifyReader>;
 
   typedef std::set<FilePathWatcherImpl*> WatcherSet;
 
   InotifyReader();
   // There is no destructor because |g_inotify_reader| is a
   // base::LazyInstace::Leaky object. Having a destructor causes build
   // issues with GCC 6 (http://crbug.com/636346).
 
   // We keep track of which delegates want to be notified on which watches.
-  hash_map<Watch, WatcherSet> watchers_;
+  std::unordered_map<Watch, WatcherSet> watchers_;
 
   // Lock to protect watchers_.
   Lock lock_;
 
   // Separate thread on which we run blocking read for inotify events.
   Thread thread_;
 
   // File descriptor returned by inotify_init.
   const int inotify_fd_;
 
@@ skipping 90 matching lines @@
   // The file or directory we're supposed to watch.
   FilePath target_;
 
   bool recursive_;
 
   // The vector of watches and next component names for all path components,
   // starting at the root directory. The last entry corresponds to the watch for
   // |target_| and always stores an empty next component name in |subdir|.
   WatchVector watches_;
 
-  hash_map<InotifyReader::Watch, FilePath> recursive_paths_by_watch_;
+  std::unordered_map<InotifyReader::Watch, FilePath> recursive_paths_by_watch_;
   std::map<FilePath, InotifyReader::Watch> recursive_watches_by_path_;
 
   WeakPtrFactory<FilePathWatcherImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 void InotifyReaderCallback(InotifyReader* reader, int inotify_fd) {
   // Make sure the file descriptors are good for use with select().
   CHECK_LE(0, inotify_fd);
@@ skipping 391 matching lines @@
   DCHECK(!ContainsKey(recursive_paths_by_watch_, watch));
   DCHECK(!ContainsKey(recursive_watches_by_path_, path));
   recursive_paths_by_watch_[watch] = path;
   recursive_watches_by_path_[path] = watch;
 }
 
 void FilePathWatcherImpl::RemoveRecursiveWatches() {
   if (!recursive_)
     return;
 
-  for (hash_map<InotifyReader::Watch, FilePath>::const_iterator it =
-           recursive_paths_by_watch_.begin();
-       it != recursive_paths_by_watch_.end();
-       ++it) {
-    g_inotify_reader.Get().RemoveWatch(it->first, this);
-  }
+  for (const auto& it : recursive_paths_by_watch_)
+    g_inotify_reader.Get().RemoveWatch(it.first, this);
+
   recursive_paths_by_watch_.clear();
   recursive_watches_by_path_.clear();
 }
 
 void FilePathWatcherImpl::AddWatchForBrokenSymlink(const FilePath& path,
                                                    WatchEntry* watch_entry) {
   DCHECK_EQ(InotifyReader::kInvalidWatch, watch_entry->watch);
   FilePath link;
   if (!ReadSymbolicLink(path, &link))
     return;
@@ skipping 29 matching lines @@
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   sequence_checker_.DetachFromSequence();
   impl_ = MakeUnique<FilePathWatcherImpl>();
 }
 
 }  // namespace base