Remove use of stl_util in drive.

components/drive/file_write_watcher.cc

 // Copyright 2013 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 "components/drive/file_write_watcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path_watcher.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/timer/timer.h"
 #include "google_apis/drive/task_util.h"
 
 namespace drive {
 namespace internal {
 
 namespace {
 const int64_t kWriteEventDelayInSeconds = 5;
 }  // namespace
 
@@ skipping 35 matching lines @@
     base::FilePathWatcher watcher;
     base::Timer timer;
 
     explicit PathWatchInfo(const base::Closure& on_write_callback)
         : on_write_callbacks(1, on_write_callback),
           timer(false /* retain_closure_on_reset */, false /* is_repeating */) {
     }
   };
 
   base::TimeDelta delay_;
-  std::map<base::FilePath, PathWatchInfo*> watchers_;
+  std::map<base::FilePath, std::unique_ptr<PathWatchInfo>> watchers_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   base::ThreadChecker thread_checker_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<FileWriteWatcherImpl> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(FileWriteWatcherImpl);
 };
 
@@ skipping 23 matching lines @@
   file_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FileWriteWatcherImpl::StartWatchOnFileThread,
                  base::Unretained(this), path,
                  google_apis::CreateRelayCallback(on_start_callback),
                  google_apis::CreateRelayCallback(on_write_callback)));
 }
 
 FileWriteWatcher::FileWriteWatcherImpl::~FileWriteWatcherImpl() {
   DCHECK(file_task_runner_->BelongsToCurrentThread());
-
-  base::STLDeleteContainerPairSecondPointers(watchers_.begin(),
-                                             watchers_.end());
 }
 
 void FileWriteWatcher::FileWriteWatcherImpl::DestroyOnFileThread() {
   DCHECK(file_task_runner_->BelongsToCurrentThread());
 
   delete this;
 }
 
 void FileWriteWatcher::FileWriteWatcherImpl::StartWatchOnFileThread(
     const base::FilePath& path,
     const StartWatchCallback& on_start_callback,
     const base::Closure& on_write_callback) {
   DCHECK(file_task_runner_->BelongsToCurrentThread());
 
-  std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
+  auto it = watchers_.find(path);
   if (it != watchers_.end()) {
     // We are already watching the path.
     on_start_callback.Run(true);
     it->second->on_write_callbacks.push_back(on_write_callback);
     return;
   }
 
   // Start watching |path|.
-  std::unique_ptr<PathWatchInfo> info(new PathWatchInfo(on_write_callback));
+  std::unique_ptr<PathWatchInfo> info =
+      base::MakeUnique<PathWatchInfo>(on_write_callback);
   bool ok = info->watcher.Watch(
       path,
       false,  // recursive
       base::Bind(&FileWriteWatcherImpl::OnWriteEvent,
                  weak_ptr_factory_.GetWeakPtr()));
-  watchers_[path] = info.release();
+  watchers_[path] = std::move(info);
   on_start_callback.Run(ok);
 }
 
 void FileWriteWatcher::FileWriteWatcherImpl::OnWriteEvent(
     const base::FilePath& path,
     bool error) {
   DCHECK(file_task_runner_->BelongsToCurrentThread());
 
   if (error)
     return;
 
-  std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
+  auto it = watchers_.find(path);
   DCHECK(it != watchers_.end());
 
   // Heuristics for detecting the end of successive write operations.
   // Delay running on_write_event_callback by |delay_| time, and if OnWriteEvent
   // is called again in the period, the timer is reset. In other words, we
   // invoke callback when |delay_| has passed after the last OnWriteEvent().
   it->second->timer.Start(FROM_HERE,
                           delay_,
                           base::Bind(&FileWriteWatcherImpl::InvokeCallback,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      path));
 }
 
 void FileWriteWatcher::FileWriteWatcherImpl::InvokeCallback(
     const base::FilePath& path) {
   DCHECK(file_task_runner_->BelongsToCurrentThread());
 
-  std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
+  auto it = watchers_.find(path);
   DCHECK(it != watchers_.end());
 
   std::vector<base::Closure> callbacks;
   callbacks.swap(it->second->on_write_callbacks);
-  delete it->second;
   watchers_.erase(it);
 
-  for (size_t i = 0; i < callbacks.size(); ++i)
-    callbacks[i].Run();
+  for (const auto& callback : callbacks)
+    callback.Run();
 }
 
 FileWriteWatcher::FileWriteWatcher(
     base::SingleThreadTaskRunner* file_task_runner)
     : watcher_impl_(new FileWriteWatcherImpl(file_task_runner)) {
 }
 
 FileWriteWatcher::~FileWriteWatcher() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void FileWriteWatcher::StartWatch(const base::FilePath& file_path,
                                   const StartWatchCallback& on_start_callback,
                                   const base::Closure& on_write_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   watcher_impl_->StartWatch(file_path, on_start_callback, on_write_callback);
 }
 
 void FileWriteWatcher::DisableDelayForTesting() {
   watcher_impl_->set_delay(base::TimeDelta());
 }
 
 }  // namespace internal
 }  // namespace drive