Remove stl_util's STLDeleteContainerPairFirstPointers.

chrome/browser/extensions/blacklist_state_fetcher.cc

 // Copyright 2013 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/extensions/blacklist_state_fetcher.h"
 
-#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/safe_browsing/protocol_manager_helper.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/safe_browsing/crx_info.pb.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 BlacklistStateFetcher::BlacklistStateFetcher()
     : url_fetcher_id_(0),
       weak_ptr_factory_(this) {}
 
 BlacklistStateFetcher::~BlacklistStateFetcher() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  base::STLDeleteContainerPairFirstPointers(requests_.begin(), requests_.end());
-  requests_.clear();
 }
 
 void BlacklistStateFetcher::Request(const std::string& id,
                                     const RequestCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!safe_browsing_config_) {
     if (g_browser_process && g_browser_process->safe_browsing_service()) {
       SetSafeBrowsingConfig(
           g_browser_process->safe_browsing_service()->GetProtocolConfig());
     } else {
@@ skipping 19 matching lines @@
 
 void BlacklistStateFetcher::SendRequest(const std::string& id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ClientCRXListInfoRequest request;
   request.set_id(id);
   std::string request_str;
   request.SerializeToString(&request_str);
 
   GURL request_url = RequestUrl();
-  net::URLFetcher* fetcher =
-      net::URLFetcher::Create(url_fetcher_id_++, request_url,
-                              net::URLFetcher::POST, this).release();
-  requests_[fetcher] = id;
+  std::unique_ptr<net::URLFetcher> fetcher_ptr = net::URLFetcher::Create(
+      url_fetcher_id_++, request_url, net::URLFetcher::POST, this);
+  net::URLFetcher* fetcher = fetcher_ptr.get();
+  requests_[fetcher] = {std::move(fetcher_ptr), id};
   fetcher->SetAutomaticallyRetryOn5xx(false);  // Don't retry on error.
   fetcher->SetRequestContext(url_request_context_getter_.get());
   fetcher->SetUploadData("application/octet-stream", request_str);
   fetcher->Start();
 }
 
 void BlacklistStateFetcher::SetSafeBrowsingConfig(
     const safe_browsing::SafeBrowsingProtocolConfig& config) {
   safe_browsing_config_.reset(
       new safe_browsing::SafeBrowsingProtocolConfig(config));
@@ skipping 15 matching lines @@
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }
 
 void BlacklistStateFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  std::map<const net::URLFetcher*, std::string>::iterator it =
-     requests_.find(source);
+  auto it = requests_.find(source);
   if (it == requests_.end()) {
     NOTREACHED();
     return;
   }
 
-  std::unique_ptr<const net::URLFetcher> fetcher;
-
-  fetcher.reset(it->first);
-  std::string id = it->second;
+  std::unique_ptr<net::URLFetcher> fetcher = std::move(it->second.first);
+  std::string id = it->second.second;
   requests_.erase(it);
 
   BlacklistState state;
 
   if (source->GetStatus().is_success() && source->GetResponseCode() == 200) {
     std::string data;
     source->GetResponseAsString(&data);
     ClientCRXListInfoResponse response;
     if (response.ParseFromString(data)) {
       state = static_cast<BlacklistState>(response.verdict());
@@ skipping 17 matching lines @@
   for (CallbackMultiMap::const_iterator callback_it = range.first;
        callback_it != range.second;
        ++callback_it) {
     callback_it->second.Run(state);
   }
 
   callbacks_.erase(range.first, range.second);
 }
 
 }  // namespace extensions