Remove stl_util's deletion function use from chrome/.

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2012 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/safe_browsing_service.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
@@ skipping 296 matching lines @@
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
                        content::NotificationService::AllSources());
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                        content::NotificationService::AllSources());
 
   // Register all the delayed analysis to the incident reporting service.
   RegisterAllDelayedAnalysis();
 }
 
 void SafeBrowsingService::ShutDown() {
-  // Deletes the PrefChangeRegistrars, whose dtors also unregister |this| as an
+  // Delete the PrefChangeRegistrars, whose dtors also unregister |this| as an
   // observer of the preferences.
-  base::STLDeleteValues(&prefs_map_);
+  prefs_map_.clear();
 
   // Remove Profile creation/destruction observers.
   prefs_registrar_.RemoveAll();
 
   Stop(true);
 
   services_delegate_->ShutdownServices();
 
   // Since URLRequestContextGetters are refcounted, can't count on clearing
   // |url_request_context_getter_| to delete it, so need to shut it down first,
@@ skipping 267 matching lines @@
         RemovePrefService(profile->GetPrefs());
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void SafeBrowsingService::AddPrefService(PrefService* pref_service) {
   DCHECK(prefs_map_.find(pref_service) == prefs_map_.end());
-  PrefChangeRegistrar* registrar = new PrefChangeRegistrar();
+  std::unique_ptr<PrefChangeRegistrar> registrar =
+      base::MakeUnique<PrefChangeRegistrar>();
   registrar->Init(pref_service);
   registrar->Add(prefs::kSafeBrowsingEnabled,
                  base::Bind(&SafeBrowsingService::RefreshState,
                             base::Unretained(this)));
   // ClientSideDetectionService will need to be refresh the models
   // renderers have if extended-reporting changes.
   registrar->Add(
       GetExtendedReportingPrefName(),
       base::Bind(&SafeBrowsingService::RefreshState, base::Unretained(this)));
-  prefs_map_[pref_service] = registrar;
+  prefs_map_[pref_service] = std::move(registrar);
   RefreshState();
 
   // Record the current pref state.
   UMA_HISTOGRAM_BOOLEAN("SafeBrowsing.Pref.General",
                         pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
   // Extended Reporting metrics are handled together elsewhere.
   RecordExtendedReportingMetrics(*pref_service);
 }
 
 void SafeBrowsingService::RemovePrefService(PrefService* pref_service) {
   if (prefs_map_.find(pref_service) != prefs_map_.end()) {
-    delete prefs_map_[pref_service];
     prefs_map_.erase(pref_service);
     RefreshState();
   } else {
     NOTREACHED();
   }
 }
 
 std::unique_ptr<SafeBrowsingService::StateSubscription>
 SafeBrowsingService::RegisterStateCallback(
     const base::Callback<void(void)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return state_callback_list_.Add(callback);
 }
 
 void SafeBrowsingService::RefreshState() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Check if any profile requires the service to be active.
   bool enable = false;
-  std::map<PrefService*, PrefChangeRegistrar*>::iterator iter;
-  for (iter = prefs_map_.begin(); iter != prefs_map_.end(); ++iter) {
+  for (auto iter = prefs_map_.begin(); iter != prefs_map_.end(); ++iter) {

[Nico, 2016/10/24 18:41:02]

nit: foreach?

[Avi (use Gerrit), 2016/10/24 19:15:37]

Done.

     if (iter->first->GetBoolean(prefs::kSafeBrowsingEnabled)) {
       enable = true;
       break;
     }
   }
 
   enabled_by_prefs_ = enable;
 
   if (enable)
     Start();
@@ skipping 21 matching lines @@
     ping_manager()->ReportThreatDetails(report);
 }
 
 void SafeBrowsingService::ProcessResourceRequest(
     const ResourceRequestInfo& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   services_delegate_->ProcessResourceRequest(&request);
 }
 
 }  // namespace safe_browsing