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 14 matching lines @@
 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.

[davidben, 2016/10/10 23:05:00]

Existing problem, but this comment seems a little dubious. Took me forever to
figure out what it was trying to do, but it seems LoadedCallbbackTask can be
taken out completely and the call sites replaced with:

base::ThreadedTaskRunnerHandle::Get()->PostTask(
    FROM_HERE,
    base::Bind(loaded_callback, base::Passed(&out_cookies)));

(No need to do this in this CL, unless you feel like it. Especially if it's not
quite as trivial as it seems. I can see about doing that as a follow-up.)

[Avi (use Gerrit), 2016/10/11 00:57:48]

Let's give that a try.

 class LoadedCallbackTask
     : public base::RefCountedThreadSafe<LoadedCallbackTask> {
  public:
   typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback;
 
   LoadedCallbackTask(LoadedCallback loaded_callback,
-                     std::vector<CanonicalCookie*> cookies);
+                     std::vector<std::unique_ptr<CanonicalCookie>> cookies);
 
-  void Run() { loaded_callback_.Run(cookies_); }
+  void Run() { loaded_callback_.Run(std::move(cookies_)); }
 
  private:
   friend class base::RefCountedThreadSafe<LoadedCallbackTask>;
   ~LoadedCallbackTask();
 
   LoadedCallback loaded_callback_;
-  std::vector<CanonicalCookie*> cookies_;
+  std::vector<std::unique_ptr<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
@@ skipping 38 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_