Update usages of std::map to use ScopedPtrMap.

components/gcm_driver/gcm_client_impl.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/gcm_driver/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 284 matching lines @@
 }
 
 GCMClientImpl::GCMClientImpl(scoped_ptr<GCMInternalsBuilder> internals_builder)
     : internals_builder_(internals_builder.Pass()),
       state_(UNINITIALIZED),
       delegate_(NULL),
       start_mode_(DELAYED_START),
       clock_(internals_builder_->BuildClock()),
       gcm_store_reset_(false),
       url_request_context_getter_(NULL),
-      pending_registration_requests_deleter_(&pending_registration_requests_),
-      pending_unregistration_requests_deleter_(
-          &pending_unregistration_requests_),
       periodic_checkin_ptr_factory_(this),
       destroying_gcm_store_ptr_factory_(this),
       weak_ptr_factory_(this) {
 }
 
 GCMClientImpl::~GCMClientImpl() {
 }
 
 void GCMClientImpl::Initialize(
     const ChromeBuildInfo& chrome_build_info,
@@ skipping 514 matching lines @@
 
 void GCMClientImpl::ResetCache() {
   weak_ptr_factory_.InvalidateWeakPtrs();
   periodic_checkin_ptr_factory_.InvalidateWeakPtrs();
   device_checkin_info_.Reset();
   connection_factory_.reset();
   delegate_->OnDisconnected();
   mcs_client_.reset();
   checkin_request_.reset();
   // Delete all of the pending registration and unregistration requests.
-  STLDeleteValues(&pending_registration_requests_);
-  STLDeleteValues(&pending_unregistration_requests_);
+  pending_registration_requests_.clear();
+  pending_unregistration_requests_.clear();
 }
 
 void GCMClientImpl::Register(
     const linked_ptr<RegistrationInfo>& registration_info) {
   DCHECK_EQ(state_, READY);
 
   // Find and use the cached registration ID.
   RegistrationInfoMap::const_iterator registrations_iter =
       registrations_.find(registration_info);
   if (registrations_iter != registrations_.end()) {
@@ skipping 56 matching lines @@
           ConstructGCMVersion(chrome_build_info_.version),
           instance_id_token_info->options));
     source_to_record = instance_id_token_info->authorized_entity;
   }
 
   RegistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
       device_checkin_info_.secret,
       registration_info->app_id);
 
-  RegistrationRequest* registration_request =
-      new RegistrationRequest(gservices_settings_.GetRegistrationURL(),
-                              request_info,
-                              request_handler.Pass(),
-                              GetGCMBackoffPolicy(),
-                              base::Bind(&GCMClientImpl::OnRegisterCompleted,
-                                          weak_ptr_factory_.GetWeakPtr(),
-                                          registration_info),
-                              kMaxRegistrationRetries,
-                              url_request_context_getter_,
-                              &recorder_,
-                              source_to_record);
-  pending_registration_requests_[registration_info] = registration_request;
+  scoped_ptr<RegistrationRequest> registration_request(new RegistrationRequest(
+      gservices_settings_.GetRegistrationURL(), request_info,
+      request_handler.Pass(), GetGCMBackoffPolicy(),
+      base::Bind(&GCMClientImpl::OnRegisterCompleted,
+                 weak_ptr_factory_.GetWeakPtr(), registration_info),
+      kMaxRegistrationRetries, url_request_context_getter_, &recorder_,
+      source_to_record));
   registration_request->Start();
+  pending_registration_requests_.insert(registration_info,
+                                        registration_request.Pass());
 }
 
 void GCMClientImpl::OnRegisterCompleted(
     const linked_ptr<RegistrationInfo>& registration_info,
     RegistrationRequest::Status status,
     const std::string& registration_id) {
   DCHECK(delegate_);
 
   Result result;
-  PendingRegistrationRequests::iterator iter =
+  PendingRegistrationRequests::const_iterator iter =
       pending_registration_requests_.find(registration_info);
   if (iter == pending_registration_requests_.end())
     result = UNKNOWN_ERROR;
   else if (status == RegistrationRequest::INVALID_SENDER)
     result = INVALID_PARAMETER;
   else if (registration_id.empty())
     result = SERVER_ERROR;
   else
     result = SUCCESS;
 
   if (result == SUCCESS) {
     // Cache it.
     registrations_[registration_info] = registration_id;
 
     // Save it in the persistent store.
     gcm_store_->AddRegistration(
         registration_info->GetSerializedKey(),
         registration_info->GetSerializedValue(registration_id),
         base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   delegate_->OnRegisterFinished(
       registration_info,
       result == SUCCESS ? registration_id : std::string(),
       result);
 
-  if (iter != pending_registration_requests_.end()) {
-    delete iter->second;
+  if (iter != pending_registration_requests_.end())
     pending_registration_requests_.erase(iter);
-  }
 }
 
 void GCMClientImpl::Unregister(
     const linked_ptr<RegistrationInfo>& registration_info) {
   DCHECK_EQ(state_, READY);
 
   scoped_ptr<UnregistrationRequest::CustomRequestHandler> request_handler;
 
   const GCMRegistrationInfo* gcm_registration_info =
       GCMRegistrationInfo::FromRegistrationInfo(registration_info.get());
@@ skipping 63 matching lines @@
       registration_info->GetSerializedKey(),
       base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   UnregistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
       device_checkin_info_.secret,
       registration_info->app_id);
 
-  UnregistrationRequest* unregistration_request = new UnregistrationRequest(
-      gservices_settings_.GetRegistrationURL(),
-      request_info,
-      request_handler.Pass(),
-      GetGCMBackoffPolicy(),
-      base::Bind(&GCMClientImpl::OnUnregisterCompleted,
-                  weak_ptr_factory_.GetWeakPtr(),
-                  registration_info),
-      kMaxUnregistrationRetries,
-      url_request_context_getter_,
-      &recorder_);
-  pending_unregistration_requests_[registration_info] = unregistration_request;
+  scoped_ptr<UnregistrationRequest> unregistration_request(
+      new UnregistrationRequest(
+          gservices_settings_.GetRegistrationURL(), request_info,
+          request_handler.Pass(), GetGCMBackoffPolicy(),
+          base::Bind(&GCMClientImpl::OnUnregisterCompleted,
+                     weak_ptr_factory_.GetWeakPtr(), registration_info),
+          kMaxUnregistrationRetries, url_request_context_getter_, &recorder_));
   unregistration_request->Start();
+  pending_unregistration_requests_.insert(registration_info,
+                                          unregistration_request.Pass());
 }
 
 void GCMClientImpl::OnUnregisterCompleted(
     const linked_ptr<RegistrationInfo>& registration_info,
     UnregistrationRequest::Status status) {
   DVLOG(1) << "Unregister completed for app: " << registration_info->app_id
            << " with " << (status ? "success." : "failure.");
 
   Result result;
   switch (status) {
     case UnregistrationRequest::SUCCESS:
       result = SUCCESS;
       break;
     case UnregistrationRequest::INVALID_PARAMETERS:
       result = INVALID_PARAMETER;
       break;
     default:
       // All other errors are treated as SERVER_ERROR.
       result = SERVER_ERROR;
       break;
   }
   delegate_->OnUnregisterFinished(registration_info, result);
 
-  PendingUnregistrationRequests::iterator iter =
-      pending_unregistration_requests_.find(registration_info);
-  if (iter == pending_unregistration_requests_.end())
-    return;
-
-  delete iter->second;
-  pending_unregistration_requests_.erase(iter);
+  pending_unregistration_requests_.erase(registration_info);
 }
 
 void GCMClientImpl::OnGCMStoreDestroyed(bool success) {
   DLOG_IF(ERROR, !success) << "GCM store failed to be destroyed!";
   UMA_HISTOGRAM_BOOLEAN("GCM.StoreDestroySucceeded", success);
 }
 
 void GCMClientImpl::Send(const std::string& app_id,
                          const std::string& receiver_id,
                          const OutgoingMessage& message) {
@@ skipping 261 matching lines @@
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm