Remove stl_util's deletion function use from chrome/.

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.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/safe_browsing/incident_reporting/incident_reporting_service.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_info.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/incident_reporting/environment_data_collection.h"
 #include "chrome/browser/safe_browsing/incident_reporting/extension_data_collection.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
@@ skipping 352 matching lines @@
 IncidentReportingService::~IncidentReportingService() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   CancelIncidentCollection();
 
   // Cancel all internal asynchronous tasks.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   CancelEnvironmentCollection();
   CancelDownloadCollection();
   CancelAllReportUploads();
-
-  base::STLDeleteValues(&profiles_);
 }
 
 std::unique_ptr<IncidentReceiver>
 IncidentReportingService::GetIncidentReceiver() {
   return base::MakeUnique<Receiver>(receiver_weak_ptr_factory_.GetWeakPtr());
 }
 
 std::unique_ptr<TrackedPreferenceValidationDelegate>
 IncidentReportingService::CreatePreferenceValidationDelegate(Profile* profile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 172 matching lines @@
   return IncidentReportUploaderImpl::UploadReport(
       callback, request_context_getter, report);
 }
 
 bool IncidentReportingService::IsProcessingReport() const {
   return report_ != nullptr;
 }
 
 IncidentReportingService::ProfileContext*
 IncidentReportingService::GetOrCreateProfileContext(Profile* profile) {
-  ProfileContextCollection::iterator it =
-      profiles_.insert(ProfileContextCollection::value_type(profile, nullptr))
-          .first;
-  if (!it->second)
-    it->second = new ProfileContext();
-  return it->second;
+  std::unique_ptr<ProfileContext>& context = profiles_[profile];
+  if (!context)
+    context = base::MakeUnique<ProfileContext>();
+  return context.get();
 }
 
 IncidentReportingService::ProfileContext*
 IncidentReportingService::GetProfileContext(Profile* profile) {
-  ProfileContextCollection::iterator it = profiles_.find(profile);
-  return it != profiles_.end() ? it->second : nullptr;
+  auto it = profiles_.find(profile);
+  return it != profiles_.end() ? it->second.get() : nullptr;
 }
 
 void IncidentReportingService::OnProfileDestroyed(Profile* profile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  ProfileContextCollection::iterator it = profiles_.find(profile);
+  auto it = profiles_.find(profile);
   if (it == profiles_.end())
     return;
 
   // Take ownership of the context.
-  std::unique_ptr<ProfileContext> context(it->second);
+  std::unique_ptr<ProfileContext> context = std::move(it->second);
   it->second = nullptr;
 
   // TODO(grt): Persist incidents for upload on future profile load.
 
   // Remove the association with this profile context from all pending uploads.
   for (const auto& upload : uploads_)
     upload->profiles_to_state.erase(context.get());
 
   // Forget about this profile. Incidents not yet sent for upload are lost.
   // No new incidents will be accepted for it.
   profiles_.erase(it);
 }
 
 Profile* IncidentReportingService::FindEligibleProfile() const {
   Profile* candidate = nullptr;
-  for (ProfileContextCollection::const_iterator scan = profiles_.begin();
-       scan != profiles_.end();
-       ++scan) {
+  for (const auto& scan : profiles_) {
     // Skip over profiles that have yet to be added to the profile manager.
     // This will also skip over the NULL-profile context used to hold
     // process-wide incidents.
-    if (!scan->second->added)
+    if (!scan.second->added)
       continue;
     // Also skip over profiles for which IncidentReporting is not enabled.
-    if (!IsEnabledForProfile(scan->first))
+    if (!IsEnabledForProfile(scan.first))
       continue;
     // If the current profile has Extended Reporting enabled, stop looking and
     // use that one.
-    if (IsExtendedReportingEnabled(*scan->first->GetPrefs())) {
-      return scan->first;
+    if (IsExtendedReportingEnabled(*scan.first->GetPrefs())) {
+      return scan.first;
     }
     // Otherwise, store this one as a candidate and keep looking (in case we
     // find one with Extended Reporting enabled).
-    candidate = scan->first;
+    candidate = scan.first;
   }
 
   return candidate;
 }
 
 void IncidentReportingService::AddIncident(Profile* profile,
                                            std::unique_ptr<Incident> incident) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Ignore incidents from off-the-record profiles.
@@ skipping 75 matching lines @@
 
 void IncidentReportingService::OnCollationTimeout() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Exit early if collection was cancelled.
   if (!collation_timeout_pending_)
     return;
 
   // Wait another round if profile-bound incidents have come in from a profile
   // that has yet to complete creation.
-  for (ProfileContextCollection::iterator scan = profiles_.begin();
-       scan != profiles_.end(); ++scan) {
-    if (scan->first && !scan->second->added && scan->second->HasIncidents()) {
+  for (const auto& scan : profiles_) {
+    if (scan.first && !scan.second->added && scan.second->HasIncidents()) {
       collation_timer_.Reset();
       return;
     }
   }
 
   collation_timeout_pending_ = false;
 
   ProcessIncidentsIfCollectionComplete();
 }
 
@@ skipping 84 matching lines @@
   if (report_->has_download())
     return false;
   // The next easy case: waiting if the finder is operating.
   if (last_download_finder_)
     return true;
   // Harder case 1: not waiting if there are no incidents to upload (only
   // incidents to clear).
   if (!HasIncidentsToUpload())
     return false;
   // Harder case 2: waiting if a non-NULL profile has not yet been added.
-  for (ProfileContextCollection::const_iterator scan = profiles_.begin();
-       scan != profiles_.end();
-       ++scan) {
-    if (scan->first && !scan->second->added)
+  for (const auto& scan : profiles_) {
+    if (scan.first && !scan.second->added)
       return true;
   }
   // There is no most recent download and there's nothing more to wait for.
   return false;
 }
 
 void IncidentReportingService::CancelDownloadCollection() {
   last_download_finder_.reset();
   last_download_begin_ = base::TimeTicks();
   if (report_)
@@ skipping 76 matching lines @@
   }
 
   // Clear incidents data where needed.
   for (auto& profile_and_context : profiles_) {
     // Bypass process-wide incidents that have not yet been associated with a
     // profile and profiles with no incidents to clear.
     if (!profile_and_context.first ||
         profile_and_context.second->incidents_to_clear.empty()) {
       continue;
     }
-    ProfileContext* context = profile_and_context.second;
+    ProfileContext* context = profile_and_context.second.get();
     StateStore::Transaction transaction(context->state_store.get());
     for (const auto& incident : context->incidents_to_clear)
       transaction.Clear(incident->GetType(), incident->GetKey());
     context->incidents_to_clear.clear();
   }
   // Abandon report if there are no incidents to upload.
   if (!HasIncidentsToUpload())
     return;
 
   bool has_download =
       report->has_download() || report->has_non_binary_download();
 
   // Collect incidents across all profiles participating in safe browsing. Drop
   // incidents if the profile stopped participating before collection completed.
   // Prune previously submitted incidents.
   // Associate the profile contexts and their incident data with the upload.
   UploadContext::PersistentIncidentStateCollection profiles_to_state;
   for (auto& profile_and_context : profiles_) {
     // Bypass process-wide incidents that have not yet been associated with a
     // profile.
     if (!profile_and_context.first)
       continue;
-    ProfileContext* context = profile_and_context.second;
+    ProfileContext* context = profile_and_context.second.get();
     if (context->incidents.empty())
       continue;
     StateStore::Transaction transaction(context->state_store.get());
     std::vector<PersistentIncidentState> states;
     // Prep persistent data and prune any incidents already sent.
     for (const auto& incident : context->incidents) {
       const PersistentIncidentState state = ComputeIncidentState(*incident);
       if (context->state_store->HasBeenReported(state.type, state.key,
                                                 state.digest)) {
         LogIncidentDataType(PRUNED, *incident);
@@ skipping 154 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing