Remove STLDeleteContainerPairFirstPointers from AutofillDownloadManager

components/autofill/core/browser/autofill_download_manager.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 "components/autofill/core/browser/autofill_download_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/autofill/core/browser/autofill_driver.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/proto/server.pb.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/variations/net/variations_http_headers.h"
 #include "net/base/load_flags.h"
@@ skipping 122 matching lines @@
                                                  Observer* observer)
     : driver_(driver),
       observer_(observer),
       max_form_cache_size_(kMaxFormCacheSize),
       fetcher_backoff_(&kAutofillBackoffPolicy),
       fetcher_id_for_unittest_(0),
       weak_factory_(this) {
   DCHECK(observer_);
 }
 
-AutofillDownloadManager::~AutofillDownloadManager() {
-  base::STLDeleteContainerPairFirstPointers(url_fetchers_.begin(),
-                                            url_fetchers_.end());
-}
+AutofillDownloadManager::~AutofillDownloadManager() = default;
 
 bool AutofillDownloadManager::StartQueryRequest(
     const std::vector<FormStructure*>& forms) {
   // Do not send the request if it contains more fields than the server can
   // accept.
   if (CountActiveFieldsInForms(forms) > kMaxFieldsPerQueryRequest)
     return false;
 
   AutofillQueryContents query;
   FormRequestData request_data;
@@ skipping 59 matching lines @@
 
 bool AutofillDownloadManager::StartRequest(
     const FormRequestData& request_data) {
   net::URLRequestContextGetter* request_context =
       driver_->GetURLRequestContext();
   DCHECK(request_context);
   GURL request_url = GetRequestUrl(request_data.request_type);
 
   // Id is ignored for regular chrome, in unit test id's for fake fetcher
   // factory will be 0, 1, 2, ...
-  net::URLFetcher* fetcher =
-      net::URLFetcher::Create(fetcher_id_for_unittest_++, request_url,
-                              net::URLFetcher::POST, this).release();
+  std::unique_ptr<net::URLFetcher> owned_fetcher = net::URLFetcher::Create(
+      fetcher_id_for_unittest_++, request_url, net::URLFetcher::POST, this);
+  net::URLFetcher* fetcher = owned_fetcher.get();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::AUTOFILL);
-  url_fetchers_[fetcher] = request_data;
+  url_fetchers_[fetcher] =
+      std::make_pair(std::move(owned_fetcher), request_data);
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->SetRequestContext(request_context);
   fetcher->SetUploadData("text/proto", request_data.payload);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   variations::AppendVariationHeaders(
       fetcher->GetOriginalURL(), driver_->IsOffTheRecord(), false, &headers);
   fetcher->SetExtraRequestHeaders(headers.ToString());
@@ skipping 49 matching lines @@
   for (size_t i = 0; i < forms_in_query.size(); ++i) {
     if (i)
       signature.append(",");
     signature.append(forms_in_query[i]);
   }
   return signature;
 }
 
 void AutofillDownloadManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  std::map<net::URLFetcher *, FormRequestData>::iterator it =
-      url_fetchers_.find(const_cast<net::URLFetcher*>(source));
+  auto it = url_fetchers_.find(const_cast<net::URLFetcher*>(source));
   if (it == url_fetchers_.end()) {
     // Looks like crash on Mac is possibly caused with callback entering here
     // with unknown fetcher when network is refreshed.
     return;
   }
-  std::string request_type(RequestTypeToString(it->second.request_type));
+  std::string request_type(RequestTypeToString(it->second.second.request_type));
 
-  CHECK(it->second.form_signatures.size());
+  CHECK(it->second.second.form_signatures.size());
   bool success = source->GetResponseCode() == net::HTTP_OK;
   fetcher_backoff_.InformOfRequest(success);
 
   if (!success) {
     // Reschedule with the appropriate delay, ignoring return value because
     // payload is already well formed.
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&AutofillDownloadManager::StartRequest),
-                   weak_factory_.GetWeakPtr(), it->second),
+                   weak_factory_.GetWeakPtr(), it->second.second),
         fetcher_backoff_.GetTimeUntilRelease());
 
     VLOG(1) << "AutofillDownloadManager: " << request_type
              << " request has failed with response "
              << source->GetResponseCode();
-    observer_->OnServerRequestError(it->second.form_signatures[0],
-                                    it->second.request_type,
+    observer_->OnServerRequestError(it->second.second.form_signatures[0],
+                                    it->second.second.request_type,
                                     source->GetResponseCode());
   } else {
     std::string response_body;
     source->GetResponseAsString(&response_body);
-    if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
-      CacheQueryRequest(it->second.form_signatures, response_body);
+    if (it->second.second.request_type ==
+        AutofillDownloadManager::REQUEST_QUERY) {
+      CacheQueryRequest(it->second.second.form_signatures, response_body);
       observer_->OnLoadedServerPredictions(std::move(response_body),
-                                           it->second.form_signatures);
+                                           it->second.second.form_signatures);
     } else {
       VLOG(1) << "AutofillDownloadManager: upload request has succeeded.";
       observer_->OnUploadedPossibleFieldTypes();
     }
   }
-  delete it->first;
   url_fetchers_.erase(it);
 }
 
 }  // namespace autofill