Update usages of std::map to use ScopedPtrMap.

sync/sessions/nudge_tracker.cc

 // Copyright (c) 2013 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/sessions/nudge_tracker.h"
 
 #include "base/basictypes.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/protocol/sync.pb.h"
 
@@ skipping 30 matching lines @@
    default:
      return minimum_delay;
   }
 }
 
 }  // namespace
 
 size_t NudgeTracker::kDefaultMaxPayloadsPerType = 10;
 
 NudgeTracker::NudgeTracker()
-    : type_tracker_deleter_(&type_trackers_),
-      invalidations_enabled_(false),
+    : invalidations_enabled_(false),
       invalidations_out_of_sync_(true),
       minimum_local_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kDefaultNudgeDelayMilliseconds)),
       local_refresh_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kSyncRefreshDelayMilliseconds)),
       remote_invalidation_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kSyncSchedulerDelayMilliseconds)) {
   ModelTypeSet protocol_types = ProtocolTypes();
   // Default initialize all the type trackers.
   for (ModelTypeSet::Iterator it = protocol_types.First(); it.Good();
        it.Inc()) {
-    type_trackers_.insert(std::make_pair(it.Get(), new DataTypeTracker()));
+    type_trackers_.insert(it.Get(), make_scoped_ptr(new DataTypeTracker()));
   }
 }
 
 NudgeTracker::~NudgeTracker() { }
 
 bool NudgeTracker::IsSyncRequired() const {
   if (IsRetryRequired())
     return true;
 
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
@@ skipping 33 matching lines @@
 }
 
 void NudgeTracker::RecordSuccessfulSyncCycle() {
   // If a retry was required, we've just serviced it.  Unset the flag.
   if (IsRetryRequired())
     current_retry_time_ = base::TimeTicks();
 
   // A successful cycle while invalidations are enabled puts us back into sync.
   invalidations_out_of_sync_ = !invalidations_enabled_;
 
-  for (TypeTrackerMap::iterator it = type_trackers_.begin();
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->RecordSuccessfulSyncCycle();
   }
 }
 
 base::TimeDelta NudgeTracker::RecordLocalChange(ModelTypeSet types) {
   // Start with the longest delay.
   base::TimeDelta delay =
       base::TimeDelta::FromMilliseconds(kDefaultShortPollIntervalSeconds);
   for (ModelTypeSet::Iterator type_it = types.First(); type_it.Good();
        type_it.Inc()) {
-    TypeTrackerMap::iterator tracker_it = type_trackers_.find(type_it.Get());
+    TypeTrackerMap::const_iterator tracker_it =
+        type_trackers_.find(type_it.Get());
     DCHECK(tracker_it != type_trackers_.end());
 
     // Only if the type tracker has a valid delay (non-zero) that is shorter
     // than the calculated delay do we update the calculated delay.
     base::TimeDelta type_delay = tracker_it->second->RecordLocalChange();
     if (type_delay == base::TimeDelta()) {
       type_delay = GetDefaultDelayForType(type_it.Get(),
                                           minimum_local_nudge_delay_);
     }
     if (type_delay < delay)
       delay = type_delay;
   }
   return delay;
 }
 
 base::TimeDelta NudgeTracker::RecordLocalRefreshRequest(ModelTypeSet types) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
-    TypeTrackerMap::iterator tracker_it = type_trackers_.find(it.Get());
+    TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(it.Get());
     DCHECK(tracker_it != type_trackers_.end());
     tracker_it->second->RecordLocalRefreshRequest();
   }
   return local_refresh_nudge_delay_;
 }
 
 base::TimeDelta NudgeTracker::RecordRemoteInvalidation(
     syncer::ModelType type,
     scoped_ptr<InvalidationInterface> invalidation) {
   // Forward the invalidations to the proper recipient.
-  TypeTrackerMap::iterator tracker_it = type_trackers_.find(type);
+  TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(type);
   DCHECK(tracker_it != type_trackers_.end());
   tracker_it->second->RecordRemoteInvalidation(invalidation.Pass());
   return remote_invalidation_nudge_delay_;
 }
 
 void NudgeTracker::RecordInitialSyncRequired(syncer::ModelType type) {
-  TypeTrackerMap::iterator tracker_it = type_trackers_.find(type);
+  TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(type);
   DCHECK(tracker_it != type_trackers_.end());
   tracker_it->second->RecordInitialSyncRequired();
 }
 
 void NudgeTracker::RecordCommitConflict(syncer::ModelType type) {
-  TypeTrackerMap::iterator tracker_it = type_trackers_.find(type);
+  TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(type);
   DCHECK(tracker_it != type_trackers_.end());
   tracker_it->second->RecordCommitConflict();
 }
 
 void NudgeTracker::OnInvalidationsEnabled() {
   invalidations_enabled_ = true;
 }
 
 void NudgeTracker::OnInvalidationsDisabled() {
   invalidations_enabled_ = false;
   invalidations_out_of_sync_ = true;
 }
 
 void NudgeTracker::SetTypesThrottledUntil(
     ModelTypeSet types,
     base::TimeDelta length,
     base::TimeTicks now) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
-    TypeTrackerMap::iterator tracker_it = type_trackers_.find(it.Get());
+    TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(it.Get());
     tracker_it->second->ThrottleType(length, now);
   }
 }
 
 void NudgeTracker::UpdateTypeThrottlingState(base::TimeTicks now) {
-  for (TypeTrackerMap::iterator it = type_trackers_.begin();
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->UpdateThrottleState(now);
   }
 }
 
 bool NudgeTracker::IsAnyTypeThrottled() const {
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second->IsThrottled()) {
       return true;
@@ skipping 154 matching lines @@
   // it is ready to go, then we set it as the current_retry_time_.  It will stay
   // there until a GU retry has succeeded.
   if (!next_retry_time_.is_null() &&
       next_retry_time_ <= sync_cycle_start_time_) {
     current_retry_time_ = next_retry_time_;
     next_retry_time_ = base::TimeTicks();
   }
 }
 
 void NudgeTracker::SetHintBufferSize(size_t size) {
-  for (TypeTrackerMap::iterator it = type_trackers_.begin();
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->UpdatePayloadBufferSize(size);
   }
 }
 
 void NudgeTracker::SetNextRetryTime(base::TimeTicks retry_time) {
   next_retry_time_ = retry_time;
 }
 
 void NudgeTracker::OnReceivedCustomNudgeDelays(
     const std::map<ModelType, base::TimeDelta>& delay_map) {
   for (std::map<ModelType, base::TimeDelta>::const_iterator iter =
            delay_map.begin();
        iter != delay_map.end();
        ++iter) {
     ModelType type = iter->first;
     DCHECK(syncer::ProtocolTypes().Has(type));
-    TypeTrackerMap::iterator type_iter = type_trackers_.find(type);
+    TypeTrackerMap::const_iterator type_iter = type_trackers_.find(type);
     if (type_iter == type_trackers_.end())
       continue;
 
     if (iter->second > minimum_local_nudge_delay_) {
       type_iter->second->UpdateLocalNudgeDelay(iter->second);
     } else {
       type_iter->second->UpdateLocalNudgeDelay(
           GetDefaultDelayForType(type,
                                  minimum_local_nudge_delay_));
     }
   }
 }
 
 void NudgeTracker::SetDefaultNudgeDelay(base::TimeDelta nudge_delay) {
   minimum_local_nudge_delay_ = nudge_delay;
 }
 
 }  // namespace sessions
 }  // namespace syncer