Update usages of std::map to use ScopedPtrMap.

sync/engine/model_type_sync_worker_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 "sync/engine/model_type_sync_worker_impl.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 12 matching lines @@
     const DataTypeState& initial_state,
     const UpdateResponseDataList& saved_pending_updates,
     scoped_ptr<Cryptographer> cryptographer,
     NudgeHandler* nudge_handler,
     scoped_ptr<ModelTypeSyncProxy> type_sync_proxy)
     : type_(type),
       data_type_state_(initial_state),
       type_sync_proxy_(type_sync_proxy.Pass()),
       cryptographer_(cryptographer.Pass()),
       nudge_handler_(nudge_handler),
-      entities_deleter_(&entities_),
       weak_ptr_factory_(this) {
   // Request an initial sync if it hasn't been completed yet.
   if (!data_type_state_.initial_sync_done) {
     nudge_handler_->NudgeForInitialDownload(type_);
   }
 
   for (UpdateResponseDataList::const_iterator it =
            saved_pending_updates.begin();
        it != saved_pending_updates.end();
        ++it) {
-    EntityTracker* entity_tracker = EntityTracker::FromServerUpdate(
+    scoped_ptr<EntityTracker> entity_tracker = EntityTracker::FromServerUpdate(
         it->id, it->client_tag_hash, it->response_version);
     entity_tracker->ReceivePendingUpdate(*it);
-    entities_.insert(std::make_pair(it->client_tag_hash, entity_tracker));
+    entities_.insert(it->client_tag_hash, entity_tracker.Pass());
   }
 
   if (cryptographer_) {
     DVLOG(1) << ModelTypeToString(type_) << ": Starting with encryption key "
              << cryptographer_->GetDefaultNigoriKeyName();
     OnCryptographerUpdated();
   }
 }
 
 ModelTypeSyncWorkerImpl::~ModelTypeSyncWorkerImpl() {
@@ skipping 63 matching lines @@
       data_type_state_.type_root_id = update_entity->id_string();
     } else {
       // Normal updates are handled here.
       const std::string& client_tag_hash =
           update_entity->client_defined_unique_tag();
       DCHECK(!client_tag_hash.empty());
 
       EntityTracker* entity_tracker = NULL;
       EntityMap::const_iterator map_it = entities_.find(client_tag_hash);
       if (map_it == entities_.end()) {
-        entity_tracker =
+        scoped_ptr<EntityTracker> scoped_entity_tracker =
             EntityTracker::FromServerUpdate(update_entity->id_string(),
                                             client_tag_hash,
                                             update_entity->version());
-        entities_.insert(std::make_pair(client_tag_hash, entity_tracker));
+        entity_tracker = scoped_entity_tracker.get();
+        entities_.insert(client_tag_hash, scoped_entity_tracker.Pass());
       } else {
         entity_tracker = map_it->second;
       }
 
       // Prepare the message for the model thread.
       UpdateResponseData response_data;
       response_data.id = update_entity->id_string();
       response_data.client_tag_hash = client_tag_hash;
       response_data.response_version = update_entity->version();
       response_data.ctime = ProtoTimeToTime(update_entity->ctime());
@@ skipping 120 matching lines @@
   return scoped_ptr<CommitContribution>(new NonBlockingTypeCommitContribution(
       data_type_state_.type_context, commit_entities, sequence_numbers, this));
 }
 
 void ModelTypeSyncWorkerImpl::StorePendingCommit(
     const CommitRequestData& request) {
   if (!request.deleted) {
     DCHECK_EQ(type_, GetModelTypeFromSpecifics(request.specifics));
   }
 
-  EntityMap::iterator map_it = entities_.find(request.client_tag_hash);
+  EntityMap::const_iterator map_it = entities_.find(request.client_tag_hash);
   if (map_it == entities_.end()) {
-    EntityTracker* entity =
-        EntityTracker::FromCommitRequest(request.id,
-                                         request.client_tag_hash,
-                                         request.sequence_number,
-                                         request.base_version,
-                                         request.ctime,
-                                         request.mtime,
-                                         request.non_unique_name,
-                                         request.deleted,
-                                         request.specifics);
-    entities_.insert(std::make_pair(request.client_tag_hash, entity));
+    scoped_ptr<EntityTracker> entity = EntityTracker::FromCommitRequest(
+        request.id, request.client_tag_hash, request.sequence_number,
+        request.base_version, request.ctime, request.mtime,
+        request.non_unique_name, request.deleted, request.specifics);
+    entities_.insert(request.client_tag_hash, entity.Pass());
   } else {
     EntityTracker* entity = map_it->second;
     entity->RequestCommit(request.id,
                           request.client_tag_hash,
                           request.sequence_number,
                           request.base_version,
                           request.ctime,
                           request.mtime,
                           request.non_unique_name,
                           request.deleted,
                           request.specifics);
   }
 }
 
 void ModelTypeSyncWorkerImpl::OnCommitResponse(
     const CommitResponseDataList& response_list) {
   for (CommitResponseDataList::const_iterator response_it =
            response_list.begin();
        response_it != response_list.end();
        ++response_it) {
     const std::string client_tag_hash = response_it->client_tag_hash;
-    EntityMap::iterator map_it = entities_.find(client_tag_hash);
+    EntityMap::const_iterator map_it = entities_.find(client_tag_hash);
 
     // There's no way we could have committed an entry we know nothing about.
     if (map_it == entities_.end()) {
       NOTREACHED() << "Received commit response for item unknown to us."
                    << " Model type: " << ModelTypeToString(type_)
                    << " ID: " << response_it->id;
       continue;
     }
 
     EntityTracker* entity = map_it->second;
@@ skipping 128 matching lines @@
     return false;
   }
   if (!out->ParseFromString(plaintext)) {
     LOG(ERROR) << "Failed to parse decrypted entity";
     return false;
   }
   return true;
 }
 
 }  // namespace syncer