Remove the old synchronous CookieMonster API.

net/base/cookie_monster_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <time.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 481 matching lines @@
         url_google_bar_(kUrlGoogleBar),
         message_loop_factory_(MessageLoop::current()) {}
 
   // Helper methods for the asynchronous Cookie Store API that call the
   // asynchronous method and then pump the loop until the callback is invoked,
   // finally returning the value.
 
   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();
   }
 
   std::string GetCookiesWithOptions(CookieMonster* cm,
                                     const GURL& url,
                                     const CookieOptions& options) {
     DCHECK(cm);
     GetCookieStringCallback callback;
@@ skipping 67 matching lines @@
     DCHECK(cm);
     SetCookieCallback callback;
     cm->SetCookieWithOptionsAsync(
         url, cookie_line, options,
         base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     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,
                             const std::string& value,
                             const std::string& domain,
                             const std::string& path,
                             const base::Time& expiration_time,
                             bool secure, bool http_only) {
     DCHECK(cm);
     SetCookieCallback callback;
@@ skipping 10 matching lines @@
                     const std::string& cookie_name) {
     DCHECK(cm);
     DeleteCookieCallback callback;
     cm->DeleteCookieAsync(url, cookie_name,
                           base::Bind(&DeleteCookieCallback::Run,
                                      base::Unretained(&callback)));
     RunFor(kTimeout);
     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());
     return callback.num_deleted();
   }
 
   int DeleteAllForHost(CookieMonster*cm,
                        const GURL& url) {
     DCHECK(cm);
     DeleteCallback callback;
@@ skipping 28 matching lines @@
 
   // Helper for DeleteAllForHost test; repopulates CM with same layout
   // each time.
   void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) {
     GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
     GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
     GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
     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)
     //    * Three levels of host cookie (w.b.a, w.c.b.a, w.d.c.b.a)
     //    * http_only cookie (w.c.b.a)
     //    * Two secure cookies (.c.b.a, w.c.b.a)
     //    * Two domain path cookies (.c.b.a/dir1, .c.b.a/dir1/dir2)
     //    * Two host path cookies (w.c.b.a/dir1, w.c.b.a/dir1/dir2)
 
     // Domain cookies
@@ skipping 82 matching lines @@
       int domain_purge_cookies,
       CookieMonster::ExpiryAndKeyScheme key_scheme) {
     const int more_than_enough_cookies =
         (domain_max_cookies + domain_purge_cookies) * 2;
     // Add a bunch of cookies on a single host, should purge them.
     {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       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);
         // Count the number of cookies.
         EXPECT_LE(CountInString(cookies, '='), domain_max_cookies);
       }
     }
 
     // Add a bunch of cookies on multiple hosts within a single eTLD.
     // Should keep at least kDomainMaxCookies - kDomainPurgeCookies
     // between them.  If we are using the effective domain keying system
     // (EKS_KEEP_RECENT_AND_PURGE_ETLDP1) we shouldn't go above
     // kDomainMaxCookies for both together.  If we're using the domain
     // keying system (EKS_DISCARD_RECENT_AND_PURGE_DOMAIN), each
     // individual domain shouldn't go above kDomainMaxCookies.
     GURL url_google_specific(kUrlGoogleSpecific);
     {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       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 =
             this->GetCookies(cm, url_google_specific);
         EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
         if (key_scheme == CookieMonster::EKS_KEEP_RECENT_AND_PURGE_ETLDP1) {
           EXPECT_LE((CountInString(cookies_general, '=') +
                      CountInString(cookies_specific, '=')),
                     domain_max_cookies);
         } else {
@@ skipping 17 matching lines @@
         EXPECT_GE(general_cookies,
                   domain_max_cookies - domain_purge_cookies);
         EXPECT_LE(general_cookies, domain_max_cookies);
         EXPECT_GE(specific_cookies,
                   domain_max_cookies - domain_purge_cookies);
         EXPECT_LE(specific_cookies, domain_max_cookies);
       }
     }
   }
 
+  // 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_;
   GURL url_google_foo_;
   GURL url_google_bar_;
 
   ScopedRunnableMethodFactory<MessageLoop> message_loop_factory_;
 };
 
 }  // namespace
 
 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
   // cookie -- should not be accessible from a sub sub-domain.
   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_));
 
   // Nothing was persisted to the backing store.
   EXPECT_EQ(0u, store->commands().size());
 }
 
 // FireFox recognizes domains containing trailing periods as valid.
 // IE and Safari do not. Assert the expected policy here.
 TEST_F(CookieMonsterTest, DomainWithTrailingDotTest) {
   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.
   EXPECT_EQ(0u, store->commands().size());
 }
 
 // Test that cookies can bet set on higher level domains.
 // http://b/issue?id=896491
 TEST_F(CookieMonsterTest, ValidSubdomainTest) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
   GURL url_abcd("http://a.b.c.d.com");
   GURL url_bcd("http://b.c.d.com");
   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));
   EXPECT_EQ("c=3; d=4", GetCookies(cm, url_cd));
   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));
 
   // Nothing was persisted to the backing store.
   EXPECT_EQ(0u, store->commands().size());
 }
 
 // Test that setting a cookie which specifies an invalid domain has
 // no side-effect. An invalid domain in this context is one which does
 // not match the originating domain.
 // http://b/issue?id=896472
 TEST_F(CookieMonsterTest, InvalidDomainTest) {
   {
     scoped_refptr<MockPersistentCookieStore> store(
         new MockPersistentCookieStore);
 
     scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
     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));
 
     // Nothing was persisted to the backing store.
     EXPECT_EQ(0u, store->commands().size());
   }
 
   {
     // Make sure the cookie code hasn't gotten its subdomain string handling
     // reversed, missed a suffix check, etc.  It's important here that the two
     // 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));
   }
 }
 
 // Test the behavior of omitting dot prefix from domain, should
 // function the same as FireFox.
 // http://b/issue?id=889898
 TEST_F(CookieMonsterTest, DomainWithoutLeadingDotTest) {
   {  // The omission of dot results in setting a domain cookie.
     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));
   }
 
   {  // 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")));
   }
 }
 
 // Test that the domain specified in cookie string is treated case-insensitive
 // http://b/issue?id=896475.
 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));
 }
 
 TEST_F(CookieMonsterTest, TestIpAddress) {
   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));
   }
 }
 
 // Test host cookies, and setting of cookies on TLD.
 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(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.
     EXPECT_EQ("", GetCookies(cm, GURL("http://hopefully-no-cookies.com/")));
     EXPECT_EQ("", GetCookies(cm, GURL("http://.com/")));
   }
 
   {  // 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./")));
   }
 
   {  // 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")));
   }
 
   {  // 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));
   }
 }
 
 // Test reading/writing cookies when the domain ends with a period,
 // as in "www.google.com."
 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(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.
   EXPECT_EQ(GetCookies(cm, GURL("http://hopefully-no-cookies.com/")), "");
   EXPECT_EQ("", GetCookies(cm, GURL("http://.com/")));
 }
 
 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")));
   EXPECT_EQ("A=B", GetCookies(cm, GURL(url + "/wee/war/more/more")));
   EXPECT_EQ("", GetCookies(cm, GURL(url + "/weehee")));
   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 + "/")));
 }
 
 TEST_F(CookieMonsterTest, HttpOnlyTest) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   options.set_include_httponly();
 
   // Create a httponly cookie.
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B; httponly", options));
 
   // Check httponly read protection.
   EXPECT_EQ("", GetCookies(cm, url_google_));
   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));
   EXPECT_EQ("A=C", GetCookies(cm, url_google_));
 }
 
 TEST_F(CookieMonsterTest, GetCookiesWithInfo) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
@@ skipping 132 matching lines @@
               CookieMonster::DomainIsHostOnly(tests[i].str));
   }
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeletion) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   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());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
 
   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_));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
   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);
 
   EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   Time now = Time::Now();
 
   // 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_));
 }
 
 static const int kLastAccessThresholdMilliseconds = 200;
 
 TEST_F(CookieMonsterTest, TestLastAccess) {
   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,
   // since we're inside the threshold.
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
 
   // Reading after a short wait should update the access date.
   base::PlatformThread::Sleep(kLastAccessThresholdMilliseconds + 20);
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
   EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm));
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
   TestHostGarbageCollectHelper(
       CookieMonster::kDomainMaxCookies, CookieMonster::kDomainPurgeCookies,
       CookieMonster::EKS_KEEP_RECENT_AND_PURGE_ETLDP1);
   TestHostGarbageCollectHelper(
       CookieMonster::kDomainMaxCookies, CookieMonster::kDomainPurgeCookies,
       CookieMonster::EKS_DISCARD_RECENT_AND_PURGE_DOMAIN);
 }
 
 // Formerly NetUtilTest.CookieTest back when we used wininet's cookie handling.
 TEST_F(CookieMonsterTest, NetUtilCookieTest) {
   const GURL test_url("http://mojo.jojo.google.izzle/");
 
   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());
   EXPECT_NE(result.find("x=1"), std::string::npos) << result;
   EXPECT_NE(result.find("y=2"), std::string::npos) << result;
 }
 
 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"));
   EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
 
   EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
   EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
 }
 
 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   scoped_refptr<CookieMonster> cm_foo(new CookieMonster(NULL, NULL));
 
   // Only cm_foo should allow foo:// cookies.
   const char* kSchemes[] = {"foo"};
   cm_foo->SetCookieableSchemes(kSchemes, 1);
 
   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) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
   // Create an httponly cookie.
   CookieOptions options;
   options.set_include_httponly();
 
   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));
 
   base::PlatformThread::Sleep(kLastAccessThresholdMilliseconds + 20);
 
   // Check cookies for url.
   CookieList cookies = GetAllCookiesForURL(cm, url_google_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
@@ skipping 37 matching lines @@
 
   // Reading after a short wait should not update the access date.
   EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   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();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("/foo", it->Path());
 
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ("E", it->Name());
@@ skipping 11 matching lines @@
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("/", it->Path());
 
   ASSERT_TRUE(++it == cookies.end());
 }
 
 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");
 
   CookieList cookies = GetAllCookies(cm);
   size_t expected_size = 4;
   EXPECT_EQ(expected_size, cookies.size());
   for (CookieList::iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     EXPECT_NE("A1", it->Value());
     EXPECT_NE("A2", it->Value());
   }
 }
 
 TEST_F(CookieMonsterTest, InitializeFromCookieMonster) {
   scoped_refptr<CookieMonster> cm_1(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
   EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_foo_,
-                                               "A1=B; path=/foo;",
-                                               options));
+                                   "A1=B; path=/foo;", options));
   EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_bar_,
-                                               "A2=D; path=/bar;",
-                                               options));
+                                   "A2=D; path=/bar;", options));
   EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_,
-                                               "A3=F;",
-                                               options));
+                                   "A3=F;", options));
 
+  CookieList cookies_1 = GetAllCookies(cm_1);
   scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL));
-  ASSERT_TRUE(cm_2->InitializeFrom(cm_1.get()));
-  CookieList cookies = cm_2->GetAllCookies();
+  ASSERT_TRUE(cm_2->InitializeFrom(cookies_1));
+  CookieList cookies_2 = GetAllCookies(cm_2);
 
   size_t expected_size = 3;
-  EXPECT_EQ(expected_size, cookies.size());
+  EXPECT_EQ(expected_size, cookies_2.size());
 
-  CookieList::iterator it = cookies.begin();
+  CookieList::iterator it = cookies_2.begin();
 
-  ASSERT_TRUE(it != cookies.end());
+  ASSERT_TRUE(it != cookies_2.end());
   EXPECT_EQ("A1", it->Name());
   EXPECT_EQ("/foo", it->Path());
 
-  ASSERT_TRUE(++it != cookies.end());
+  ASSERT_TRUE(++it != cookies_2.end());
   EXPECT_EQ("A2", it->Name());
   EXPECT_EQ("/bar", it->Path());
 
-  ASSERT_TRUE(++it != cookies.end());
+  ASSERT_TRUE(++it != cookies_2.end());
   EXPECT_EQ("A3", it->Name());
   EXPECT_EQ("/", it->Path());
 }
 
 
 // Test that overwriting persistent cookies deletes the old one from the
 // backing store.
 TEST_F(CookieMonsterTest, OverwritePersistentCookie) {
   GURL url_google("http://www.google.com/");
   GURL url_chromium("http://chromium.org");
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
 
   // 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);
 
   // Insert a cookie "b" for path "/path1", that is httponly. This should
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   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);
 
   EXPECT_EQ("a=val33", GetCookies(cm, GURL("http://www.google.com/path1")));
   EXPECT_EQ("a=val9", GetCookies(cm, GURL("http://www.google.com/path2")));
   EXPECT_EQ("a=val99", GetCookies(cm, GURL("http://chromium.org/path1")));
 }
 
 // Tests importing from a persistent cookie store that contains duplicate
 // equivalent cookies. This situation should be handled by removing the
@@ skipping 120 matching lines @@
   EXPECT_NE(name1, name2);
 }
 
 TEST_F(CookieMonsterTest, Delegate) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<MockCookieMonsterDelegate> delegate(
       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);
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_EQ("A", delegate->changes()[0].first.Name());
   EXPECT_EQ("B", delegate->changes()[0].first.Value());
   EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
   EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("C", delegate->changes()[1].first.Name());
   EXPECT_EQ("D", delegate->changes()[1].first.Value());
@@ skipping 11 matching lines @@
   EXPECT_EQ("C", delegate->changes()[0].first.Name());
   EXPECT_EQ("D", delegate->changes()[0].first.Value());
   delegate->reset();
 
   EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
   EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // 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);
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   delegate->reset();
 
   // Insert a cookie "a" for path "/path1", that is httponly. This should
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   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);
   ASSERT_EQ(2u, delegate->changes().size());
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
   EXPECT_FALSE(delegate->changes()[1].second);
@@ skipping 140 matching lines @@
   CookieOptions options;
 
   // Add in three cookies through every public interface to the
   // CookieMonster and confirm that none of them have duplicate
   // creation times.
 
   // SetCookieWithCreationTime and SetCookieWithCreationTimeAndOptions
   // 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");
-
-  {
-    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);
-  }
+  SetCookie(cm, url_google_, "SetCookie1=A");
+  SetCookie(cm, url_google_, "SetCookie2=A");
+  SetCookie(cm, url_google_, "SetCookie3=A");
 
   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));
   typedef std::map<int64, CookieMonster::CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (CookieList::const_iterator it = cookie_list.begin();
        it != cookie_list.end(); it++) {
     const int64 creation_date = it->CreationDate().ToInternalValue();
     TimeCookieMap::const_iterator
         existing_cookie_it(check_map.find(creation_date));
@@ skipping 66 matching lines @@
      base::Time::Now() + base::TimeDelta::FromSeconds(100),
      true, false}
   };
   const int INPUT_DELETE = 1;
 
   // Create new cookies and flush them to the store.
   {
     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),
                  input_info[INPUT_DELETE].name);
   }
 
   // Create a new cookie monster and make sure that everything is correct
   {
     scoped_refptr<CookieMonster> cmin(new CookieMonster(store, NULL));
     CookieList cookies(GetAllCookies(cmin));
@@ skipping 18 matching lines @@
       EXPECT_EQ(input->expires.ToInternalValue(),
                 output->ExpiryDate().ToInternalValue());
     }
   }
 }
 
 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(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());
     EXPECT_EQ("e", cookies[i++].Name());
     EXPECT_EQ("b", cookies[i++].Name());
     EXPECT_EQ("c", cookies[i++].Name());
   }
 
   {
     unsigned int i = 0;
     CookieList cookies(GetAllCookies(cm));
     ASSERT_EQ(6u, cookies.size());
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
     EXPECT_EQ("e", cookies[i++].Name());
     EXPECT_EQ("g", cookies[i++].Name());
     EXPECT_EQ("b", cookies[i++].Name());
     EXPECT_EQ("c", cookies[i++].Name());
   }
 }
 
-
-// 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
 // get rid of cookies when we should).  The perftest is probing for
 // whether garbage collection happens when it shouldn't.  See comments
 // before that test for more details.
 TEST_F(CookieMonsterTest, GarbageCollectionTriggers) {
   // First we check to make sure that a whole lot of recent cookies
   // doesn't get rid of anything after garbage collection is checked for.
   {
     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());
   }
 
   // Now we explore a series of relationships between cookie last access
   // time and size of store to make sure we only get rid of cookies when
   // we really should.
   const struct TestCase {
     int num_cookies;
     int num_old_cookies;
     int expected_initial_cookies;
@@ skipping 44 matching lines @@
       const TestCase *test_case = &test_cases[ci];
       scoped_refptr<CookieMonster> cm(
           CreateMonsterFromStoreForGC(
               test_case->num_cookies, test_case->num_old_cookies,
               CookieMonster::kSafeFromGlobalPurgeDays * 2));
       cm->SetExpiryAndKeyScheme(schemes[recent_scheme]);
       EXPECT_EQ(test_case->expected_initial_cookies,
                 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 << ")";
     }
   }
 }
 
 // This test checks that setting a cookie forcing it to be a session only
 // cookie works as expected.
 TEST_F(CookieMonsterTest, ForceSessionOnly) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
   // 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));
 
   // Get the canonical cookie.
   CookieList cookie_list = GetAllCookies(cm);
   ASSERT_EQ(1U, cookie_list.size());
   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));
 
   // Check that the cookie was deleted.
   cookie_list = GetAllCookies(cm);
   ASSERT_EQ(0U, cookie_list.size());
 }
 
 // This test checks that keep expired cookies flag is working.
 TEST_F(CookieMonsterTest, KeepExpiredCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   cm->SetKeepExpiredCookies();
   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));
 
   // Get the canonical cookie.
   CookieList cookie_list = GetAllCookies(cm);
   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));
 
   // Check that the cookie with the past expiry date is still there.
   // GetAllCookies() also triggers garbage collection.
   cookie_list = GetAllCookies(cm);
   ASSERT_EQ(1U, cookie_list.size());
   ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now()));
 }
 
 namespace {
 
 // Mock PersistentCookieStore that keeps track of the number of Flush() calls.
 class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
  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;
   }
 
   void AddCookie(const CookieMonster::CanonicalCookie&) {}
   void UpdateCookieAccessTime(const CookieMonster::CanonicalCookie&) {}
   void DeleteCookie(const CookieMonster::CanonicalCookie&) {}
   void SetClearLocalStateOnExit(bool clear_local_state) {}
 
   void Flush(Task* completion_callback) {
     ++flush_count_;
@@ skipping 129 matching lines @@
       cm, GURL("http://fake.a.url"), "a", "b", "a.url", "/",
       base::Time::Now() + base::TimeDelta::FromMinutes(59),
       false, false));
 
   base::Histogram::SampleSet histogram_set_2;
   expired_histogram->SnapshotSample(&histogram_set_2);
   EXPECT_EQ(histogram_set_1.TotalCount() + 1,
             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());
 }
 
 namespace {
 
 class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
  public:
   MultiThreadedCookieMonsterTest() : other_thread_("CMTthread") {}
 
   // Helper methods for calling the asynchronous CookieMonster methods
   // from a different thread.
 
   void GetCookiesTask(CookieMonster* cm,
                       const GURL& url,
                       GetCookieStringCallback* callback) {
-    cm->GetCookiesAsync(
-        url,
+    cm->GetCookiesWithOptionsAsync(
+        url, CookieOptions(),
         base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
   }
 
   void GetCookiesWithOptionsTask(CookieMonster* cm,
                                  const GURL& url,
                                  const CookieOptions& options,
                                  GetCookieStringCallback* callback) {
     cm->GetCookiesWithOptionsAsync(
         url, options,
         base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
@@ skipping 63 matching lines @@
                         const std::string& cookie_name,
                         DeleteCookieCallback* callback) {
     cm->DeleteCookieAsync(
         url, cookie_name,
         base::Bind(&DeleteCookieCallback::Run, base::Unretained(callback)));
   }
 
   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)));
   }
 
   void DeleteAllForHostTask(CookieMonster* cm,
                             const GURL& url,
                             DeleteCallback* callback) {
     cm->DeleteAllForHostAsync(
         url,
         base::Bind(&DeleteCallback::Run, base::Unretained(callback)));
@@ skipping 19 matching lines @@
 };
 
 }  // namespace
 
 // TODO(ycxiao): Eventually, we will need to create a separate thread, create
 // the cookie monster on that thread (or at least its store, i.e., the DB
 // thread).
 
 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(
       &net::MultiThreadedCookieMonsterTest::GetCookiesTask,
       base::Unretained(this),
       cm, url_google_, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.cookie());
 }
 
 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(
       &net::MultiThreadedCookieMonsterTest::GetCookiesWithOptionsTask,
       base::Unretained(this),
       cm, url_google_, options, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.cookie());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetCookiesWithInfo) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   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());
   EXPECT_EQ("A", cookie_infos[0].name);
   EXPECT_EQ("", cookie_infos[0].mac_key);
   EXPECT_EQ("", cookie_infos[0].mac_algorithm);
   GetCookiesWithInfoCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&net::MultiThreadedCookieMonsterTest::GetCookiesWithInfoTask,
                  base::Unretained(this),
                  cm, url_google_, options, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.cookie_line());
   EXPECT_EQ(1U, callback.cookie_info().size());
   EXPECT_EQ("A", callback.cookie_info()[0].name);
   EXPECT_EQ("", callback.cookie_info()[0].mac_key);
   EXPECT_EQ("", callback.cookie_info()[0].mac_algorithm);
 }
 
 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());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesTask,
                  base::Unretained(this),
                  cm, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 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());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLTask,
                  base::Unretained(this),
                  cm, url_google_, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 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);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ skipping 53 matching lines @@
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   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());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
   EXPECT_EQ(1, DeleteAllForHost(cm, url_google_));
@@ skipping 23 matching lines @@
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
       base::Unretained(this),
       cm, *it, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 }  // namespace net