Reland of move stl_util's deletion function use from components/invalidation/.

components/invalidation/impl/sync_system_resources.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 "components/invalidation/impl/sync_system_resources.h"
 
+#include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/invalidation/impl/gcm_network_channel.h"
 #include "components/invalidation/impl/gcm_network_channel_delegate.h"
 #include "components/invalidation/impl/push_client_channel.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "google/cacheinvalidation/deps/callback.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "jingle/notifier/listener/push_client.h"
@@ skipping 58 matching lines @@
   is_started_ = true;
   is_stopped_ = false;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void SyncInvalidationScheduler::Stop() {
   CHECK(IsRunningOnThread());
   is_stopped_ = true;
   is_started_ = false;
   weak_factory_.InvalidateWeakPtrs();
-  base::STLDeleteElements(&posted_tasks_);
+  posted_tasks_.clear();
 }
 
 void SyncInvalidationScheduler::Schedule(invalidation::TimeDelta delay,
                                          invalidation::Closure* task) {
   DCHECK(invalidation::IsCallbackRepeatable(task));
   CHECK(IsRunningOnThread());
 
   if (!is_started_) {
     delete task;
     return;
   }
 
-  posted_tasks_.insert(task);
+  posted_tasks_.insert(base::WrapUnique(task));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&SyncInvalidationScheduler::RunPostedTask,
                             weak_factory_.GetWeakPtr(), task),
       delay);
 }
 
 bool SyncInvalidationScheduler::IsRunningOnThread() const {
   return created_on_task_runner_->BelongsToCurrentThread();
 }
 
 invalidation::Time SyncInvalidationScheduler::GetCurrentTime() const {
   CHECK(IsRunningOnThread());
   return base::Time::Now();
 }
 
 void SyncInvalidationScheduler::SetSystemResources(
     invalidation::SystemResources* resources) {
   // Do nothing.
 }
 
 void SyncInvalidationScheduler::RunPostedTask(invalidation::Closure* task) {
   CHECK(IsRunningOnThread());
   task->Run();
-  posted_tasks_.erase(task);
-  delete task;
+  auto it =
+      std::find_if(posted_tasks_.begin(), posted_tasks_.end(),
+                   [task](const std::unique_ptr<invalidation::Closure>& ptr) {
+                     return ptr.get() == task;
+                   });
+  posted_tasks_.erase(it);
 }
 
 SyncNetworkChannel::SyncNetworkChannel()
     : last_network_status_(false),
       received_messages_count_(0) {}
 
 SyncNetworkChannel::~SyncNetworkChannel() {
-  base::STLDeleteElements(&network_status_receivers_);
 }
 
 void SyncNetworkChannel::SetMessageReceiver(
     invalidation::MessageCallback* incoming_receiver) {
   incoming_receiver_.reset(incoming_receiver);
 }
 
 void SyncNetworkChannel::AddNetworkStatusReceiver(
     invalidation::NetworkStatusCallback* network_status_receiver) {
   network_status_receiver->Run(last_network_status_);
-  network_status_receivers_.push_back(network_status_receiver);
+  network_status_receivers_.push_back(
+      base::WrapUnique(network_status_receiver));
 }
 
 void SyncNetworkChannel::SetSystemResources(
     invalidation::SystemResources* resources) {
   // Do nothing.
 }
 
 void SyncNetworkChannel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 13 matching lines @@
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     std::unique_ptr<GCMNetworkChannelDelegate> delegate) {
   return base::MakeUnique<GCMNetworkChannel>(request_context_getter,
                                              std::move(delegate));
 }
 
 void SyncNetworkChannel::NotifyNetworkStatusChange(bool online) {
   // Remember network state for future NetworkStatusReceivers.
   last_network_status_ = online;
   // Notify NetworkStatusReceivers in cacheinvalidation.
-  for (NetworkStatusReceiverList::const_iterator it =
-           network_status_receivers_.begin();
-       it != network_status_receivers_.end(); ++it) {
-    (*it)->Run(online);
+  for (const auto& receiver : network_status_receivers_) {
+    receiver->Run(online);
   }
 }
 
 void SyncNetworkChannel::NotifyChannelStateChange(
     InvalidatorState invalidator_state) {
   for (auto& observer : observers_)
     observer.OnNetworkChannelStateChanged(invalidator_state);
 }
 
 bool SyncNetworkChannel::DeliverIncomingMessage(const std::string& message) {
@@ skipping 22 matching lines @@
 
 void SyncStorage::WriteKey(const std::string& key, const std::string& value,
                            invalidation::WriteKeyCallback* done) {
   CHECK(state_writer_);
   // TODO(ghc): actually write key,value associations, and don't invoke the
   // callback until the operation completes.
   state_writer_->WriteState(value);
   cached_state_ = value;
   // According to the cache invalidation API folks, we can do this as
   // long as we make sure to clear the persistent state that we start
-  // up the cache invalidation client with.  However, we musn't do it
+  // up the cache invalidation client with.  However, we mustn't do it
   // right away, as we may be called under a lock that the callback
   // uses.
   scheduler_->Schedule(
       invalidation::Scheduler::NoDelay(),
       invalidation::NewPermanentCallback(
           this, &SyncStorage::RunAndDeleteWriteKeyCallback,
           done));
 }
 
 void SyncStorage::ReadKey(const std::string& key,
@@ skipping 85 matching lines @@
 
 SyncInvalidationScheduler* SyncSystemResources::internal_scheduler() {
   return internal_scheduler_.get();
 }
 
 SyncInvalidationScheduler* SyncSystemResources::listener_scheduler() {
   return listener_scheduler_.get();
 }
 
 }  // namespace syncer