Remove some uses of stl_util's STLDeleteContainerPointers.

chrome/browser/safe_browsing/ping_manager.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/ping_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/safe_browsing/permission_reporter.h"
 #include "components/certificate_reporting/error_reporter.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/report_sender.h"
@@ skipping 45 matching lines @@
         cookies_preference));
 
     permission_reporter_.reset(
         new PermissionReporter(request_context_getter->GetURLRequestContext()));
   }
 
   version_ = SafeBrowsingProtocolManagerHelper::Version();
 }
 
 SafeBrowsingPingManager::~SafeBrowsingPingManager() {
-  // Delete in-progress safebrowsing reports (hits and details).
-  base::STLDeleteContainerPointers(safebrowsing_reports_.begin(),
-                                   safebrowsing_reports_.end());
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // All SafeBrowsing request responses are handled here.
 void SafeBrowsingPingManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  Reports::iterator sit = safebrowsing_reports_.find(source);
-  DCHECK(sit != safebrowsing_reports_.end());
-  delete *sit;
-  safebrowsing_reports_.erase(sit);
+  auto it =
+      std::find_if(safebrowsing_reports_.begin(), safebrowsing_reports_.end(),
+                   [source](const std::unique_ptr<net::URLFetcher>& ptr) {
+                     return ptr.get() == source;
+                   });
+  DCHECK(it != safebrowsing_reports_.end());
+  safebrowsing_reports_.erase(it);
 }
 
 // Sends a SafeBrowsing "hit" report.
 void SafeBrowsingPingManager::ReportSafeBrowsingHit(
     const safe_browsing::HitReport& hit_report) {
   GURL report_url = SafeBrowsingHitUrl(hit_report);
-  net::URLFetcher* report =
-      net::URLFetcher::Create(report_url, hit_report.post_data.empty()
-                                              ? net::URLFetcher::GET
-                                              : net::URLFetcher::POST,
-                              this)
-          .release();
-  report->SetLoadFlags(net::LOAD_DISABLE_CACHE);
-  report->SetRequestContext(request_context_getter_.get());
+  std::unique_ptr<net::URLFetcher> report_ptr = net::URLFetcher::Create(
+      report_url, hit_report.post_data.empty() ? net::URLFetcher::GET
+                                               : net::URLFetcher::POST,
+      this);
+  net::URLFetcher* report = report_ptr.get();
+  report_ptr->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  report_ptr->SetRequestContext(request_context_getter_.get());
   if (!hit_report.post_data.empty())
-    report->SetUploadData("text/plain", hit_report.post_data);
-  safebrowsing_reports_.insert(report);
+    report_ptr->SetUploadData("text/plain", hit_report.post_data);
+  safebrowsing_reports_.insert(std::move(report_ptr));

[Nico, 2016/09/15 16:07:16]

nit: If you do 

  (*safebrowsing_reports_.insert(std::move(report_ptr)))->Start();

here, you don't need the raw pointer. Not sure if that's better though.

[Avi (use Gerrit), 2016/09/15 19:53:45]

I suppose so, but I'll pass for simplicity/clarity.

   report->Start();
 }
 
 // Sends threat details for users who opt-in.
 void SafeBrowsingPingManager::ReportThreatDetails(const std::string& report) {
   GURL report_url = ThreatDetailsUrl();
-  net::URLFetcher* fetcher =
-      net::URLFetcher::Create(report_url, net::URLFetcher::POST, this)
-          .release();
+  std::unique_ptr<net::URLFetcher> fetcher =
+      net::URLFetcher::Create(report_url, net::URLFetcher::POST, this);
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("application/octet-stream", report);
   // Don't try too hard to send reports on failures.
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->Start();
-  safebrowsing_reports_.insert(fetcher);
+  safebrowsing_reports_.insert(std::move(fetcher));
 }
 
 void SafeBrowsingPingManager::ReportInvalidCertificateChain(
     const std::string& serialized_report) {
   DCHECK(certificate_error_reporter_);
   certificate_error_reporter_->SendExtendedReportingReport(serialized_report);
 }
 
 void SafeBrowsingPingManager::SetCertificateErrorReporterForTesting(
     std::unique_ptr<certificate_reporting::ErrorReporter>
@@ skipping 96 matching lines @@
           version_.c_str());
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }
 
 }  // namespace safe_browsing