Revert 100415 - Re-land http://codereview.chromium.org/7831056/ and http://codereview.chromium.org/7833042/ .

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

They are now loaded on the DB thread. Cookie operations received in the meantime are queued and executed, on the IO thread, in the order they were received, when loading completes.

A few straggler clients are updated to use the asynchronous CookieStore/CookieMonster API as part of this CL, as the synchronous API is removed.

This entire CL has been previously reviewed by the appropriate owners, however an error was made during the submit.

BUG=68657
TEST=net_unittests / DeferredCookieTaskTest.* and CookieMonsterTest.*
Review URL: http://codereview.chromium.org/7860039

TBR=erikwright@chromium.org
Review URL: http://codereview.chromium.org/7862002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@100460 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 242 insertions, 711 deletions

diff --git a/net/base/cookie_monster_unittest.cc b/net/base/cookie_monster_unittest.cc
index fac72f8..3b41c7b 100644
--- a/net/base/cookie_monster_unittest.cc
+++ b/net/base/cookie_monster_unittest.cc
@@ -20,8 +20,7 @@
 #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 "testing/gmock/include/gmock/gmock.h"
+#include "net/base/cookie_monster_store_test.h"  // For CookieStore Mock
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -32,20 +31,6 @@ using base::Thread;
 
 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";
@@ -160,10 +145,10 @@ class GetCookiesWithInfoCallback : public CookieCallback {
       : CookieCallback(run_in_thread) {}
 
   void Run(
-      const std::string& cookie_line,
-      const std::vector<CookieStore::CookieInfo>& cookie_info) {
-    cookie_line_ = cookie_line;
-    cookie_info_ = cookie_info;
+      std::string* cookie_line,
+      std::vector<CookieStore::CookieInfo>* cookie_info) {
+    cookie_line_ = *cookie_line;
+    cookie_info_ = *cookie_info;
     CallbackEpilogue();
   }
 
@@ -432,7 +417,7 @@ TEST(ParsedCookieTest, TooManyPairs) {
   EXPECT_FALSE(pc2.IsSecure());
 }
 
-// TODO(erikwright): some better test cases for invalid cookies.
+// TODO some better test cases for invalid cookies.
 TEST(ParsedCookieTest, InvalidWhitespace) {
   CookieMonster::ParsedCookie pc("    ");
   EXPECT_FALSE(pc.IsValid());
@@ -514,9 +499,9 @@ class CookieMonsterTest : public testing::Test {
   std::string GetCookies(CookieMonster* cm, const GURL& url) {
     DCHECK(cm);
     GetCookieStringCallback callback;
-    cm->GetCookiesWithOptionsAsync(
-        url, CookieOptions(), base::Bind(&GetCookieStringCallback::Run,
-                                         base::Unretained(&callback)));
+    cm->GetCookiesAsync(
+        url, base::Bind(&GetCookieStringCallback::Run,
+                        base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.cookie();
@@ -604,13 +589,6 @@ class CookieMonsterTest : public testing::Test {
     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,
@@ -641,23 +619,14 @@ class CookieMonsterTest : public testing::Test {
     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) {
+                              const base::Time& delete_end,
+                              bool sync_to_store) {
     DCHECK(cm);
     DeleteCallback callback;
     cm->DeleteAllCreatedBetweenAsync(
-        delete_begin, delete_end,
+        delete_begin, delete_end, sync_to_store,
         base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
@@ -706,7 +675,7 @@ class CookieMonsterTest : public testing::Test {
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
-    DeleteAll(cm);
+    cm->DeleteAll(true);
 
     // Static population for probe:
     //    * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a)
@@ -809,7 +778,7 @@ class CookieMonsterTest : public testing::Test {
       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(SetCookie(cm, url_google_, cookie));
+        EXPECT_TRUE(cm->SetCookie(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);
@@ -831,9 +800,9 @@ class CookieMonsterTest : public testing::Test {
       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(SetCookie(cm, url_google_, cookie_general));
+        EXPECT_TRUE(cm->SetCookie(url_google_, cookie_general));
         std::string cookie_specific = base::StringPrintf("c%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm, url_google_specific, cookie_specific));
+        EXPECT_TRUE(cm->SetCookie(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 =
@@ -871,16 +840,6 @@ class CookieMonsterTest : public testing::Test {
     }
   }
 
-  // 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_;
@@ -890,472 +849,15 @@ class CookieMonsterTest : public testing::Test {
   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;
-  CookieMonster::CanonicalCookie cookie = BuildCanonicalCookie(
-      "www.google.com", "X=1; path=/", base::Time::Now());
-
-  MockDeleteCookieCallback delete_cookie_callback;
-
-  BeginWith(DeleteCanonicalCookieAction(
-      &cookie_monster(), cookie, &delete_cookie_callback));
-
-  WaitForLoadCall();
-
-  EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
-      DeleteCanonicalCookieAction(
-      &cookie_monster(), cookie, &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(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "C=D; domain=.google.izzle"));
+  EXPECT_TRUE(cm->SetCookie(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
@@ -1363,18 +865,18 @@ TEST_F(CookieMonsterTest, DomainTest) {
   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(SetCookie(cm, url_google_, "E=F; domain=.www.google.izzle"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_, "G=H; domain=www.google.izzle"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_, "I=J; domain=.izzle"));
+  EXPECT_FALSE(cm->SetCookie(url_google_, "I=J; domain=.izzle"));
   EXPECT_EQ("", GetCookies(cm, GURL("http://a.izzle")));
-  EXPECT_FALSE(SetCookie(cm, url_google_, "K=L; domain=.bla.www.google.izzle"));
+  EXPECT_FALSE(cm->SetCookie(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_));
@@ -1389,8 +891,8 @@ TEST_F(CookieMonsterTest, DomainWithTrailingDotTest) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
-  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_FALSE(cm->SetCookie(url_google_, "a=1; domain=.www.google.com."));
+  EXPECT_FALSE(cm->SetCookie(url_google_, "b=2; domain=.www.google.com.."));
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Nothing was persisted to the backing store.
@@ -1408,10 +910,10 @@ TEST_F(CookieMonsterTest, ValidSubdomainTest) {
   GURL url_cd("http://c.d.com");
   GURL url_d("http://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_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_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));
@@ -1419,8 +921,8 @@ TEST_F(CookieMonsterTest, ValidSubdomainTest) {
   EXPECT_EQ("d=4", GetCookies(cm, url_d));
 
   // Check that the same cookie can exist on different sub-domains.
-  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_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_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));
 
@@ -1441,31 +943,31 @@ TEST_F(CookieMonsterTest, InvalidDomainTest) {
     GURL url_foobar("http://foo.bar.com");
 
     // More specific sub-domain than allowed.
-    EXPECT_FALSE(SetCookie(cm, url_foobar, "a=1; domain=.yo.foo.bar.com"));
+    EXPECT_FALSE(cm->SetCookie(url_foobar, "a=1; domain=.yo.foo.bar.com"));
 
-    EXPECT_FALSE(SetCookie(cm, url_foobar, "b=2; domain=.foo.com"));
-    EXPECT_FALSE(SetCookie(cm, url_foobar, "c=3; domain=.bar.foo.com"));
+    EXPECT_FALSE(cm->SetCookie(url_foobar, "b=2; domain=.foo.com"));
+    EXPECT_FALSE(cm->SetCookie(url_foobar, "c=3; domain=.bar.foo.com"));
 
     // Different TLD, but the rest is a substring.
-    EXPECT_FALSE(SetCookie(cm, url_foobar, "d=4; domain=.foo.bar.com.net"));
+    EXPECT_FALSE(cm->SetCookie(url_foobar, "d=4; domain=.foo.bar.com.net"));
 
     // A substring that isn't really a parent domain.
-    EXPECT_FALSE(SetCookie(cm, url_foobar, "e=5; domain=ar.com"));
+    EXPECT_FALSE(cm->SetCookie(url_foobar, "e=5; domain=ar.com"));
 
     // Completely invalid domains:
-    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"));
+    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"));
 
     // Make sure there isn't something quirky in the domain canonicalization
     // that supports full URL semantics.
-    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_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_EQ("", GetCookies(cm, url_foobar));
 
@@ -1479,7 +981,7 @@ TEST_F(CookieMonsterTest, InvalidDomainTest) {
     // hosts below have the same domain + registry.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url_foocom("http://foo.com.com");
-    EXPECT_FALSE(SetCookie(cm, url_foocom, "a=1; domain=.foo.com.com.com"));
+    EXPECT_FALSE(cm->SetCookie(url_foocom, "a=1; domain=.foo.com.com.com"));
     EXPECT_EQ("", GetCookies(cm, url_foocom));
   }
 }
@@ -1492,7 +994,7 @@ TEST_F(CookieMonsterTest, DomainWithoutLeadingDotTest) {
     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(SetCookie(cm, url_hosted, "sawAd=1; domain=filefront.com"));
+    EXPECT_TRUE(cm->SetCookie(url_hosted, "sawAd=1; domain=filefront.com"));
     EXPECT_EQ("sawAd=1", GetCookies(cm, url_hosted));
     EXPECT_EQ("sawAd=1", GetCookies(cm, url_filefront));
   }
@@ -1500,7 +1002,7 @@ TEST_F(CookieMonsterTest, DomainWithoutLeadingDotTest) {
   {  // 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(SetCookie(cm, url, "a=1; domain=www.google.com"));
+    EXPECT_TRUE(cm->SetCookie(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")));
@@ -1512,8 +1014,8 @@ TEST_F(CookieMonsterTest, DomainWithoutLeadingDotTest) {
 TEST_F(CookieMonsterTest, CaseInsensitiveDomainTest) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url("http://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_TRUE(cm->SetCookie(url, "a=1; domain=.GOOGLE.COM"));
+  EXPECT_TRUE(cm->SetCookie(url, "b=2; domain=.wWw.gOOgLE.coM"));
   EXPECT_EQ("a=1; b=2", GetCookies(cm, url));
 }
 
@@ -1521,20 +1023,20 @@ TEST_F(CookieMonsterTest, TestIpAddress) {
   GURL url_ip("http://1.2.3.4/weee");
   {
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-    EXPECT_TRUE(SetCookie(cm, url_ip, kValidCookieLine));
+    EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_ip, "b=2; domain=.1.2.3.4"));
-    EXPECT_FALSE(SetCookie(cm, url_ip, "c=3; domain=.3.4"));
+    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_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(SetCookie(cm, url_ip, "b=2; domain=1.2.3.3"));
+    EXPECT_FALSE(cm->SetCookie(url_ip, "b=2; domain=1.2.3.3"));
     EXPECT_EQ("", GetCookies(cm, url_ip));
-    EXPECT_TRUE(SetCookie(cm, url_ip, "b=2; domain=1.2.3.4"));
+    EXPECT_TRUE(cm->SetCookie(url_ip, "b=2; domain=1.2.3.4"));
     EXPECT_EQ("b=2", GetCookies(cm, url_ip));
   }
 }
@@ -1545,9 +1047,9 @@ TEST_F(CookieMonsterTest, TestNonDottedAndTLD) {
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://com/");
     // Allow setting on "com", (but only as a host cookie).
-    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_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_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.
@@ -1558,7 +1060,7 @@ TEST_F(CookieMonsterTest, TestNonDottedAndTLD) {
   {  // 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(SetCookie(cm, url, "a=1"));
+    EXPECT_TRUE(cm->SetCookie(url, "a=1"));
     EXPECT_EQ("a=1", GetCookies(cm, url));
     EXPECT_EQ("", GetCookies(cm, GURL("http://hopefully-no-cookies.com./")));
   }
@@ -1566,24 +1068,24 @@ TEST_F(CookieMonsterTest, TestNonDottedAndTLD) {
   {  // 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(SetCookie(cm, url, "a=1; domain=.b"));
-    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=b"));
+    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.b"));
+    EXPECT_FALSE(cm->SetCookie(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(SetCookie(cm, url, "a=1; domain=.com"));
-    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=com"));
+    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.com"));
+    EXPECT_FALSE(cm->SetCookie(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(SetCookie(cm, url, "a=1; domain=.co.uk"));
-    EXPECT_FALSE(SetCookie(cm, url, "b=2; domain=.uk"));
+    EXPECT_FALSE(cm->SetCookie(url, "a=1; domain=.co.uk"));
+    EXPECT_FALSE(cm->SetCookie(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")));
@@ -1592,9 +1094,9 @@ TEST_F(CookieMonsterTest, TestNonDottedAndTLD) {
   {  // Intranet URLs should only be able to set host cookies.
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     GURL url("http://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_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_EQ("a=1", GetCookies(cm, url));
   }
 }
@@ -1605,15 +1107,15 @@ TEST_F(CookieMonsterTest, TestHostEndsWithDot) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url("http://www.google.com");
   GURL url_with_dot("http://www.google.com.");
-  EXPECT_TRUE(SetCookie(cm, url, "a=1"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url, "b=2; domain=.www.google.com."));
+  EXPECT_FALSE(cm->SetCookie(url, "b=2; domain=.www.google.com."));
   EXPECT_EQ("a=1", GetCookies(cm, url));
 
-  EXPECT_TRUE(SetCookie(cm, url_with_dot, "b=2; domain=.google.com."));
+  EXPECT_TRUE(cm->SetCookie(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.
@@ -1623,19 +1125,19 @@ TEST_F(CookieMonsterTest, TestHostEndsWithDot) {
 
 TEST_F(CookieMonsterTest, InvalidScheme) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_FALSE(SetCookie(cm, GURL(kUrlFtp), kValidCookieLine));
+  EXPECT_FALSE(cm->SetCookie(GURL(kUrlFtp), kValidCookieLine));
 }
 
 TEST_F(CookieMonsterTest, InvalidScheme_Read) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, GURL(kUrlGoogle), kValidDomainCookieLine));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, GURL(url), "A=B; path=/wee"));
+  EXPECT_TRUE(cm->SetCookie(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")));
@@ -1644,7 +1146,7 @@ TEST_F(CookieMonsterTest, PathTest) {
   EXPECT_EQ("", GetCookies(cm, GURL(url + "/")));
 
   // If we add a 0 length path, it should default to /
-  EXPECT_TRUE(SetCookie(cm, GURL(url), "A=C; path="));
+  EXPECT_TRUE(cm->SetCookie(GURL(url), "A=C; path="));
   EXPECT_EQ("A=B; A=C", GetCookies(cm, GURL(url + "/wee")));
   EXPECT_EQ("A=C", GetCookies(cm, GURL(url + "/")));
 }
@@ -1662,14 +1164,14 @@ TEST_F(CookieMonsterTest, HttpOnlyTest) {
   EXPECT_EQ("A=B", GetCookiesWithOptions(cm, url_google_, options));
 
   // Check httponly overwrite protection.
-  EXPECT_FALSE(SetCookie(cm, url_google_, "A=C"));
+  EXPECT_FALSE(cm->SetCookie(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(SetCookie(cm, url_google_, "B=A; httponly"));
+  EXPECT_FALSE(cm->SetCookie(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));
@@ -1822,24 +1324,24 @@ TEST_F(CookieMonsterTest, TestCookieDeletion) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
 
   // Create a session cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  EXPECT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
+  EXPECT_TRUE(cm->SetCookie(url_google_,
                            std::string(kValidCookieLine) + "; max-age=0"));
   EXPECT_EQ("", GetCookies(cm, url_google_));
 
   // Create a session cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  EXPECT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Expires.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_,
+  EXPECT_TRUE(cm->SetCookie(url_google_,
                            std::string(kValidCookieLine) +
                            "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
@@ -1847,38 +1349,38 @@ TEST_F(CookieMonsterTest, TestCookieDeletion) {
 
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   // Delete it via Max-Age.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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_));
@@ -1891,25 +1393,25 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  EXPECT_TRUE(cm->SetCookie(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, DeleteAll(cm));
+  EXPECT_EQ(2, cm->DeleteAll(false));
   EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
 
   EXPECT_EQ(0u, store->commands().size());
 
   // Create a persistent cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        std::string(kValidCookieLine) +
-                        "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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, DeleteAll(cm));  // sync_to_store = true.
+  EXPECT_EQ(1, cm->DeleteAll(true));  // sync_to_store = true.
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
@@ -1922,56 +1424,59 @@ TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
 
   // Nothing has been added so nothing should be deleted.
   EXPECT_EQ(0, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time()));
+                                       Time(), false));
 
   // 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)));
+                                          now - TimeDelta::FromDays(1),
+                                          false));
 
   // Try to delete yesterday, also make sure that delete_end is not
   // inclusive.
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(2),
-                                       now));
+                                          now,
+                                          false));
 
   // Make sure the delete_begin is inclusive.
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(7),
-                                       now));
+                                          now,
+                                          false));
 
   // Delete the last (now) item.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time()));
+  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time(), false));
 
   // Really make sure everything is gone.
-  EXPECT_EQ(0, DeleteAll(cm));
+  EXPECT_EQ(0, cm->DeleteAll(false));
 }
 
 TEST_F(CookieMonsterTest, TestSecure) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_secure_));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_secure_, "A=B; secure"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_secure_, "D=E; secure"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google_secure_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(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_));
@@ -1983,7 +1488,7 @@ TEST_F(CookieMonsterTest, TestLastAccess) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   const Time last_access_date(GetFirstCookieAccessDate(cm));
 
   // Reading the cookie again immediately shouldn't update the access date,
@@ -2012,13 +1517,13 @@ TEST_F(CookieMonsterTest, NetUtilCookieTest) {
 
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm, test_url, "foo=bar"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, test_url, "x=1"));
-  EXPECT_TRUE(SetCookie(cm, test_url, "y=2"));
+  EXPECT_TRUE(cm->SetCookie(test_url, "x=1"));
+  EXPECT_TRUE(cm->SetCookie(test_url, "y=2"));
 
   std::string result = GetCookies(cm, test_url);
   EXPECT_FALSE(result.empty());
@@ -2029,9 +1534,9 @@ TEST_F(CookieMonsterTest, NetUtilCookieTest) {
 TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  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_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "C=D"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "E=F"));
   EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
 
   EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
@@ -2052,10 +1557,10 @@ TEST_F(CookieMonsterTest, SetCookieableSchemes) {
   GURL foo_url("foo://host/path");
   GURL http_url("http://host/path");
 
-  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"));
+  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"));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
@@ -2068,11 +1573,11 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
 
   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));
 
@@ -2130,11 +1635,14 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
   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();
@@ -2166,12 +1674,12 @@ TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
 TEST_F(CookieMonsterTest, DeleteCookieByName) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  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"));
+  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"));
 
   DeleteCookie(cm, GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
 
@@ -2234,15 +1742,15 @@ TEST_F(CookieMonsterTest, OverwritePersistentCookie) {
 
   // Insert a cookie "a" for path "/path1"
   EXPECT_TRUE(
-      SetCookie(cm, url_google, "a=val1; path=/path1; "
-                "expires=Mon, 18-Apr-22 22:50:13 GMT"));
+      cm->SetCookie(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(
-      SetCookie(cm, url_google, "b=val1; path=/path1; "
-                "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+      cm->SetCookie(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);
 
@@ -2252,35 +1760,35 @@ TEST_F(CookieMonsterTest, OverwritePersistentCookie) {
   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(SetCookie(cm, url_google,
-                        "a=val33; path=/path1; "
-                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_google,
-                        "a=val9; path=/path2; "
-                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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(SetCookie(cm, url_chromium,
-                        "a=val99; path=/path1; "
-                        "expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  EXPECT_TRUE(cm->SetCookie(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);
 
@@ -2421,9 +1929,9 @@ TEST_F(CookieMonsterTest, Delegate) {
       new MockCookieMonsterDelegate);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, delegate));
 
-  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_TRUE(cm->SetCookie(url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "C=D"));
+  EXPECT_TRUE(cm->SetCookie(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);
@@ -2455,7 +1963,7 @@ TEST_F(CookieMonsterTest, Delegate) {
 
   // Insert a cookie "a" for path "/path1"
   EXPECT_TRUE(
-      SetCookie(cm, url_google_, "a=val1; path=/path1; "
+      cm->SetCookie(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);
@@ -2472,9 +1980,9 @@ TEST_F(CookieMonsterTest, Delegate) {
   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);
@@ -2635,22 +2143,40 @@ TEST_F(CookieMonsterTest, UniqueCreationTime) {
   // are not included as they aren't going to be public for very much
   // longer.
 
-  // SetCookie, SetCookieWithOptions, SetCookieWithDetails
+  // SetCookie, SetCookies, SetCookiesWithOptions,
+  // SetCookieWithOptions, SetCookieWithDetails
 
-  SetCookie(cm, url_google_, "SetCookie1=A");
-  SetCookie(cm, url_google_, "SetCookie2=A");
-  SetCookie(cm, url_google_, "SetCookie3=A");
+  cm->SetCookie(url_google_, "SetCookie1=A");
+  cm->SetCookie(url_google_, "SetCookie2=A");
+  cm->SetCookie(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));
@@ -2737,9 +2263,9 @@ TEST_F(CookieMonsterTest, BackingStoreCommunication) {
     scoped_refptr<CookieMonster> cmout(new CookieMonster(store, NULL));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
-      EXPECT_TRUE(SetCookieWithDetails(cmout, GURL(p->gurl), p->name, p->value,
-                                       p->domain, p->path, p->expires,
-                                       p->secure, p->http_only));
+      EXPECT_TRUE(cmout->SetCookieWithDetails(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),
@@ -2778,26 +2304,26 @@ TEST_F(CookieMonsterTest, CookieOrdering) {
   // 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(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_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_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(GetAllCookiesForURL(
-        cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+    CookieList cookies(cm->GetAllCookiesForURL(
+        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());
@@ -2819,6 +2345,16 @@ TEST_F(CookieMonsterTest, CookieOrdering) {
   }
 }
 
+
+// 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
@@ -2832,7 +2368,7 @@ TEST_F(CookieMonsterTest, GarbageCollectionTriggers) {
     scoped_refptr<CookieMonster> cm(
         CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
     EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm).size());
-    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
+    cm->SetCookie(GURL("http://newdomain.com"), "b=2");
     EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, GetAllCookies(cm).size());
   }
 
@@ -2897,7 +2433,7 @@ TEST_F(CookieMonsterTest, GarbageCollectionTriggers) {
                 static_cast<int>(GetAllCookies(cm).size()))
           << "For test case " << ci;
       // Will trigger GC
-      SetCookie(cm, GURL("http://newdomain.com"), "b=2");
+      cm->SetCookie(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 << ")";
@@ -2913,8 +2449,7 @@ TEST_F(CookieMonsterTest, ForceSessionOnly) {
 
   // 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));
 
@@ -2924,8 +2459,7 @@ TEST_F(CookieMonsterTest, ForceSessionOnly) {
   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));
 
@@ -2941,8 +2475,7 @@ TEST_F(CookieMonsterTest, KeepExpiredCookies) {
   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));
 
@@ -2951,8 +2484,7 @@ TEST_F(CookieMonsterTest, KeepExpiredCookies) {
   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));
 
@@ -2970,9 +2502,7 @@ class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
-  bool Load(const LoadedCallback& loaded_callback) {
-    std::vector<CookieMonster::CanonicalCookie*> out_cookies;
-    loaded_callback.Run(out_cookies);
+  bool Load(std::vector<CookieMonster::CanonicalCookie*>*) {
     return false;
   }
 
@@ -3122,7 +2652,7 @@ TEST_F(CookieMonsterTest, HistogramCheck) {
             histogram_set_2.TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  ASSERT_TRUE(cm->SetCookie(url_google_, kValidCookieLine));
   expired_histogram->SnapshotSample(&histogram_set_1);
   EXPECT_EQ(histogram_set_2.TotalCount(),
             histogram_set_1.TotalCount());
@@ -3140,8 +2670,8 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
   void GetCookiesTask(CookieMonster* cm,
                       const GURL& url,
                       GetCookieStringCallback* callback) {
-    cm->GetCookiesWithOptionsAsync(
-        url, CookieOptions(),
+    cm->GetCookiesAsync(
+        url,
         base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
   }
 
@@ -3225,9 +2755,10 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
   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,
+        delete_begin, delete_end, sync_to_store,
         base::Bind(&DeleteCallback::Run,
                    base::Unretained(callback)));
   }
@@ -3267,7 +2798,7 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   GetCookieStringCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ -3282,7 +2813,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookies) {
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookiesWithOptions) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   EXPECT_EQ("A=B", GetCookiesWithOptions(cm, url_google_, options));
   GetCookieStringCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ -3299,7 +2830,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookiesWithInfo) {
   CookieOptions options;
   std::string cookie_line;
   std::vector<CookieStore::CookieInfo> cookie_infos;
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(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());
@@ -3322,7 +2853,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookiesWithInfo) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   CookieList cookies = GetAllCookies(cm);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
@@ -3345,7 +2876,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   CookieList cookies = GetAllCookiesForURL(cm, url_google_);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
@@ -3368,7 +2899,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(cm->SetCookie(url_google_, "A=B"));
   CookieOptions options;
   CookieList cookies =
       GetAllCookiesForURLWithOptions(cm, url_google_, options);
@@ -3442,14 +2973,14 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   Time now = Time::Now();
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
-                                       Time()));
+                                       Time(), false));
   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(), &callback);
+      Time(), false, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.num_deleted());