Update usages of std::map to use ScopedPtrMap.

chrome/browser/predictors/resource_prefetch_predictor.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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
@@ skipping 315 matching lines @@
 // ResourcePrefetchPredictor.
 
 ResourcePrefetchPredictor::ResourcePrefetchPredictor(
     const ResourcePrefetchPredictorConfig& config,
     Profile* profile)
     : profile_(profile),
       config_(config),
       initialization_state_(NOT_INITIALIZED),
       tables_(PredictorDatabaseFactory::GetForProfile(profile)
                   ->resource_prefetch_tables()),
-      results_map_deleter_(&results_map_),
       history_service_observer_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Some form of learning has to be enabled.
   DCHECK(config_.IsLearningEnabled());
   if (config_.IsURLPrefetchingEnabled(profile_))
     DCHECK(config_.IsURLLearningEnabled());
   if (config_.IsHostPrefetchingEnabled(profile_))
     DCHECK(config_.IsHostLearningEnabled());
 }
@@ skipping 56 matching lines @@
                    << initialization_state_;
   }
 }
 
 void ResourcePrefetchPredictor::FinishedPrefetchForNavigation(
     const NavigationID& navigation_id,
     PrefetchKeyType key_type,
     ResourcePrefetcher::RequestVector* requests) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  Result* result = new Result(key_type, requests);
+  scoped_ptr<Result> result(new Result(key_type, requests));
   // Add the results to the results map.
-  if (!results_map_.insert(std::make_pair(navigation_id, result)).second) {
+  if (!results_map_.insert(navigation_id, result.Pass()).second)
     DLOG(FATAL) << "Returning results for existing navigation.";
-    delete result;
-  }
 }
 
 void ResourcePrefetchPredictor::Shutdown() {
   if (prefetch_manager_.get()) {
     prefetch_manager_->ShutdownOnUIThread();
     prefetch_manager_ = NULL;
   }
   history_service_observer_.RemoveAll();
 }
 
@@ skipping 83 matching lines @@
   RecordNavigationEvent(NAVIGATION_EVENT_ONLOAD_TRACKED_URL);
 
   // Get and use the navigation ID stored in |inflight_navigations_| because it
   // has the timing infomation.
   const NavigationID navigation_id(nav_it->first);
 
   // Report any stats.
   base::TimeDelta plt = base::TimeTicks::Now() - navigation_id.creation_time;
   ReportPageLoadTimeStats(plt);
   if (prefetch_manager_.get()) {
-    ResultsMap::iterator results_it = results_map_.find(navigation_id);
+    ResultsMap::const_iterator results_it = results_map_.find(navigation_id);
     bool have_prefetch_results = results_it != results_map_.end();
     UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.HavePrefetchResults",
                           have_prefetch_results);
     if (have_prefetch_results) {
       ReportAccuracyStats(results_it->second->key_type,
                           *(nav_it->second),
                           results_it->second->requests.get());
       ReportPageLoadTimePrefetchStats(
           plt,
           true,
@@ skipping 192 matching lines @@
   for (NavigationMap::iterator it = inflight_navigations_.begin();
        it != inflight_navigations_.end();) {
     if (it->first.IsSameRenderer(navigation_id) ||
         (time_now - it->first.creation_time > max_navigation_age)) {
       inflight_navigations_.erase(it++);
       RecordNavigationEvent(NAVIGATION_EVENT_REQUEST_EXPIRED);
     } else {
       ++it;
     }
   }
-  for (ResultsMap::iterator it = results_map_.begin();
+  for (ResultsMap::const_iterator it = results_map_.begin();
        it != results_map_.end();) {
     if (it->first.IsSameRenderer(navigation_id) ||
         (time_now - it->first.creation_time > max_navigation_age)) {
-      delete it->second;
       results_map_.erase(it++);
     } else {
       ++it;
     }
   }
 }
 
 void ResourcePrefetchPredictor::DeleteAllUrls() {
   inflight_navigations_.clear();
   url_table_cache_->clear();
@@ skipping 86 matching lines @@
   // Host level data - no cutoff, always learn the navigation if enabled.
   if (config_.IsHostLearningEnabled()) {
     LearnNavigation(navigation_id.main_frame_url.host(),
                     PREFETCH_KEY_TYPE_HOST,
                     requests,
                     config_.max_hosts_to_track,
                     host_table_cache_.get());
   }
 
   // Remove the navigation from the results map.
-  ResultsMap::iterator results_it = results_map_.find(navigation_id);
-  if (results_it != results_map_.end()) {
-    delete results_it->second;
-    results_map_.erase(results_it);
-  }
+  results_map_.erase(navigation_id);
 }
 
 void ResourcePrefetchPredictor::LearnNavigation(
     const std::string& key,
     PrefetchKeyType key_type,
     const std::vector<URLRequestSummary>& new_resources,
     size_t max_data_map_size,
     PrefetchDataMap* data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 225 matching lines @@
   int prefetch_cancelled = 0, prefetch_failed = 0, prefetch_not_started = 0;
   // 'a_' -> actual, 'p_' -> predicted.
   int p_cache_a_cache = 0, p_cache_a_network = 0, p_cache_a_notused = 0,
       p_network_a_cache = 0, p_network_a_network = 0, p_network_a_notused = 0;
 
   for (ResourcePrefetcher::RequestVector::iterator it = prefetched->begin();
        it != prefetched->end(); ++it) {
     ResourcePrefetcher::Request* req = *it;
 
     // Set the usage states if the resource was actually used.
-    std::map<GURL, bool>::iterator actual_it = actual_resources.find(
-        req->resource_url);
+    std::map<GURL, bool>::const_iterator actual_it =
+        actual_resources.find(req->resource_url);
     if (actual_it != actual_resources.end()) {
       if (actual_it->second) {
         req->usage_status =
             ResourcePrefetcher::Request::USAGE_STATUS_FROM_CACHE;
       } else {
         req->usage_status =
             ResourcePrefetcher::Request::USAGE_STATUS_FROM_NETWORK;
       }
     }
 
@@ skipping 221 matching lines @@
     // HistoryService is already loaded. Continue with Initialization.
     OnHistoryAndCacheLoaded();
     return;
   }
   DCHECK(!history_service_observer_.IsObserving(history_service));
   history_service_observer_.Add(history_service);
   return;
 }
 
 }  // namespace predictors