Finalize a CL originally by departed intern ycxiao@ that detaches the loading of cookies from the...

net/base/cookie_monster_unittest.cc

Index: net/base/cookie_monster_unittest.cc
===================================================================
--- net/base/cookie_monster_unittest.cc	(revision 99705)
+++ net/base/cookie_monster_unittest.cc	(working copy)
@@ -20,7 +20,8 @@
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/cookie_monster.h"
-#include "net/base/cookie_monster_store_test.h"  // For CookieStore Mock
+#include "net/base/cookie_monster_store_test.h"  // For CookieStore mock
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -31,6 +32,20 @@
 
 namespace {
 
+// TODO(erikwright): Replace the pre-existing MockPersistentCookieStore (and
+// brethren) with this one, and remove the 'New' prefix.
+class NewMockPersistentCookieStore
+    : public CookieMonster::PersistentCookieStore {
+ public:
+  MOCK_METHOD1(Load, bool(const LoadedCallback& loaded_callback));
+  MOCK_METHOD1(AddCookie, void(const CookieMonster::CanonicalCookie& cc));
+  MOCK_METHOD1(UpdateCookieAccessTime,
+               void(const CookieMonster::CanonicalCookie& cc));
+  MOCK_METHOD1(DeleteCookie, void(const CookieMonster::CanonicalCookie& cc));
+  MOCK_METHOD1(SetClearLocalStateOnExit, void(bool clear_local_state));
+  MOCK_METHOD1(Flush, void(Task* completion_task));
+};
+
 const int kTimeout = 1000;
 
 const char* kTopLevelDomainPlus1 = "http://www.harvard.edu";
@@ -145,10 +160,10 @@
       : CookieCallback(run_in_thread) {}
 
   void Run(
-      std::string* cookie_line,
-      std::vector<CookieStore::CookieInfo>* cookie_info) {
-    cookie_line_ = *cookie_line;
-    cookie_info_ = *cookie_info;
+      const std::string& cookie_line,
+      const std::vector<CookieStore::CookieInfo>& cookie_info) {
+    cookie_line_ = cookie_line;
+    cookie_info_ = cookie_info;
     CallbackEpilogue();
   }
 
@@ -417,7 +432,7 @@
   EXPECT_FALSE(pc2.IsSecure());
 }
 
-// TODO some better test cases for invalid cookies.
+// TODO(erikwright): some better test cases for invalid cookies.
 TEST(ParsedCookieTest, InvalidWhitespace) {
   CookieMonster::ParsedCookie pc("    ");
   EXPECT_FALSE(pc.IsValid());
@@ -499,9 +514,9 @@
   std::string GetCookies(CookieMonster* cm, const GURL& url) {
     DCHECK(cm);
     GetCookieStringCallback callback;
-    cm->GetCookiesAsync(
-        url, base::Bind(&GetCookieStringCallback::Run,
-                        base::Unretained(&callback)));
+    cm->GetCookiesWithOptionsAsync(
+        url, CookieOptions(), base::Bind(&GetCookieStringCallback::Run,
+                                         base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.cookie();
@@ -589,6 +604,13 @@
     return callback.result();
   }
 
+  bool SetCookie(CookieMonster* cm,
+                 const GURL& url,
+                 const std::string& cookie_line) {
+    CookieOptions options;
+    return SetCookieWithOptions(cm, url, cookie_line, options);
+  }
+
   bool SetCookieWithDetails(CookieMonster* cm,
                             const GURL& url,
                             const std::string& name,
@@ -619,14 +641,23 @@
     EXPECT_TRUE(callback.did_run());
   }
 
+  int DeleteAll(CookieMonster*cm) {
+    DCHECK(cm);
+    DeleteCallback callback;
+    cm->DeleteAllAsync(
+        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+    RunFor(kTimeout);
+    EXPECT_TRUE(callback.did_run());
+    return callback.num_deleted();
+  }
+
   int DeleteAllCreatedBetween(CookieMonster*cm,
                               const base::Time& delete_begin,
-                              const base::Time& delete_end,
-                              bool sync_to_store) {
+                              const base::Time& delete_end) {
     DCHECK(cm);
     DeleteCallback callback;
     cm->DeleteAllCreatedBetweenAsync(
-        delete_begin, delete_end, sync_to_store,
+        delete_begin, delete_end,
         base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
@@ -675,7 +706,7 @@
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
-    cm->DeleteAll(true);
+    DeleteAll(cm);
 
     // Static population for probe:
     //    * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a)
@@ -778,7 +809,7 @@
       cm->SetExpiryAndKeyScheme(key_scheme);
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(cm->SetCookie(url_google_, cookie));
+        EXPECT_TRUE(SetCookie(cm, url_google_, cookie));
         std::string cookies = this->GetCookies(cm, url_google_);
         // Make sure we find it in the cookies.
         EXPECT_NE(cookies.find(cookie), std::string::npos);
@@ -800,9 +831,9 @@
       cm->SetExpiryAndKeyScheme(key_scheme);
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie_general = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(cm->SetCookie(url_google_, cookie_general));
+        EXPECT_TRUE(SetCookie(cm, url_google_, cookie_general));
         std::string cookie_specific = base::StringPrintf("c%03d=b", i);
-        EXPECT_TRUE(cm->SetCookie(url_google_specific, cookie_specific));
+        EXPECT_TRUE(SetCookie(cm, url_google_specific, cookie_specific));
         std::string cookies_general = this->GetCookies(cm, url_google_);
         EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
         std::string cookies_specific =
@@ -840,6 +871,16 @@
     }
   }
 
+  // Function for creating a CM with a number of cookies in it,
+  // no store (and hence no ability to affect access time).
+  CookieMonster* CreateMonsterForGC(int num_cookies) {
+    CookieMonster* cm(new CookieMonster(NULL, NULL));
+    for (int i = 0; i < num_cookies; i++) {
+      SetCookie(cm, GURL(StringPrintf("http://h%05d.izzle", i)), "a=1");
+    }
+    return cm;
+  }
+
  protected:
   GURL url_google_;
   GURL url_google_secure_;
@@ -849,15 +890,471 @@
   ScopedRunnableMethodFactory<MessageLoop> message_loop_factory_;
 };
 
+// TODO(erikwright): Replace the other callbacks and synchronous helper methods
+// in this test suite with these Mocks.
+template<typename T, typename C> class MockCookieCallback {
+ public:
+  C AsCallback() {
+    return base::Bind(&T::Invoke, base::Unretained(static_cast<T*>(this)));
+  }
+};
+
+class MockGetCookiesCallback
+  : public MockCookieCallback<MockGetCookiesCallback,
+                              CookieStore::GetCookiesCallback> {
+ public:
+  MOCK_METHOD1(Invoke, void(const std::string& cookies));
+};
+
+class MockGetCookieInfoCallback
+  : public MockCookieCallback<MockGetCookieInfoCallback,
+                              CookieStore::GetCookieInfoCallback> {
+ public:
+  MOCK_METHOD2(Invoke,
+               void(const std::string& cookies,
+                    const std::vector<CookieStore::CookieInfo>& cookie_infos));
+};
+
+class MockSetCookiesCallback
+  : public MockCookieCallback<MockSetCookiesCallback,
+                              CookieStore::SetCookiesCallback> {
+ public:
+  MOCK_METHOD1(Invoke, void(bool success));
+};
+
+class MockClosure
+  : public MockCookieCallback<MockClosure, base::Closure> {
+ public:
+  MOCK_METHOD0(Invoke, void(void));
+};
+
+class MockGetCookieListCallback
+  : public MockCookieCallback<MockGetCookieListCallback,
+                              CookieMonster::GetCookieListCallback> {
+ public:
+  MOCK_METHOD1(Invoke, void(const CookieList& cookies));
+};
+
+class MockDeleteCallback
+  : public MockCookieCallback<MockDeleteCallback,
+                              CookieMonster::DeleteCallback> {
+ public:
+  MOCK_METHOD1(Invoke, void(int num_deleted));
+};
+
+class MockDeleteCookieCallback
+  : public MockCookieCallback<MockDeleteCookieCallback,
+                              CookieMonster::DeleteCookieCallback> {
+ public:
+  MOCK_METHOD1(Invoke, void(bool success));
+};
+
+ACTION(QuitCurrentMessageLoop) {
+  MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+}
+
+// TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed,
+// rename these, removing the 'Action' suffix.
+ACTION_P4(DeleteCookieAction, cookie_monster, url, name, callback) {
+  cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback());
+}
+ACTION_P3(GetCookiesAction, cookie_monster, url, callback) {
+  cookie_monster->GetCookiesWithOptionsAsync(
+      url, CookieOptions(), callback->AsCallback());
+}
+ACTION_P3(GetCookiesWithInfoAction, cookie_monster, url, callback) {
+  cookie_monster->GetCookiesWithInfoAsync(
+      url, CookieOptions(), callback->AsCallback());
+}
+ACTION_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) {
+  cookie_monster->SetCookieWithOptionsAsync(
+      url, cookie_line, CookieOptions(), callback->AsCallback());
+}
+ACTION_P4(DeleteAllCreatedBetweenAction,
+          cookie_monster, delete_begin, delete_end, callback) {
+  cookie_monster->DeleteAllCreatedBetweenAsync(
+      delete_begin, delete_end, callback->AsCallback());
+}
+ACTION_P10(SetCookieWithDetailsAction,
+           cookie_monster, url, name, value, domain, path, expiration_time,
+           secure, http_only, callback) {
+  cookie_monster->SetCookieWithDetailsAsync(
+      url, name, value, domain, path, expiration_time, secure, http_only,
+      callback->AsCallback());
+}
+
+ACTION_P2(GetAllCookiesAction, cookie_monster, callback) {
+  cookie_monster->GetAllCookiesAsync(callback->AsCallback());
+}
+
+ACTION_P3(DeleteAllForHostAction, cookie_monster, url, callback) {
+  cookie_monster->DeleteAllForHostAsync(url, callback->AsCallback());
+}
+
+ACTION_P3(DeleteCanonicalCookieAction, cookie_monster, cookie, callback) {
+  cookie_monster->DeleteCanonicalCookieAsync(cookie, callback->AsCallback());
+}
+
+ACTION_P2(DeleteAllAction, cookie_monster, callback) {
+  cookie_monster->DeleteAllAsync(callback->AsCallback());
+}
+
+ACTION_P3(GetAllCookiesForUrlWithOptionsAction, cookie_monster, url, callback) {
+  cookie_monster->GetAllCookiesForURLWithOptionsAsync(
+      url, CookieOptions(), callback->AsCallback());
+}
+
+ACTION_P3(GetAllCookiesForUrlAction, cookie_monster, url, callback) {
+  cookie_monster->GetAllCookiesForURLAsync(url, callback->AsCallback());
+}
+
 }  // namespace
 
+// This test suite verifies the task deferral behaviour of the CookieMonster.
+// Specifically, for each asynchronous method, verify that:
+// 1. invoking it on an uninitialized cookie store causes the store to begin
+//    loading its backing data.
+// 2. The initial invocation does not complete until the loading completes.
+// 3. Invocations after the loading has completed complete immediately.
+class DeferredCookieTaskTest : public CookieMonsterTest {
+ protected:
+  DeferredCookieTaskTest() {
+    persistent_store_ = new NewMockPersistentCookieStore();
+    cookie_monster_ = new CookieMonster(persistent_store_.get(), NULL);
+  }
+
+  // Defines a cookie to be returned from PersistentCookieStore::Load
+  void DeclareLoadedCookie(const std::string& key,
+                      const std::string& cookie_line,
+                      const base::Time& creation_time) {
+    AddCookieToList(key, cookie_line, creation_time, &loaded_cookies_);
+  }
+
+  // Runs the message loop, waiting until PersistentCookieStore::Load is called.
+  // Call CompleteLoadingAndWait to cause the load to complete.
+  void WaitForLoadCall() {
+    RunFor(kTimeout);
+
+    // Verify that PeristentStore::Load was called.
+    testing::Mock::VerifyAndClear(persistent_store_.get());
+  }
+
+  // Invokes the PersistentCookieStore::Load completion callback and waits
+  // until the message loop is quit.
+  void CompleteLoadingAndWait() {
+    loaded_callback_.Run(loaded_cookies_);
+    RunFor(kTimeout);
+  }
+
+  // Performs the provided action, expecting it to cause a call to
+  // PersistentCookieStore::Load. Call WaitForLoadCall to verify the load call
+  // is received.
+  void BeginWith(testing::Action<void(void)> action) {
+    EXPECT_CALL(*this, Begin()).WillOnce(action);
+    ExpectLoadCall();
+    Begin();
+  }
+
+  // Declares an expectation that PersistentCookieStore::Load will be called,
+  // saving the provided callback and sending a quit to the message loop.
+  void ExpectLoadCall() {
+    EXPECT_CALL(*persistent_store_, Load(testing::_)).WillOnce(testing::DoAll(
+        testing::SaveArg<0>(&loaded_callback_),
+        QuitCurrentMessageLoop(),
+        testing::Return(true)));
+  }
+
+  // Invokes the initial action.
+  MOCK_METHOD0(Begin, void(void));
+
+  // Returns the CookieMonster instance under test.
+  CookieMonster& cookie_monster() { return *cookie_monster_; }
+
+ private:
+  // Declares that mock expectations in this test suite are strictly ordered.
+  testing::InSequence in_sequence_;
+  // Holds cookies to be returned from PersistentCookieStore::Load.
+  std::vector<CookieMonster::CanonicalCookie*> loaded_cookies_;
+  // Stores the callback passed from the CookieMonster to the
+  // PersistentCookieStore
+  CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
+  // Stores the CookieMonster under test.
+  scoped_refptr<CookieMonster> cookie_monster_;
+  // Stores the mock PersistentCookieStore.
+  scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
+};
+
+TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookiesCallback get_cookies_callback;
+
+  BeginWith(GetCookiesAction(
+      &cookie_monster(), url_google_, &get_cookies_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
+      GetCookiesAction(&cookie_monster(), url_google_, &get_cookies_callback));
+  EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredGetCookiesWithInfo) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookieInfoCallback get_cookie_info_callback;
+
+  BeginWith(GetCookiesWithInfoAction(
+      &cookie_monster(), url_google_, &get_cookie_info_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce(
+      GetCookiesWithInfoAction(
+          &cookie_monster(), url_google_, &get_cookie_info_callback));
+  EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
+  MockSetCookiesCallback set_cookies_callback;
+
+  BeginWith(SetCookieAction(
+      &cookie_monster(), url_google_, "A=B", &set_cookies_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
+      SetCookieAction(
+          &cookie_monster(), url_google_, "X=Y", &set_cookies_callback));
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
+  MockClosure delete_cookie_callback;
+
+  BeginWith(DeleteCookieAction(
+      &cookie_monster(), url_google_, "A", &delete_cookie_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(
+      DeleteCookieAction(
+          &cookie_monster(), url_google_, "X", &delete_cookie_callback));
+  EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
+  MockSetCookiesCallback set_cookies_callback;
+
+  BeginWith(SetCookieWithDetailsAction(
+      &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo",
+      base::Time(), false, false, &set_cookies_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
+      SetCookieWithDetailsAction(
+          &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo",
+          base::Time(), false, false, &set_cookies_callback));
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookieListCallback get_cookie_list_callback;
+
+  BeginWith(GetAllCookiesAction(
+      &cookie_monster(), &get_cookie_list_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookieListCallback get_cookie_list_callback;
+
+  BeginWith(GetAllCookiesForUrlAction(
+      &cookie_monster(), url_google_, &get_cookie_list_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      GetAllCookiesForUrlAction(
+          &cookie_monster(), url_google_, &get_cookie_list_callback));
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+
+TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookieListCallback get_cookie_list_callback;
+
+  BeginWith(GetAllCookiesForUrlWithOptionsAction(
+      &cookie_monster(), url_google_, &get_cookie_list_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      GetAllCookiesForUrlWithOptionsAction(
+          &cookie_monster(), url_google_, &get_cookie_list_callback));
+  EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) {
+  MockDeleteCallback delete_callback;
+
+  BeginWith(DeleteAllAction(
+      &cookie_monster(), &delete_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      DeleteAllAction(&cookie_monster(), &delete_callback));
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCreatedBetweenCookies) {
+  MockDeleteCallback delete_callback;
+
+  BeginWith(DeleteAllCreatedBetweenAction(
+      &cookie_monster(), base::Time(), base::Time::Now(), &delete_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      DeleteAllCreatedBetweenAction(
+          &cookie_monster(), base::Time(), base::Time::Now(),
+          &delete_callback));
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredDeleteAllForHostCookies) {
+  MockDeleteCallback delete_callback;
+
+  BeginWith(DeleteAllForHostAction(
+      &cookie_monster(), url_google_, &delete_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      DeleteAllForHostAction(
+          &cookie_monster(), url_google_, &delete_callback));
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
+  std::vector<CookieMonster::CanonicalCookie*> cookies;
+  AddCookieToList("www.google.com", "X=1; path=/", base::Time::Now(), &cookies);
+
+  MockDeleteCookieCallback delete_cookie_callback;
+
+  BeginWith(DeleteCanonicalCookieAction(
+      &cookie_monster(), *cookies[0], &delete_cookie_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
+      DeleteCanonicalCookieAction(
+      &cookie_monster(), *cookies[0], &delete_cookie_callback));
+  EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
+// Verify that a series of queued tasks are executed in order upon loading of
+// the backing store and that new tasks received while the queued tasks are
+// being dispatched go to the end of the queue.
+TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
+  DeclareLoadedCookie("www.google.izzle",
+                      "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
+                      Time::Now() + TimeDelta::FromDays(3));
+
+  MockGetCookiesCallback get_cookies_callback;
+  MockSetCookiesCallback set_cookies_callback;
+  MockClosure delete_cookie_callback;
+  MockGetCookieInfoCallback get_cookie_info_callback;
+
+  EXPECT_CALL(*this, Begin()).WillOnce(testing::DoAll(
+      GetCookiesAction(
+          &cookie_monster(), url_google_, &get_cookies_callback),
+      SetCookieAction(
+          &cookie_monster(), url_google_, "A=B", &set_cookies_callback),
+      DeleteCookieAction(
+          &cookie_monster(), url_google_, "A", &delete_cookie_callback)));
+  ExpectLoadCall();
+  Begin();
+
+  WaitForLoadCall();
+  EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
+      GetCookiesWithInfoAction(
+          &cookie_monster(), url_google_, &get_cookie_info_callback));
+
+  EXPECT_CALL(set_cookies_callback, Invoke(true));
+  EXPECT_CALL(delete_cookie_callback, Invoke());
+  EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
 TEST_F(CookieMonsterTest, DomainTest) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "C=D; domain=.google.izzle"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D; domain=.google.izzle"));
   EXPECT_EQ("A=B; C=D", GetCookies(cm, url_google_));
 
   // Verify that A=B was set as a host cookie rather than a domain
@@ -865,18 +1362,18 @@
   EXPECT_EQ("C=D", GetCookies(cm, GURL("http://foo.www.google.izzle")));
 
   // Test and make sure we find domain cookies on the same domain.
-  EXPECT_TRUE(cm->SetCookie(url_google_, "E=F; domain=.www.google.izzle"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "E=F; domain=.www.google.izzle"));
   EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
 
   // Test setting a domain= that doesn't start w/ a dot, should
   // treat it as a domain cookie, as if there was a pre-pended dot.
-  EXPECT_TRUE(cm->SetCookie(url_google_, "G=H; domain=www.google.izzle"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "G=H; domain=www.google.izzle"));
   EXPECT_EQ("A=B; C=D; E=F; G=H", GetCookies(cm, url_google_));
 
   // Test domain enforcement, should fail on a sub-domain or something too deep.
-  EXPECT_FALSE(cm->SetCookie(url_google_, "I=J; domain=.izzle"));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "I=J; domain=.izzle"));
   EXPECT_EQ("", GetCookies(cm, GURL("http://a.izzle")));
-  EXPECT_FALSE(cm->SetCookie(url_google_, "K=L; domain=.bla.www.google.izzle"));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "K=L; domain=.bla.www.google.izzle"));
   EXPECT_EQ("C=D; E=F; G=H",
             GetCookies(cm, GURL("http://bla.www.google.izzle")));
   EXPECT_EQ("A=B; C=D; E=F; G=H", GetCookies(cm, url_google_));
@@ -891,8 +1388,8 @@
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
-  EXPECT_FALSE(cm->SetCookie(url_google_, "a=1; domain=.www.google.com."));
-  EXPECT_FALSE(cm->SetCookie(url_google_, "b=2; domain=.www.google.com.."));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "a=1; domain=.www.google.com."));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "b=2; domain=.www.google.com.."));
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Nothing was persisted to the backing store.
@@ -910,10 +1407,10 @@
   GURL url_cd("http://c.d.com");
   GURL url_d("http://d.com");
 
-  EXPECT_TRUE(cm->SetCookie(url_abcd, "a=1; domain=.a.b.c.d.com"));
-  EXPECT_TRUE(cm->SetCookie(url_abcd, "b=2; domain=.b.c.d.com"));
-  EXPECT_TRUE(cm->SetCookie(url_abcd, "c=3; domain=.c.d.com"));
-  EXPECT_TRUE(cm->SetCookie(url_abcd, "d=4; domain=.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_abcd, "a=1; domain=.a.b.c.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_abcd, "b=2; domain=.b.c.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_abcd, "c=3; domain=.c.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_abcd, "d=4; domain=.d.com"));
 
   EXPECT_EQ("a=1; b=2; c=3; d=4", GetCookies(cm, url_abcd));
   EXPECT_EQ("b=2; c=3; d=4", GetCookies(cm, url_bcd));
@@ -921,8 +1418,8 @@
   EXPECT_EQ("d=4", GetCookies(cm, url_d));
 
   // Check that the same cookie can exist on different sub-domains.
-  EXPECT_TRUE(cm->SetCookie(url_bcd, "X=bcd; domain=.b.c.d.com"));
-  EXPECT_TRUE(cm->SetCookie(url_bcd, "X=cd; domain=.c.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_bcd, "X=bcd; domain=.b.c.d.com"));
+  EXPECT_TRUE(SetCookie(cm, url_bcd, "X=cd; domain=.c.d.com"));
   EXPECT_EQ("b=2; c=3; d=4; X=bcd; X=cd", GetCookies(cm, url_bcd));
   EXPECT_EQ("c=3; d=4; X=cd", GetCookies(cm, url_cd));
 
@@ -943,31 +1440,31 @@
     GURL url_foobar("http://foo.bar.com");
 
     // More specific sub-domain than allowed.
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "a=1; domain=.yo.foo.bar.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "a=1; domain=.yo.foo.bar.com"));
 
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "b=2; domain=.foo.com"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "c=3; domain=.bar.foo.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "b=2; domain=.foo.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "c=3; domain=.bar.foo.com"));
 
     // Different TLD, but the rest is a substring.
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "d=4; domain=.foo.bar.com.net"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "d=4; domain=.foo.bar.com.net"));
 
     // A substring that isn't really a parent domain.
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "e=5; domain=ar.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "e=5; domain=ar.com"));
 
     // Completely invalid domains:
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "f=6; domain=."));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "g=7; domain=/"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "h=8; domain=http://foo.bar.com"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "i=9; domain=..foo.bar.com"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "j=10; domain=..bar.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "f=6; domain=."));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "g=7; domain=/"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "h=8; domain=http://foo.bar.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "i=9; domain=..foo.bar.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "j=10; domain=..bar.com"));
 
     // Make sure there isn't something quirky in the domain canonicalization
     // that supports full URL semantics.
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "k=11; domain=.foo.bar.com?blah"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "l=12; domain=.foo.bar.com/blah"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "m=13; domain=.foo.bar.com:80"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "n=14; domain=.foo.bar.com:"));
-    EXPECT_FALSE(cm->SetCookie(url_foobar, "o=15; domain=.foo.bar.com#sup"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "k=11; domain=.foo.bar.com?blah"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "l=12; domain=.foo.bar.com/blah"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "m=13; domain=.foo.bar.com:80"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "n=14; domain=.foo.bar.com:"));
+    EXPECT_FALSE(SetCookie(cm, url_foobar, "o=15; domain=.foo.bar.com#sup"));
 
     EXPECT_EQ("", GetCookies(cm, url_foobar));
 
@@ -981,7 +1478,7 @@
     // hosts below have the same domain + registry.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url_foocom("http://foo.com.com");
-    EXPECT_FALSE(cm->SetCookie(url_foocom, "a=1; domain=.foo.com.com.com"));
+    EXPECT_FALSE(SetCookie(cm, url_foocom, "a=1; domain=.foo.com.com.com"));
     EXPECT_EQ("", GetCookies(cm, url_foocom));
   }
 }
@@ -994,7 +1491,7 @@
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url_hosted("http://manage.hosted.filefront.com");
     GURL url_filefront("http://www.filefront.com");
-    EXPECT_TRUE(cm->SetCookie(url_hosted, "sawAd=1; domain=filefront.com"));
+    EXPECT_TRUE(SetCookie(cm, url_hosted, "sawAd=1; domain=filefront.com"));
     EXPECT_EQ("sawAd=1", GetCookies(cm, url_hosted));
     EXPECT_EQ("sawAd=1", GetCookies(cm, url_filefront));
   }
@@ -1002,7 +1499,7 @@
   {  // Even when the domains match exactly, don't consider it host cookie.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://www.google.com");
-    EXPECT_TRUE(cm->SetCookie(url, "a=1; domain=www.google.com"));
+    EXPECT_TRUE(SetCookie(cm, url, "a=1; domain=www.google.com"));
     EXPECT_EQ("a=1", GetCookies(cm, url));
     EXPECT_EQ("a=1", GetCookies(cm, GURL("http://sub.www.google.com")));
     EXPECT_EQ("", GetCookies(cm, GURL("http://something-else.com")));
@@ -1014,8 +1511,8 @@
 TEST_F(CookieMonsterTest, CaseInsensitiveDomainTest) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url("http://www.google.com");
-  EXPECT_TRUE(cm->SetCookie(url, "a=1; domain=.GOOGLE.COM"));
-  EXPECT_TRUE(cm->SetCookie(url, "b=2; domain=.wWw.gOOgLE.coM"));
+  EXPECT_TRUE(SetCookie(cm, url, "a=1; domain=.GOOGLE.COM"));
+  EXPECT_TRUE(SetCookie(cm, url, "b=2; domain=.wWw.gOOgLE.coM"));
   EXPECT_EQ("a=1; b=2", GetCookies(cm, url));
 }
 
@@ -1023,20 +1520,20 @@
   GURL url_ip("http://1.2.3.4/weee");
   {
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-    EXPECT_TRUE(cm->SetCookie(url_ip, kValidCookieLine));
+    EXPECT_TRUE(SetCookie(cm, url_ip, kValidCookieLine));
     EXPECT_EQ("A=B", GetCookies(cm, url_ip));
   }
 
   {  // IP addresses should not be able to set domain cookies.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-    EXPECT_FALSE(cm->SetCookie(url_ip, "b=2; domain=.1.2.3.4"));
-    EXPECT_FALSE(cm->SetCookie(url_ip, "c=3; domain=.3.4"));
+    EXPECT_FALSE(SetCookie(cm, url_ip, "b=2; domain=.1.2.3.4"));
+    EXPECT_FALSE(SetCookie(cm, url_ip, "c=3; domain=.3.4"));
     EXPECT_EQ("", GetCookies(cm, url_ip));
     // It should be allowed to set a cookie if domain= matches the IP address
     // exactly.  This matches IE/Firefox, even though it seems a bit wrong.
-    EXPECT_FALSE(cm->SetCookie(url_ip, "b=2; domain=1.2.3.3"));
+    EXPECT_FALSE(SetCookie(cm, url_ip, "b=2; domain=1.2.3.3"));
     EXPECT_EQ("", GetCookies(cm, url_ip));
-    EXPECT_TRUE(cm->SetCookie(url_ip, "b=2; domain=1.2.3.4"));
+    EXPECT_TRUE(SetCookie(cm, url_ip, "b=2; domain=1.2.3.4"));
     EXPECT_EQ("b=2", GetCookies(cm, url_ip));
   }
 }
@@ -1047,9 +1544,9 @@
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://com/");
     // Allow setting on "com", (but only as a host cookie).
-    EXPECT_TRUE(cm->SetCookie(url, "a=1"));
-    EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=.com"));
-    EXPECT_FALSE(cm->SetCookie(url, "c=3; domain=com"));
+    EXPECT_TRUE(SetCookie(cm, url, "a=1"));
+    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=.com"));
+    EXPECT_FALSE(SetCookie(cm, url, "c=3; domain=com"));
     EXPECT_EQ("a=1", GetCookies(cm, url));
     // Make sure it doesn't show up for a normal .com, it should be a host
     // not a domain cookie.
@@ -1060,7 +1557,7 @@
   {  // http://com. should be treated the same as http://com.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://com./index.html");
-    EXPECT_TRUE(cm->SetCookie(url, "a=1"));
+    EXPECT_TRUE(SetCookie(cm, url, "a=1"));
     EXPECT_EQ("a=1", GetCookies(cm, url));
     EXPECT_EQ("", GetCookies(cm, GURL("http://hopefully-no-cookies.com./")));
   }
@@ -1068,24 +1565,24 @@
   {  // Should not be able to set host cookie from a subdomain.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://a.b");
-    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.b"));
-    EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=b"));
+    EXPECT_FALSE(SetCookie(cm, url, "a=1; domain=.b"));
+    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=b"));
     EXPECT_EQ("", GetCookies(cm, url));
   }
 
   {  // Same test as above, but explicitly on a known TLD (com).
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://google.com");
-    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.com"));
-    EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=com"));
+    EXPECT_FALSE(SetCookie(cm, url, "a=1; domain=.com"));
+    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=com"));
     EXPECT_EQ("", GetCookies(cm, url));
   }
 
   {  // Make sure can't set cookie on TLD which is dotted.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://google.co.uk");
-    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.co.uk"));
-    EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=.uk"));
+    EXPECT_FALSE(SetCookie(cm, url, "a=1; domain=.co.uk"));
+    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=.uk"));
     EXPECT_EQ("", GetCookies(cm, url));
     EXPECT_EQ("", GetCookies(cm, GURL("http://something-else.co.uk")));
     EXPECT_EQ("", GetCookies(cm, GURL("http://something-else.uk")));
@@ -1094,9 +1591,9 @@
   {  // Intranet URLs should only be able to set host cookies.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://b");
-    EXPECT_TRUE(cm->SetCookie(url, "a=1"));
-    EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=.b"));
-    EXPECT_FALSE(cm->SetCookie(url, "c=3; domain=b"));
+    EXPECT_TRUE(SetCookie(cm, url, "a=1"));
+    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=.b"));
+    EXPECT_FALSE(SetCookie(cm, url, "c=3; domain=b"));
     EXPECT_EQ("a=1", GetCookies(cm, url));
   }
 }
@@ -1107,15 +1604,15 @@
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url("http://www.google.com");
   GURL url_with_dot("http://www.google.com.");
-  EXPECT_TRUE(cm->SetCookie(url, "a=1"));
+  EXPECT_TRUE(SetCookie(cm, url, "a=1"));
   EXPECT_EQ("a=1", GetCookies(cm, url));
 
   // Do not share cookie space with the dot version of domain.
   // Note: this is not what FireFox does, but it _is_ what IE+Safari do.
-  EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=.www.google.com."));
+  EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=.www.google.com."));
   EXPECT_EQ("a=1", GetCookies(cm, url));
 
-  EXPECT_TRUE(cm->SetCookie(url_with_dot, "b=2; domain=.google.com."));
+  EXPECT_TRUE(SetCookie(cm, url_with_dot, "b=2; domain=.google.com."));
   EXPECT_EQ("b=2", GetCookies(cm, url_with_dot));
 
   // Make sure there weren't any side effects.
@@ -1125,19 +1622,19 @@
 
 TEST_F(CookieMonsterTest, InvalidScheme) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_FALSE(cm->SetCookie(GURL(kUrlFtp), kValidCookieLine));
+  EXPECT_FALSE(SetCookie(cm, GURL(kUrlFtp), kValidCookieLine));
 }
 
 TEST_F(CookieMonsterTest, InvalidScheme_Read) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(GURL(kUrlGoogle), kValidDomainCookieLine));
+  EXPECT_TRUE(SetCookie(cm, GURL(kUrlGoogle), kValidDomainCookieLine));
   EXPECT_EQ("", GetCookies(cm, GURL(kUrlFtp)));
 }
 
 TEST_F(CookieMonsterTest, PathTest) {
   std::string url("http://www.google.izzle");
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(GURL(url), "A=B; path=/wee"));
+  EXPECT_TRUE(SetCookie(cm, GURL(url), "A=B; path=/wee"));
   EXPECT_EQ("A=B", GetCookies(cm, GURL(url + "/wee")));
   EXPECT_EQ("A=B", GetCookies(cm, GURL(url + "/wee/")));
   EXPECT_EQ("A=B", GetCookies(cm, GURL(url + "/wee/war")));
@@ -1146,7 +1643,7 @@
   EXPECT_EQ("", GetCookies(cm, GURL(url + "/")));
 
   // If we add a 0 length path, it should default to /
-  EXPECT_TRUE(cm->SetCookie(GURL(url), "A=C; path="));
+  EXPECT_TRUE(SetCookie(cm, GURL(url), "A=C; path="));
   EXPECT_EQ("A=B; A=C", GetCookies(cm, GURL(url + "/wee")));
   EXPECT_EQ("A=C", GetCookies(cm, GURL(url + "/")));
 }
@@ -1164,14 +1661,14 @@
   EXPECT_EQ("A=B", GetCookiesWithOptions(cm, url_google_, options));
 
   // Check httponly overwrite protection.
-  EXPECT_FALSE(cm->SetCookie(url_google_, "A=C"));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "A=C"));
   EXPECT_EQ("", GetCookies(cm, url_google_));
   EXPECT_EQ("A=B", GetCookiesWithOptions(cm, url_google_, options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=C", options));
   EXPECT_EQ("A=C", GetCookies(cm, url_google_));
 
   // Check httponly create protection.
-  EXPECT_FALSE(cm->SetCookie(url_google_, "B=A; httponly"));
+  EXPECT_FALSE(SetCookie(cm, url_google_, "B=A; httponly"));
   EXPECT_EQ("A=C", GetCookiesWithOptions(cm, url_google_, options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "B=A; httponly", options));
   EXPECT_EQ("A=C; B=A", GetCookiesWithOptions(cm, url_google_, options));
@@ -1324,24 +1821,24 @@
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
 
   // Create a session cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
+  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
+  EXPECT_TRUE(SetCookie(cm, url_google_,
                            std::string(kValidCookieLine) + "; max-age=0"));
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Create a session cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
+  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Expires.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
+  EXPECT_TRUE(SetCookie(cm, url_google_,
                            std::string(kValidCookieLine) +
                            "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
+  EXPECT_TRUE(SetCookie(cm, url_google_,
                            std::string(kValidCookieLine) +
                            "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
@@ -1349,38 +1846,38 @@
 
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
+  EXPECT_TRUE(SetCookie(cm, url_google_,
                            std::string(kValidCookieLine) + "; max-age=0"));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
-                           std::string(kValidCookieLine) +
-                           "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google_,
+                        std::string(kValidCookieLine) +
+                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Expires.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
-                           std::string(kValidCookieLine) +
-                           "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google_,
+                        std::string(kValidCookieLine) +
+                        "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
   ASSERT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Create a persistent cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
-                           std::string(kValidCookieLine) +
-                           "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google_,
+                        std::string(kValidCookieLine) +
+                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(5u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Expires, with a unix epoch of 0.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
-                           std::string(kValidCookieLine) +
-                           "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google_,
+                        std::string(kValidCookieLine) +
+                        "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
   ASSERT_EQ(6u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[5].type);
   EXPECT_EQ("", GetCookies(cm, url_google_));
@@ -1393,25 +1890,25 @@
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
+  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
 
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "C=D; httponly", options));
   EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm, url_google_, options));
 
-  EXPECT_EQ(2, cm->DeleteAll(false));
+  EXPECT_EQ(2, DeleteAll(cm));
   EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
 
   EXPECT_EQ(0u, store->commands().size());
 
   // Create a persistent cookie.
-  EXPECT_TRUE(cm->SetCookie(url_google_,
-                            std::string(kValidCookieLine) +
-                            "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google_,
+                        std::string(kValidCookieLine) +
+                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
 
-  EXPECT_EQ(1, cm->DeleteAll(true));  // sync_to_store = true.
+  EXPECT_EQ(1, DeleteAll(cm));  // sync_to_store = true.
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
@@ -1424,59 +1921,56 @@
 
   // Nothing has been added so nothing should be deleted.
   EXPECT_EQ(0, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time(), false));
+                                       Time()));
 
   // Create 3 cookies with creation date of today, yesterday and the day before.
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-0=Now", now));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-1=Yesterday",
-                                           now - TimeDelta::FromDays(1)));
+                                            now - TimeDelta::FromDays(1)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-2=DayBefore",
-                                           now - TimeDelta::FromDays(2)));
+                                            now - TimeDelta::FromDays(2)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-3=ThreeDays",
-                                           now - TimeDelta::FromDays(3)));
+                                            now - TimeDelta::FromDays(3)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-7=LastWeek",
-                                           now - TimeDelta::FromDays(7)));
+                                            now - TimeDelta::FromDays(7)));
 
   // Try to delete threedays and the daybefore.
   EXPECT_EQ(2, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(3),
-                                          now - TimeDelta::FromDays(1),
-                                          false));
+                                       now - TimeDelta::FromDays(1)));
 
   // Try to delete yesterday, also make sure that delete_end is not
   // inclusive.
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(2),
-                                          now,
-                                          false));
+                                       now));
 
   // Make sure the delete_begin is inclusive.
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(7),
-                                          now,
-                                          false));
+                                       now));
 
   // Delete the last (now) item.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time(), false));
+  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time()));
 
   // Really make sure everything is gone.
-  EXPECT_EQ(0, cm->DeleteAll(false));
+  EXPECT_EQ(0, DeleteAll(cm));
 }
 
 TEST_F(CookieMonsterTest, TestSecure) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_secure_));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_secure_, "A=B; secure"));
+  EXPECT_TRUE(SetCookie(cm, url_google_secure_, "A=B; secure"));
   // The secure should overwrite the non-secure.
   EXPECT_EQ("", GetCookies(cm, url_google_));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_secure_));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_secure_, "D=E; secure"));
+  EXPECT_TRUE(SetCookie(cm, url_google_secure_, "D=E; secure"));
   EXPECT_EQ("", GetCookies(cm, url_google_));
   EXPECT_EQ("A=B; D=E", GetCookies(cm, url_google_secure_));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_secure_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_secure_, "A=B"));
   // The non-secure should overwrite the secure.
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   EXPECT_EQ("D=E; A=B", GetCookies(cm, url_google_secure_));
@@ -1488,7 +1982,7 @@
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   const Time last_access_date(GetFirstCookieAccessDate(cm));
 
   // Reading the cookie again immediately shouldn't update the access date,
@@ -1517,13 +2011,13 @@
 
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(cm->SetCookie(test_url, "foo=bar"));
+  EXPECT_TRUE(SetCookie(cm, test_url, "foo=bar"));
   std::string value = GetCookies(cm, test_url);
   EXPECT_EQ("foo=bar", value);
 
   // test that we can retrieve all cookies:
-  EXPECT_TRUE(cm->SetCookie(test_url, "x=1"));
-  EXPECT_TRUE(cm->SetCookie(test_url, "y=2"));
+  EXPECT_TRUE(SetCookie(cm, test_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm, test_url, "y=2"));
 
   std::string result = GetCookies(cm, test_url);
   EXPECT_FALSE(result.empty());
@@ -1534,9 +2028,9 @@
 TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "C=D"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "E=F"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "E=F"));
   EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
 
   EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
@@ -1557,10 +2051,10 @@
   GURL foo_url("foo://host/path");
   GURL http_url("http://host/path");
 
-  EXPECT_TRUE(cm->SetCookie(http_url, "x=1"));
-  EXPECT_FALSE(cm->SetCookie(foo_url, "x=1"));
-  EXPECT_TRUE(cm_foo->SetCookie(foo_url, "x=1"));
-  EXPECT_FALSE(cm_foo->SetCookie(http_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm, http_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm, foo_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm_foo, foo_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm_foo, http_url, "x=1"));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
@@ -1573,11 +2067,11 @@
 
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B; httponly", options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
-                                       "C=D; domain=.google.izzle",
-                                       options));
+                                   "C=D; domain=.google.izzle",
+                                   options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_secure_,
-                                       "E=F; domain=.google.izzle; secure",
-                                       options));
+                                   "E=F; domain=.google.izzle; secure",
+                                   options));
 
   const Time last_access_date(GetFirstCookieAccessDate(cm));
 
@@ -1635,14 +2129,11 @@
   CookieOptions options;
 
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_foo_,
-                                       "A=B; path=/foo;",
-                                       options));
+                                   "A=B; path=/foo;", options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_bar_,
-                                       "C=D; path=/bar;",
-                                       options));
+                                   "C=D; path=/bar;", options));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
-                                       "E=F;",
-                                       options));
+                                   "E=F;", options));
 
   CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
   CookieList::iterator it = cookies.begin();
@@ -1674,12 +2165,12 @@
 TEST_F(CookieMonsterTest, DeleteCookieByName) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=A1; path=/"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=A2; path=/foo"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=A3; path=/bar"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "B=B1; path=/"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "B=B2; path=/foo"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "B=B3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=A3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "B=B3; path=/bar"));
 
   DeleteCookie(cm, GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
 
@@ -1742,15 +2233,15 @@
 
   // Insert a cookie "a" for path "/path1"
   EXPECT_TRUE(
-      cm->SetCookie(url_google, "a=val1; path=/path1; "
-                                "expires=Mon, 18-Apr-22 22:50:13 GMT"));
+      SetCookie(cm, url_google, "a=val1; path=/path1; "
+                "expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
 
   // Insert a cookie "b" for path "/path1"
   EXPECT_TRUE(
-      cm->SetCookie(url_google, "b=val1; path=/path1; "
-                                "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+      SetCookie(cm, url_google, "b=val1; path=/path1; "
+                "expires=Mon, 18-Apr-22 22:50:14 GMT"));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[1].type);
 
@@ -1760,35 +2251,35 @@
   allow_httponly.set_include_httponly();
   EXPECT_TRUE(
     SetCookieWithOptions(cm, url_google,
-                             "b=val2; path=/path1; httponly; "
-                             "expires=Mon, 18-Apr-22 22:50:14 GMT",
-                             allow_httponly));
+                         "b=val2; path=/path1; httponly; "
+                         "expires=Mon, 18-Apr-22 22:50:14 GMT",
+                         allow_httponly));
   ASSERT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[2].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[3].type);
 
   // Insert a cookie "a" for path "/path1". This should overwrite.
-  EXPECT_TRUE(cm->SetCookie(url_google,
-                            "a=val33; path=/path1; "
-                            "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google,
+                        "a=val33; path=/path1; "
+                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
   ASSERT_EQ(6u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[4].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[5].type);
 
   // Insert a cookie "a" for path "/path2". This should NOT overwrite
   // cookie "a", since the path is different.
-  EXPECT_TRUE(cm->SetCookie(url_google,
-                            "a=val9; path=/path2; "
-                            "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_google,
+                        "a=val9; path=/path2; "
+                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
   ASSERT_EQ(7u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[6].type);
 
   // Insert a cookie "a" for path "/path1", but this time for "chromium.org".
   // Although the name and path match, the hostnames do not, so shouldn't
   // overwrite.
-  EXPECT_TRUE(cm->SetCookie(url_chromium,
-                            "a=val99; path=/path1; "
-                            "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(SetCookie(cm, url_chromium,
+                        "a=val99; path=/path1; "
+                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
   ASSERT_EQ(8u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[7].type);
 
@@ -1929,9 +2420,9 @@
       new MockCookieMonsterDelegate);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, delegate));
 
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "C=D"));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "E=F"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "E=F"));
   EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
   ASSERT_EQ(3u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
@@ -1963,7 +2454,7 @@
 
   // Insert a cookie "a" for path "/path1"
   EXPECT_TRUE(
-      cm->SetCookie(url_google_, "a=val1; path=/path1; "
+      SetCookie(cm, url_google_, "a=val1; path=/path1; "
                                 "expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
@@ -1980,9 +2471,9 @@
   allow_httponly.set_include_httponly();
   EXPECT_TRUE(
     SetCookieWithOptions(cm, url_google_,
-                             "a=val2; path=/path1; httponly; "
-                             "expires=Mon, 18-Apr-22 22:50:14 GMT",
-                             allow_httponly));
+                         "a=val2; path=/path1; httponly; "
+                         "expires=Mon, 18-Apr-22 22:50:14 GMT",
+                         allow_httponly));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
@@ -2143,40 +2634,22 @@
   // are not included as they aren't going to be public for very much
   // longer.
 
-  // SetCookie, SetCookies, SetCookiesWithOptions,
-  // SetCookieWithOptions, SetCookieWithDetails
+  // SetCookie, SetCookieWithOptions, SetCookieWithDetails
 
-  cm->SetCookie(url_google_, "SetCookie1=A");
-  cm->SetCookie(url_google_, "SetCookie2=A");
-  cm->SetCookie(url_google_, "SetCookie3=A");
+  SetCookie(cm, url_google_, "SetCookie1=A");
+  SetCookie(cm, url_google_, "SetCookie2=A");
+  SetCookie(cm, url_google_, "SetCookie3=A");
 
-  {
-    std::vector<std::string> cookie_lines;
-    cookie_lines.push_back("setCookies1=A");
-    cookie_lines.push_back("setCookies2=A");
-    cookie_lines.push_back("setCookies4=A");
-    cm->SetCookies(url_google_, cookie_lines);
-  }
-
-  {
-    std::vector<std::string> cookie_lines;
-    cookie_lines.push_back("setCookiesWithOptions1=A");
-    cookie_lines.push_back("setCookiesWithOptions2=A");
-    cookie_lines.push_back("setCookiesWithOptions3=A");
-
-    cm->SetCookiesWithOptions(url_google_, cookie_lines, options);
-  }
-
   SetCookieWithOptions(cm, url_google_, "setCookieWithOptions1=A", options);
   SetCookieWithOptions(cm, url_google_, "setCookieWithOptions2=A", options);
   SetCookieWithOptions(cm, url_google_, "setCookieWithOptions3=A", options);
 
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails1", "A",
-                           ".google.com", "/", Time(), false, false);
+                       ".google.com", "/", Time(), false, false);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A",
-                           ".google.com", "/", Time(), false, false);
+                       ".google.com", "/", Time(), false, false);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A",
-                           ".google.com", "/", Time(), false, false);
+                       ".google.com", "/", Time(), false, false);
 
   // Now we check
   CookieList cookie_list(GetAllCookies(cm));
@@ -2263,9 +2736,9 @@
     scoped_refptr<CookieMonster> cmout(new CookieMonster(store, NULL));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
-      EXPECT_TRUE(cmout->SetCookieWithDetails(GURL(p->gurl), p->name, p->value,
-                                              p->domain, p->path, p->expires,
-                                              p->secure, p->http_only));
+      EXPECT_TRUE(SetCookieWithDetails(cmout, GURL(p->gurl), p->name, p->value,
+                                       p->domain, p->path, p->expires,
+                                       p->secure, p->http_only));
     }
     DeleteCookie(cmout, GURL(std::string(input_info[INPUT_DELETE].gurl) +
                              input_info[INPUT_DELETE].path),
@@ -2304,26 +2777,26 @@
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://d.c.b.a.google.com/aa/x.html"),
-                            "c=1"));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://b.a.google.com/aa/bb/cc/x.html"),
-                            "d=1; domain=b.a.google.com"));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://b.a.google.com/aa/bb/cc/x.html"),
-                            "a=4; domain=b.a.google.com"));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
-                            "e=1; domain=c.b.a.google.com"));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://d.c.b.a.google.com/aa/bb/x.html"),
-                            "b=1"));
-  EXPECT_TRUE(cm->SetCookie(GURL("http://news.bbc.co.uk/midpath/x.html"),
-                            "g=10"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/x.html"),
+                        "c=1"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+                        "d=1; domain=b.a.google.com"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"),
+                        "a=4; domain=b.a.google.com"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
+                        "e=1; domain=c.b.a.google.com"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/bb/x.html"),
+                        "b=1"));
+  EXPECT_TRUE(SetCookie(cm, GURL("http://news.bbc.co.uk/midpath/x.html"),
+                        "g=10"));
   EXPECT_EQ("d=1; a=4; e=1; b=1; c=1",
-            GetCookiesWithOptions(cm,
-                GURL("http://d.c.b.a.google.com/aa/bb/cc/dd"),
+            GetCookiesWithOptions(
+                cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd"),
                 CookieOptions()));
   {
     unsigned int i = 0;
-    CookieList cookies(cm->GetAllCookiesForURL(
-        GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+    CookieList cookies(GetAllCookiesForURL(
+        cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
     ASSERT_EQ(5u, cookies.size());
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
@@ -2345,16 +2818,6 @@
   }
 }
 
-
-// Function for creating a CM with a number of cookies in it,
-// no store (and hence no ability to affect access time).
-static CookieMonster* CreateMonsterForGC(int num_cookies) {
-  CookieMonster* cm(new CookieMonster(NULL, NULL));
-  for (int i = 0; i < num_cookies; i++)
-    cm->SetCookie(GURL(StringPrintf("http://h%05d.izzle", i)), "a=1");
-  return cm;
-}
-
 // This test and CookieMonstertest.TestGCTimes (in cookie_monster_perftest.cc)
 // are somewhat complementary twins.  This test is probing for whether
 // garbage collection always happens when it should (i.e. that we actually
@@ -2368,7 +2831,7 @@
     scoped_refptr<CookieMonster> cm(
         CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
     EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm).size());
-    cm->SetCookie(GURL("http://newdomain.com"), "b=2");
+    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
     EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, GetAllCookies(cm).size());
   }
 
@@ -2433,7 +2896,7 @@
                 static_cast<int>(GetAllCookies(cm).size()))
           << "For test case " << ci;
       // Will trigger GC
-      cm->SetCookie(GURL("http://newdomain.com"), "b=2");
+      SetCookie(cm, GURL("http://newdomain.com"), "b=2");
       EXPECT_EQ(test_case->expected_cookies_after_set[recent_scheme],
                 static_cast<int>((GetAllCookies(cm).size())))
           << "For test case (" << ci << ", " << recent_scheme << ")";
@@ -2449,7 +2912,8 @@
 
   // Set a persistent cookie, but force it to be a session cookie.
   options.set_force_session();
-  ASSERT_TRUE(SetCookieWithOptions(cm, url_google_,
+  ASSERT_TRUE(SetCookieWithOptions(
+      cm, url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
       options));
 
@@ -2459,7 +2923,8 @@
   ASSERT_FALSE(cookie_list[0].IsPersistent());
 
   // Use a past expiry date to delete the cookie, but force it to session only.
-  ASSERT_TRUE(SetCookieWithOptions(cm, url_google_,
+  ASSERT_TRUE(SetCookieWithOptions(
+      cm, url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       options));
 
@@ -2475,7 +2940,8 @@
   CookieOptions options;
 
   // Set a persistent cookie.
-  ASSERT_TRUE(SetCookieWithOptions(cm, url_google_,
+  ASSERT_TRUE(SetCookieWithOptions(
+      cm, url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
       options));
 
@@ -2484,7 +2950,8 @@
   ASSERT_EQ(1U, cookie_list.size());
 
   // Use a past expiry date to delete the cookie.
-  ASSERT_TRUE(SetCookieWithOptions(cm, url_google_,
+  ASSERT_TRUE(SetCookieWithOptions(
+      cm, url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       options));
 
@@ -2502,7 +2969,9 @@
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
-  bool Load(std::vector<CookieMonster::CanonicalCookie*>*) {
+  bool Load(const LoadedCallback& loaded_callback) {
+    std::vector<CookieMonster::CanonicalCookie*> out_cookies;
+    loaded_callback.Run(out_cookies);
     return false;
   }
 
@@ -2652,7 +3121,7 @@
             histogram_set_2.TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
+  ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   expired_histogram->SnapshotSample(&histogram_set_1);
   EXPECT_EQ(histogram_set_2.TotalCount(),
             histogram_set_1.TotalCount());
@@ -2670,8 +3139,8 @@
   void GetCookiesTask(CookieMonster* cm,
                       const GURL& url,
                       GetCookieStringCallback* callback) {
-    cm->GetCookiesAsync(
-        url,
+    cm->GetCookiesWithOptionsAsync(
+        url, CookieOptions(),
         base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
   }
 
@@ -2755,10 +3224,9 @@
   void DeleteAllCreatedBetweenTask(CookieMonster* cm,
                                    const base::Time& delete_begin,
                                    const base::Time& delete_end,
-                                   bool sync_to_store,
                                    DeleteCallback* callback) {
     cm->DeleteAllCreatedBetweenAsync(
-        delete_begin, delete_end, sync_to_store,
+        delete_begin, delete_end,
         base::Bind(&DeleteCallback::Run,
                    base::Unretained(callback)));
   }
@@ -2798,7 +3266,7 @@
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   GetCookieStringCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ -2813,7 +3281,7 @@
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookiesWithOptions) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookiesWithOptions(cm, url_google_, options));
   GetCookieStringCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ -2830,7 +3298,7 @@
   CookieOptions options;
   std::string cookie_line;
   std::vector<CookieStore::CookieInfo> cookie_infos;
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   GetCookiesWithInfo(cm, url_google_, options, &cookie_line, &cookie_infos);
   EXPECT_EQ("A=B", cookie_line);
   EXPECT_EQ(1U, cookie_infos.size());
@@ -2853,7 +3321,7 @@
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   CookieList cookies = GetAllCookies(cm);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
@@ -2876,7 +3344,7 @@
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   CookieList cookies = GetAllCookiesForURL(cm, url_google_);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
@@ -2899,7 +3367,7 @@
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
   CookieOptions options;
   CookieList cookies =
       GetAllCookiesForURLWithOptions(cm, url_google_, options);
@@ -2973,14 +3441,14 @@
   Time now = Time::Now();
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time(), false));
+                                       Time()));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
   DeleteCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
       base::Unretained(this),
       cm, now - TimeDelta::FromDays(99),
-      Time(), false, &callback);
+      Time(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.num_deleted());