Remove stl_util's STLDeleteContainerPairFirstPointers.

chrome/browser/safe_browsing/protocol_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/protocol_manager.h"
 
 #include <utility>
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/common/env_vars.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/google_api_keys.h"
@@ skipping 156 matching lines @@
     const net::URLRequestStatus& status,
     int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       metric_name, status.is_success() ? response_code : status.error());
 }
 
 bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
-SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
-  // Delete in-progress SafeBrowsing requests.
-  base::STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
-                                            hash_requests_.end());
-  hash_requests_.clear();
-}
+SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {}
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
 void SafeBrowsingProtocolManager::GetFullHash(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback,
     bool is_download,
     bool is_extended_reporting) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // If we are in GetHash backoff, we need to check if we're past the next
   // allowed time. If we are, we can proceed with the request. If not, we are
   // required to return empty results (i.e. treat the page as safe).
   if (gethash_error_count_ && Time::Now() <= next_gethash_time_) {
     RecordGetHashResult(is_download, GET_HASH_BACKOFF_ERROR);
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
   GURL gethash_url = GetHashUrl(is_extended_reporting);
-  net::URLFetcher* fetcher =
-      net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
-                              net::URLFetcher::POST, this)
-          .release();
-  hash_requests_[fetcher] = FullHashDetails(callback, is_download);
+  std::unique_ptr<net::URLFetcher> fetcher_ptr = net::URLFetcher::Create(
+      url_fetcher_id_++, gethash_url, net::URLFetcher::POST, this);
+  net::URLFetcher* fetcher = fetcher_ptr.get();
+  hash_requests_[fetcher] = {std::move(fetcher_ptr),
+                             FullHashDetails(callback, is_download)};
 
   const std::string get_hash = FormatGetHash(prefixes);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
 void SafeBrowsingProtocolManager::GetNextUpdate() {
@@ skipping 10 matching lines @@
 // TODO(paulg): Clarify with the SafeBrowsing team whether a failed parse of a
 //              chunk should retry the download and parse of that chunk (and
 //              what back off / how many times to try), and if that effects the
 //              update back off. For now, a failed parse of the chunk means we
 //              drop it. This isn't so bad because the next UPDATE_REQUEST we
 //              do will report all the chunks we have. If that chunk is still
 //              required, the SafeBrowsing servers will tell us to get it again.
 void SafeBrowsingProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  std::unique_ptr<const net::URLFetcher> fetcher;
 
-  HashRequests::iterator it = hash_requests_.find(source);
+  auto it = hash_requests_.find(source);
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
 
   if (it != hash_requests_.end()) {
     // GetHash response.
-    // Reset the scoped pointer so the fetcher gets destroyed properly.
-    fetcher.reset(it->first);
     RecordHttpResponseOrErrorCode(kGetHashUmaResponseMetricName, status,
                                   response_code);
-    const FullHashDetails& details = it->second;
+    const FullHashDetails& details = it->second.second;
     std::vector<SBFullHashResult> full_hashes;
     base::TimeDelta cache_lifetime;
     if (status.is_success() && (response_code == net::HTTP_OK ||
                                 response_code == net::HTTP_NO_CONTENT)) {
       // For tracking our GetHash false positive (net::HTTP_NO_CONTENT) rate,
       // compared to real (net::HTTP_OK) responses.
       if (response_code == net::HTTP_OK)
         RecordGetHashResult(details.is_download, GET_HASH_STATUS_200);
       else
         RecordGetHashResult(details.is_download, GET_HASH_STATUS_204);
@@ skipping 25 matching lines @@
     // Invoke the callback with full_hashes, even if there was a parse error or
     // an error response code (in which case full_hashes will be empty). The
     // caller can't be blocked indefinitely.
     details.callback.Run(full_hashes, cache_lifetime);
 
     hash_requests_.erase(it);
   } else {
     // Update or chunk response.
     RecordHttpResponseOrErrorCode(kGetChunkUmaResponseMetricName, status,
                                   response_code);
-    fetcher.reset(request_.release());
+    std::unique_ptr<net::URLFetcher> fetcher = std::move(request_);
 
     if (request_type_ == UPDATE_REQUEST ||
         request_type_ == BACKUP_UPDATE_REQUEST) {
       if (!fetcher.get()) {
         // We've timed out waiting for an update response, so we've cancelled
         // the update request and scheduled a new one. Ignore this response.
         return;
       }
 
       // Cancel the update response timeout now that we have the response.
@@ skipping 473 matching lines @@
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     const FullHashDetails& other) = default;
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing