Remove stl_util's deletion function use from device/.

device/time_zone_monitor/time_zone_monitor_linux.cc

 // Copyright 2014 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 "device/time_zone_monitor/time_zone_monitor.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_path_watcher.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 
 #if !defined(OS_CHROMEOS)
 
 namespace device {
@@ skipping 21 matching lines @@
 // FilePathWatcher needs to run on the FILE thread, but TimeZoneMonitor runs
 // on the UI thread. TimeZoneMonitorLinuxImpl is the bridge between these
 // threads.
 class TimeZoneMonitorLinuxImpl
     : public base::RefCountedThreadSafe<TimeZoneMonitorLinuxImpl> {
  public:
   explicit TimeZoneMonitorLinuxImpl(
       TimeZoneMonitorLinux* owner,
       scoped_refptr<base::SequencedTaskRunner> file_task_runner)
       : base::RefCountedThreadSafe<TimeZoneMonitorLinuxImpl>(),
-        file_path_watchers_(),
         main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         file_task_runner_(file_task_runner),
         owner_(owner) {
     DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&TimeZoneMonitorLinuxImpl::StartWatchingOnFileThread, this));
   }
 
   void StopWatching() {
     DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
     owner_ = NULL;
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&TimeZoneMonitorLinuxImpl::StopWatchingOnFileThread, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<TimeZoneMonitorLinuxImpl>;
 
   ~TimeZoneMonitorLinuxImpl() {
     DCHECK(!owner_);
-    base::STLDeleteElements(&file_path_watchers_);
   }
 
   void StartWatchingOnFileThread() {
     base::ThreadRestrictions::AssertIOAllowed();
     DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
 
     // There is no true standard for where time zone information is actually
     // stored. glibc uses /etc/localtime, uClibc uses /etc/TZ, and some older
     // systems store the name of the time zone file within /usr/share/zoneinfo
     // in /etc/timezone. Different libraries and custom builds may mean that
     // still more paths are used. Just watch all three of these paths, because
     // false positives are harmless, assuming the false positive rate is
     // reasonable.
     const char* const kFilesToWatch[] = {
         "/etc/localtime", "/etc/timezone", "/etc/TZ",
     };
 
     for (size_t index = 0; index < arraysize(kFilesToWatch); ++index) {
-      file_path_watchers_.push_back(new base::FilePathWatcher());
+      file_path_watchers_.push_back(base::MakeUnique<base::FilePathWatcher>());
       file_path_watchers_.back()->Watch(
           base::FilePath(kFilesToWatch[index]), false,
           base::Bind(&TimeZoneMonitorLinuxImpl::OnTimeZoneFileChanged, this));
     }
   }
 
   void StopWatchingOnFileThread() {
     DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
-    base::STLDeleteElements(&file_path_watchers_);
+    file_path_watchers_.clear();
   }
 
   void OnTimeZoneFileChanged(const base::FilePath& path, bool error) {
     DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&TimeZoneMonitorLinuxImpl::OnTimeZoneFileChangedOnUIThread,
                    this));
   }
 
   void OnTimeZoneFileChangedOnUIThread() {
     DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
     if (owner_) {
       owner_->NotifyClientsFromImpl();
     }
   }
 
-  std::vector<base::FilePathWatcher*> file_path_watchers_;
+  std::vector<std::unique_ptr<base::FilePathWatcher>> file_path_watchers_;
 
   scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
   TimeZoneMonitorLinux* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(TimeZoneMonitorLinuxImpl);
 };
 
 }  // namespace
 
@@ skipping 27 matching lines @@
 // static
 std::unique_ptr<TimeZoneMonitor> TimeZoneMonitor::Create(
     scoped_refptr<base::SequencedTaskRunner> file_task_runner) {
   return std::unique_ptr<TimeZoneMonitor>(
       new TimeZoneMonitorLinux(file_task_runner));
 }
 
 }  // namespace device
 
 #endif  // !OS_CHROMEOS