Remove stl_util's deletion function use from components/invalidation/.

components/invalidation/impl/registration_manager.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/registration_manager.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "google/cacheinvalidation/include/invalidation-client.h"
 #include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
 RegistrationManager::PendingRegistrationInfo::PendingRegistrationInfo() {}
 
@@ skipping 33 matching lines @@
 const int RegistrationManager::kMaxRegistrationDelaySeconds = 60 * 60;
 
 RegistrationManager::RegistrationManager(
     invalidation::InvalidationClient* invalidation_client)
     : invalidation_client_(invalidation_client) {
   DCHECK(invalidation_client_);
 }
 
 RegistrationManager::~RegistrationManager() {
   DCHECK(CalledOnValidThread());
-  base::STLDeleteValues(&registration_statuses_);
 }
 
 ObjectIdSet RegistrationManager::UpdateRegisteredIds(const ObjectIdSet& ids) {
   DCHECK(CalledOnValidThread());
 
   const ObjectIdSet& old_ids = GetRegisteredIds();
   const ObjectIdSet& to_register = ids;
   ObjectIdSet to_unregister;
   std::set_difference(old_ids.begin(), old_ids.end(),
                       ids.begin(), ids.end(),
                       std::inserter(to_unregister, to_unregister.begin()),
                       ObjectIdLessThan());
 
   for (ObjectIdSet::const_iterator it = to_unregister.begin();
        it != to_unregister.end(); ++it) {
     UnregisterId(*it);
   }
 
   for (ObjectIdSet::const_iterator it = to_register.begin();
        it != to_register.end(); ++it) {
     if (!base::ContainsKey(registration_statuses_, *it)) {
-      registration_statuses_.insert(
-          std::make_pair(*it, new RegistrationStatus(*it, this)));
+      registration_statuses_[*it] =
+          base::MakeUnique<RegistrationStatus>(*it, this);
     }
     if (!IsIdRegistered(*it)) {
       TryRegisterId(*it, false /* is-retry */);
     }
   }
 
   return to_unregister;
 }
 
 void RegistrationManager::MarkRegistrationLost(
     const invalidation::ObjectId& id) {
   DCHECK(CalledOnValidThread());
-  RegistrationStatusMap::const_iterator it = registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     DVLOG(1) << "Attempt to mark non-existent registration for "
              << ObjectIdToString(id) << " as lost";
     return;
   }
   if (!it->second->enabled) {
     return;
   }
   it->second->state = invalidation::InvalidationListener::UNREGISTERED;
   bool is_retry = !it->second->last_registration_request.is_null();
   TryRegisterId(id, is_retry);
 }
 
 void RegistrationManager::MarkAllRegistrationsLost() {
   DCHECK(CalledOnValidThread());
-  for (RegistrationStatusMap::const_iterator it =
-           registration_statuses_.begin();
+  for (auto it = registration_statuses_.begin();
        it != registration_statuses_.end(); ++it) {
     if (IsIdRegistered(it->first)) {
       MarkRegistrationLost(it->first);
     }
   }
 }
 
 void RegistrationManager::DisableId(const invalidation::ObjectId& id) {
   DCHECK(CalledOnValidThread());
-  RegistrationStatusMap::const_iterator it = registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     DVLOG(1) << "Attempt to disable non-existent registration for "
              << ObjectIdToString(id);
     return;
   }
   it->second->Disable();
 }
 
 // static
 double RegistrationManager::CalculateBackoff(
@@ skipping 15 matching lines @@
 }
 
 ObjectIdSet RegistrationManager::GetRegisteredIdsForTest() const {
   return GetRegisteredIds();
 }
 
 RegistrationManager::PendingRegistrationMap
     RegistrationManager::GetPendingRegistrationsForTest() const {
   DCHECK(CalledOnValidThread());
   PendingRegistrationMap pending_registrations;
-  for (RegistrationStatusMap::const_iterator it =
-           registration_statuses_.begin();
-       it != registration_statuses_.end(); ++it) {
-    const invalidation::ObjectId& id = it->first;
-    RegistrationStatus* status = it->second;
+  for (const auto& status_pair : registration_statuses_) {
+    const invalidation::ObjectId& id = status_pair.first;
+    RegistrationStatus* status = status_pair.second.get();
     if (status->registration_timer.IsRunning()) {
       pending_registrations[id].last_registration_request =
           status->last_registration_request;
       pending_registrations[id].registration_attempt =
           status->last_registration_attempt;
       pending_registrations[id].delay = status->delay;
       pending_registrations[id].actual_delay =
           status->registration_timer.GetCurrentDelay();
     }
   }
   return pending_registrations;
 }
 
 void RegistrationManager::FirePendingRegistrationsForTest() {
   DCHECK(CalledOnValidThread());
-  for (RegistrationStatusMap::const_iterator it =
-           registration_statuses_.begin();
-       it != registration_statuses_.end(); ++it) {
-    if (it->second->registration_timer.IsRunning()) {
-      it->second->DoRegister();
+  for (const auto& status_pair : registration_statuses_) {
+    if (status_pair.second->registration_timer.IsRunning()) {
+      status_pair.second->DoRegister();
     }
   }
 }
 
 double RegistrationManager::GetJitter() {
   // |jitter| lies in [-1.0, 1.0), which is low-biased, but only
   // barely.
   //
   // TODO(akalin): Fix the bias.
   return 2.0 * base::RandDouble() - 1.0;
 }
 
 void RegistrationManager::TryRegisterId(const invalidation::ObjectId& id,
                                         bool is_retry) {
   DCHECK(CalledOnValidThread());
-  RegistrationStatusMap::const_iterator it = registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "TryRegisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
-  RegistrationStatus* status = it->second;
+  RegistrationStatus* status = it->second.get();
   if (!status->enabled) {
     // Disabled, so do nothing.
     return;
   }
   status->last_registration_attempt = base::Time::Now();
   if (is_retry) {
     // If we're a retry, we must have tried at least once before.
     DCHECK(!status->last_registration_request.is_null());
     // delay = max(0, (now - last request) + next_delay)
     status->delay =
@@ skipping 27 matching lines @@
              << ObjectIdToString(id) << " immediately";
     status->delay = base::TimeDelta();
     status->next_delay = base::TimeDelta();
     status->DoRegister();
   }
 }
 
 void RegistrationManager::DoRegisterId(const invalidation::ObjectId& id) {
   DCHECK(CalledOnValidThread());
   invalidation_client_->Register(id);
-  RegistrationStatusMap::const_iterator it = registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "DoRegisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
   it->second->state = invalidation::InvalidationListener::REGISTERED;
   it->second->last_registration_request = base::Time::Now();
 }
 
 void RegistrationManager::UnregisterId(const invalidation::ObjectId& id) {
   DCHECK(CalledOnValidThread());
   invalidation_client_->Unregister(id);
-  RegistrationStatusMap::iterator it = registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "UnregisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
-  delete it->second;
   registration_statuses_.erase(it);
 }
 
 
 ObjectIdSet RegistrationManager::GetRegisteredIds() const {
   DCHECK(CalledOnValidThread());
   ObjectIdSet ids;
-  for (RegistrationStatusMap::const_iterator it =
-           registration_statuses_.begin();
-       it != registration_statuses_.end(); ++it) {
-    if (IsIdRegistered(it->first)) {
-      ids.insert(it->first);
+  for (const auto& status_pair : registration_statuses_) {
+    if (IsIdRegistered(status_pair.first)) {
+      ids.insert(status_pair.first);
     }
   }
   return ids;
 }
 
 bool RegistrationManager::IsIdRegistered(
     const invalidation::ObjectId& id) const {
   DCHECK(CalledOnValidThread());
-  RegistrationStatusMap::const_iterator it =
-      registration_statuses_.find(id);
+  auto it = registration_statuses_.find(id);
   return it != registration_statuses_.end() &&
       it->second->state == invalidation::InvalidationListener::REGISTERED;
 }
 
 }  // namespace syncer