Remove stl_util's deletion functions from net/cookies/ and net/extras/.

net/cookies/cookie_monster_store_test.cc

Index: net/cookies/cookie_monster_store_test.cc
diff --git a/net/cookies/cookie_monster_store_test.cc b/net/cookies/cookie_monster_store_test.cc
index 7a8af87c47e136d047500b633893d2b26afe7b97..a6ac41d14ce5cf934e916f0222d1628f50b7522a 100644
--- a/net/cookies/cookie_monster_store_test.cc
+++ b/net/cookies/cookie_monster_store_test.cc
@@ -19,10 +19,10 @@
 
 namespace net {
 
-LoadedCallbackTask::LoadedCallbackTask(LoadedCallback loaded_callback,
-                                       std::vector<CanonicalCookie*> cookies)
-    : loaded_callback_(loaded_callback), cookies_(cookies) {
-}
+LoadedCallbackTask::LoadedCallbackTask(
+    LoadedCallback loaded_callback,
+    std::vector<std::unique_ptr<CanonicalCookie>> cookies)
+    : loaded_callback_(loaded_callback), cookies_(std::move(cookies)) {}
 
 LoadedCallbackTask::~LoadedCallbackTask() {
 }
@@ -46,9 +46,9 @@ MockPersistentCookieStore::MockPersistentCookieStore()
 
 void MockPersistentCookieStore::SetLoadExpectation(
     bool return_value,
-    const std::vector<CanonicalCookie*>& result) {
+    std::vector<std::unique_ptr<CanonicalCookie>> result) {
   load_return_value_ = return_value;
-  load_result_ = result;
+  load_result_.swap(result);
 }
 
 void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
@@ -57,15 +57,15 @@ void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
         CookieStoreCommand(CookieStoreCommand::LOAD, loaded_callback, ""));
     return;
   }
-  std::vector<CanonicalCookie*> out_cookies;
+  std::vector<std::unique_ptr<CanonicalCookie>> out_cookies;
   if (load_return_value_) {
-    out_cookies = load_result_;
+    out_cookies.swap(load_result_);
     loaded_ = true;
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&LoadedCallbackTask::Run,
-                 new LoadedCallbackTask(loaded_callback, out_cookies)));
+      FROM_HERE, base::Bind(&LoadedCallbackTask::Run,
+                            new LoadedCallbackTask(loaded_callback,
+                                                   std::move(out_cookies))));
 }
 
 void MockPersistentCookieStore::LoadCookiesForKey(
@@ -82,8 +82,9 @@ void MockPersistentCookieStore::LoadCookiesForKey(
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&LoadedCallbackTask::Run,
-                   new LoadedCallbackTask(loaded_callback,
-                                          std::vector<CanonicalCookie*>())));
+                   new LoadedCallbackTask(
+                       loaded_callback,
+                       std::vector<std::unique_ptr<CanonicalCookie>>())));
   }
 }
 
@@ -151,11 +152,11 @@ std::unique_ptr<CanonicalCookie> BuildCanonicalCookie(
 void AddCookieToList(const GURL& url,
                      const std::string& cookie_line,
                      const base::Time& creation_time,
-                     std::vector<CanonicalCookie*>* out_list) {
+                     std::vector<std::unique_ptr<CanonicalCookie>>* out_list) {
   std::unique_ptr<CanonicalCookie> cookie(
       BuildCanonicalCookie(url, cookie_line, creation_time));
 
-  out_list->push_back(cookie.release());
+  out_list->push_back(std::move(cookie));
 }
 
 MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
@@ -164,16 +165,15 @@ MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
 
 void MockSimplePersistentCookieStore::Load(
     const LoadedCallback& loaded_callback) {
-  std::vector<CanonicalCookie*> out_cookies;
+  std::vector<std::unique_ptr<CanonicalCookie>> out_cookies;
 
-  for (CanonicalCookieMap::const_iterator it = cookies_.begin();
-       it != cookies_.end(); it++)
-    out_cookies.push_back(new CanonicalCookie(it->second));
+  for (auto it = cookies_.begin(); it != cookies_.end(); it++)
+    out_cookies.push_back(base::MakeUnique<CanonicalCookie>(it->second));
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&LoadedCallbackTask::Run,
-                 new LoadedCallbackTask(loaded_callback, out_cookies)));
+      FROM_HERE, base::Bind(&LoadedCallbackTask::Run,
+                            new LoadedCallbackTask(loaded_callback,
+                                                   std::move(out_cookies))));
   loaded_ = true;
 }
 
@@ -186,8 +186,9 @@ void MockSimplePersistentCookieStore::LoadCookiesForKey(
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&LoadedCallbackTask::Run,
-                   new LoadedCallbackTask(loaded_callback,
-                                          std::vector<CanonicalCookie*>())));
+                   new LoadedCallbackTask(
+                       loaded_callback,
+                       std::vector<std::unique_ptr<CanonicalCookie>>())));
   }
 }