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

net/cookies/cookie_monster_store_test.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 "net/cookies/cookie_monster_store_test.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 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() {
 }
 
 CookieStoreCommand::CookieStoreCommand(
     Type type,
     const CookieMonster::PersistentCookieStore::LoadedCallback& loaded_callback,
     const std::string& key)
     : type(type), loaded_callback(loaded_callback), key(key) {}
 
 CookieStoreCommand::CookieStoreCommand(Type type, const CanonicalCookie& cookie)
     : type(type), cookie(cookie) {}
 
 CookieStoreCommand::CookieStoreCommand(const CookieStoreCommand& other) =
     default;
 
 CookieStoreCommand::~CookieStoreCommand() {}
 
 MockPersistentCookieStore::MockPersistentCookieStore()
     : store_load_commands_(false), load_return_value_(true), loaded_(false) {}
 
 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) {
   if (store_load_commands_) {
     commands_.push_back(
         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(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   if (store_load_commands_) {
     commands_.push_back(CookieStoreCommand(
         CookieStoreCommand::LOAD_COOKIES_FOR_KEY, loaded_callback, key));
     return;
   }
   if (!loaded_) {
     Load(loaded_callback);
   } else {
     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>>())));
   }
 }
 
 void MockPersistentCookieStore::AddCookie(const CanonicalCookie& cookie) {
   commands_.push_back(CookieStoreCommand(CookieStoreCommand::ADD, cookie));
 }
 
 void MockPersistentCookieStore::UpdateCookieAccessTime(
     const CanonicalCookie& cookie) {
 }
@@ skipping 47 matching lines @@
 
   return CanonicalCookie::Create(url, pc.Name(), pc.Value(), url.host(),
                                  cookie_path, creation_time, cookie_expires,
                                  pc.IsSecure(), pc.IsHttpOnly(), pc.SameSite(),
                                  false, pc.Priority());
 }
 
 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()
     : loaded_(false) {
 }
 
 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;
 }
 
 void MockSimplePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   if (!loaded_) {
     Load(loaded_callback);
   } else {
     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>>())));
   }
 }
 
 void MockSimplePersistentCookieStore::AddCookie(const CanonicalCookie& cookie) {
   int64_t creation_time = cookie.CreationDate().ToInternalValue();
   EXPECT_TRUE(cookies_.find(creation_time) == cookies_.end());
   cookies_[creation_time] = cookie;
 }
 
 void MockSimplePersistentCookieStore::UpdateCookieAccessTime(
@@ skipping 59 matching lines @@
     store->AddCookie(*cc);
   }
 
   return base::MakeUnique<CookieMonster>(store.get(), nullptr);
 }
 
 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {
 }
 
 }  // namespace net