Remove stl_util's STLDeleteContainerPairPointers.

components/spellcheck/browser/spelling_service_client.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 "components/spellcheck/browser/spelling_service_client.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #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 "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_service.h"
 #include "components/spellcheck/browser/pref_names.h"
 #include "components/spellcheck/common/spellcheck_common.h"
 #include "components/spellcheck/common/spellcheck_result.h"
@@ skipping 17 matching lines @@
 // The location of error messages in JSON response from spelling service.
 const char kErrorPath[] = "error";
 
 // Languages currently supported by SPELLCHECK.
 const char* const kValidLanguages[] = {"en", "es", "fi", "da"};
 
 }  // namespace
 
 SpellingServiceClient::SpellingServiceClient() {}
 
-SpellingServiceClient::~SpellingServiceClient() {
-  base::STLDeleteContainerPairPointers(spellcheck_fetchers_.begin(),
-                                       spellcheck_fetchers_.end());
-}
+SpellingServiceClient::~SpellingServiceClient() {}
 
 bool SpellingServiceClient::RequestTextCheck(
     content::BrowserContext* context,
     ServiceType type,
     const base::string16& text,
     const TextCheckCompleteCallback& callback) {
   DCHECK(type == SUGGEST || type == SPELLCHECK);
   if (!context || !IsAvailable(context, type)) {
     callback.Run(false, text, std::vector<SpellCheckResult>());
     return false;
@@ skipping 41 matching lines @@
   GURL url = GURL(kSpellingServiceURL);
   net::URLFetcher* fetcher = CreateURLFetcher(url).release();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::SPELL_CHECKER);
   fetcher->SetRequestContext(
       content::BrowserContext::GetDefaultStoragePartition(context)
           ->GetURLRequestContext());
   fetcher->SetUploadData("application/json", request);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
-  spellcheck_fetchers_[fetcher] = new TextCheckCallbackData(callback, text);
+  spellcheck_fetchers_[fetcher] = base::MakeUnique<TextCheckCallbackData>(
+      base::WrapUnique(fetcher), callback, text);
   fetcher->Start();
   return true;
 }
 
 bool SpellingServiceClient::IsAvailable(content::BrowserContext* context,
                                         ServiceType type) {
   const PrefService* pref = user_prefs::UserPrefs::Get(context);
   DCHECK(pref);
   // If prefs don't allow spellchecking, if the context is off the record, or if
   // multilingual spellchecking is enabled the spelling service should be
@@ skipping 109 matching lines @@
       return false;
     }
     SpellCheckResult result(SpellCheckResult::SPELLING, start, length,
                             replacement);
     results->push_back(result);
   }
   return true;
 }
 
 SpellingServiceClient::TextCheckCallbackData::TextCheckCallbackData(
+    std::unique_ptr<net::URLFetcher> fetcher,
     TextCheckCompleteCallback callback,
     base::string16 text)
-    : callback(callback), text(text) {}
+    : fetcher(std::move(fetcher)), callback(callback), text(text) {}
 
 SpellingServiceClient::TextCheckCallbackData::~TextCheckCallbackData() {}
 
 void SpellingServiceClient::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(spellcheck_fetchers_[source]);
-  std::unique_ptr<const net::URLFetcher> fetcher(source);
-  std::unique_ptr<TextCheckCallbackData> callback_data(
-      spellcheck_fetchers_[fetcher.get()]);
+  DCHECK(base::ContainsKey(spellcheck_fetchers_, source));
+  std::unique_ptr<TextCheckCallbackData> callback_data =
+      std::move(spellcheck_fetchers_[source]);
+  spellcheck_fetchers_.erase(source);
+
   bool success = false;
   std::vector<SpellCheckResult> results;
-  if (fetcher->GetResponseCode() / 100 == 2) {
+  if (source->GetResponseCode() / 100 == 2) {
     std::string data;
-    fetcher->GetResponseAsString(&data);
+    source->GetResponseAsString(&data);
     success = ParseResponse(data, &results);
   }
-  spellcheck_fetchers_.erase(fetcher.get());
 
   // The callback may release the last (transitive) dependency on |this|. It
   // MUST be the last function called.
   callback_data->callback.Run(success, callback_data->text, results);
 }
 
 std::unique_ptr<net::URLFetcher> SpellingServiceClient::CreateURLFetcher(
     const GURL& url) {
   return net::URLFetcher::Create(url, net::URLFetcher::POST, this);
 }