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

net/cookies/cookie_monster_store_test.h

 // 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.
 
 // This file contains test infrastructure for multiple files
 // (current cookie_monster_unittest.cc and cookie_monster_perftest.cc)
 // that need to test out CookieMonster interactions with the backing store.
 // It should only be included by test code.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
@@ skipping 12 matching lines @@
 #include "net/cookies/cookie_monster.h"
 
 class GURL;
 
 namespace base {
 class Time;
 }
 
 namespace net {
 
-// Wrapper class for posting a loaded callback. Since the Callback class is not
-// reference counted, we cannot post a callback to the message loop directly,
-// instead we post a LoadedCallbackTask.
-class LoadedCallbackTask
-    : public base::RefCountedThreadSafe<LoadedCallbackTask> {
- public:
-  typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback;
-
-  LoadedCallbackTask(LoadedCallback loaded_callback,
-                     std::vector<CanonicalCookie*> cookies);
-
-  void Run() { loaded_callback_.Run(cookies_); }
-
- private:
-  friend class base::RefCountedThreadSafe<LoadedCallbackTask>;
-  ~LoadedCallbackTask();
-
-  LoadedCallback loaded_callback_;
-  std::vector<CanonicalCookie*> cookies_;
-
-  DISALLOW_COPY_AND_ASSIGN(LoadedCallbackTask);
-};  // Wrapper class LoadedCallbackTask
-
 // Describes a call to one of the 5 functions of PersistentCookieStore.
 struct CookieStoreCommand {
   enum Type {
     LOAD,
     LOAD_COOKIES_FOR_KEY,
     // UPDATE_ACCESS_TIME is not included in this list, because get cookie
     // commands may or may not end updating the access time, unless they have
     // the option set not to do so.
     ADD,
     REMOVE,
@@ skipping 34 matching lines @@
 
   MockPersistentCookieStore();
 
   // When set, Load() and LoadCookiesForKey() calls are store in the command
   // list, rather than being automatically executed. Defaults to false.
   void set_store_load_commands(bool store_load_commands) {
     store_load_commands_ = store_load_commands;
   }
 
   void SetLoadExpectation(bool return_value,
-                          const std::vector<CanonicalCookie*>& result);
+                          std::vector<std::unique_ptr<CanonicalCookie>> result);
 
   const CommandList& commands() const { return commands_; }
 
   void Load(const LoadedCallback& loaded_callback) override;
 
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& loaded_callback) override;
 
   void AddCookie(const CanonicalCookie& cookie) override;
 
   void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
 
   void DeleteCookie(const CanonicalCookie& cookie) override;
 
   void Flush(const base::Closure& callback) override;
 
   void SetForceKeepSessionState() override;
 
  protected:
   ~MockPersistentCookieStore() override;
 
  private:
   CommandList commands_;
 
   bool store_load_commands_;
 
   // Deferred result to use when Load() is called.
   bool load_return_value_;
-  std::vector<CanonicalCookie*> load_result_;
+  std::vector<std::unique_ptr<CanonicalCookie>> load_result_;
   // Indicates if the store has been fully loaded to avoid returning duplicate
   // cookies.
   bool loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPersistentCookieStore);
 };
 
 // Mock for CookieMonsterDelegate
 class MockCookieMonsterDelegate : public CookieMonsterDelegate {
  public:
@@ skipping 20 matching lines @@
 // Helper to build a single CanonicalCookie.
 std::unique_ptr<CanonicalCookie> BuildCanonicalCookie(
     const GURL& url,
     const std::string& cookie_line,
     const base::Time& creation_time);
 
 // Helper to build a list of CanonicalCookie*s.
 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);
 
 // Just act like a backing database.  Keep cookie information from
 // Add/Update/Delete and regurgitate it when Load is called.
 class MockSimplePersistentCookieStore
     : public CookieMonster::PersistentCookieStore {
  public:
   MockSimplePersistentCookieStore();
 
   void Load(const LoadedCallback& loaded_callback) override;
 
@@ skipping 35 matching lines @@
 std::unique_ptr<CookieMonster> CreateMonsterFromStoreForGC(
     int num_secure_cookies,
     int num_old_secure_cookies,
     int num_non_secure_cookies,
     int num_old_non_secure_cookies,
     int days_old);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_