Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/cookies/cookie_monster_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cookies/cookie_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 204 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);
 
-    DeleteAll(cm);
+    DeleteAll(cm.get());
 
     // 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
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_1,
-                                           "dom_1", "X", ".harvard.edu", "/",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_1,
+                                           "dom_1",
+                                           "X",
+                                           ".harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_2", "X", ".math.harvard.edu",
-                                           "/", base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_2",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_3,
-                                           "dom_3", "X",
-                                           ".bourbaki.math.harvard.edu", "/",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_3,
+                                           "dom_3",
+                                           "X",
+                                           ".bourbaki.math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Host cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_1,
                                            "host_1",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_2",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_3,
                                            "host_3",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Http_only cookie
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "httpo_check",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
                                            true,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Secure cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2_secure,
-                                           "sec_dom", "X", ".math.harvard.edu",
-                                           "/", base::Time(), true, false,
+                                           "sec_dom",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/",
+                                           base::Time(),
+                                           true,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2_secure,
                                            "sec_host",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            true,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Domain path cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_path_1", "X",
-                                           ".math.harvard.edu", "/dir1",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_path_1",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/dir1",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2,
-                                           "dom_path_2", "X",
-                                           ".math.harvard.edu", "/dir1/dir2",
-                                           base::Time(), false, false,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
+                                           url_top_level_domain_plus_2,
+                                           "dom_path_2",
+                                           "X",
+                                           ".math.harvard.edu",
+                                           "/dir1/dir2",
+                                           base::Time(),
+                                           false,
+                                           false,
                                            COOKIE_PRIORITY_DEFAULT));
 
     // Host path cookies
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_path_1",
                                            "X",
                                            std::string(),
                                            "/dir1",
                                            base::Time(),
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
-    EXPECT_TRUE(this->SetCookieWithDetails(cm,
+    EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
                                            url_top_level_domain_plus_2,
                                            "host_path_2",
                                            "X",
                                            std::string(),
                                            "/dir1/dir2",
                                            base::Time(),
                                            false,
                                            false,
                                            COOKIE_PRIORITY_DEFAULT));
 
-    EXPECT_EQ(13U, this->GetAllCookies(cm).size());
+    EXPECT_EQ(13U, this->GetAllCookies(cm.get()).size());
   }
 
   Time GetFirstCookieAccessDate(CookieMonster* cm) {
     const CookieList all_cookies(this->GetAllCookies(cm));
     return all_cookies.front().LastAccessDate();
   }
 
   bool FindAndDeleteCookie(CookieMonster* cm,
                            const std::string& domain,
                            const std::string& name) {
@@ skipping 12 matching lines @@
   void TestHostGarbageCollectHelper() {
     int domain_max_cookies = CookieMonster::kDomainMaxCookies;
     int domain_purge_cookies = CookieMonster::kDomainPurgeCookies;
     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));
       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));
-        std::string cookies = this->GetCookies(cm, url_google_);
+        EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie));
+        std::string cookies = this->GetCookies(cm.get(), 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.  We shouldn't go above kDomainMaxCookies for both together.
     GURL url_google_specific(kUrlGoogleSpecific);
     {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       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(SetCookie(cm.get(), url_google_, cookie_general));
         std::string cookie_specific = base::StringPrintf("c%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm, url_google_specific, cookie_specific));
-        std::string cookies_general = this->GetCookies(cm, url_google_);
+        EXPECT_TRUE(SetCookie(cm.get(), url_google_specific, cookie_specific));
+        std::string cookies_general = this->GetCookies(cm.get(), url_google_);
         EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
         std::string cookies_specific =
-            this->GetCookies(cm, url_google_specific);
+            this->GetCookies(cm.get(), url_google_specific);
         EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
         EXPECT_LE((CountInString(cookies_general, '=') +
                    CountInString(cookies_specific, '=')),
                   domain_max_cookies);
       }
       // After all this, there should be at least
       // kDomainMaxCookies - kDomainPurgeCookies for both URLs.
-      std::string cookies_general = this->GetCookies(cm, url_google_);
-      std::string cookies_specific = this->GetCookies(cm, url_google_specific);
+      std::string cookies_general = this->GetCookies(cm.get(), url_google_);
+      std::string cookies_specific =
+          this->GetCookies(cm.get(), url_google_specific);
       int total_cookies = (CountInString(cookies_general, '=') +
                            CountInString(cookies_specific, '='));
       EXPECT_GE(total_cookies, domain_max_cookies - domain_purge_cookies);
       EXPECT_LE(total_cookies, domain_max_cookies);
     }
   }
 
   CookiePriority CharToPriority(char ch) {
     switch (ch) {
       case 'L':
@@ skipping 99 matching lines @@
               CookieMonster::kDomainPurgeCookies);
     DCHECK_EQ(30U, CookieMonster::kDomainCookiesQuotaLow);
     DCHECK_EQ(50U, CookieMonster::kDomainCookiesQuotaMedium);
     DCHECK_EQ(70U, CookieMonster::kDomainCookiesQuotaHigh);
 
     scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
     cm->SetPriorityAwareGarbageCollection(true);
 
     // Each test case adds 181 cookies, so 31 cookies are evicted.
     // Cookie same priority, repeated for each priority.
-    TestPriorityCookieCase(cm, "181L", 150U, 0U, 0U);
-    TestPriorityCookieCase(cm, "181M", 0U, 150U, 0U);
-    TestPriorityCookieCase(cm, "181H", 0U, 0U, 150U);
+    TestPriorityCookieCase(cm.get(), "181L", 150U, 0U, 0U);
+    TestPriorityCookieCase(cm.get(), "181M", 0U, 150U, 0U);
+    TestPriorityCookieCase(cm.get(), "181H", 0U, 0U, 150U);
 
     // Pairwise scenarios.
     // Round 1 => none; round2 => 31M; round 3 => none.
-    TestPriorityCookieCase(cm, "10H 171M", 0U, 140U, 10U);
+    TestPriorityCookieCase(cm.get(), "10H 171M", 0U, 140U, 10U);
     // Round 1 => 10L; round2 => 21M; round 3 => none.
-    TestPriorityCookieCase(cm, "141M 40L", 30U, 120U, 0U);
+    TestPriorityCookieCase(cm.get(), "141M 40L", 30U, 120U, 0U);
     // Round 1 => none; round2 => none; round 3 => 31H.
-    TestPriorityCookieCase(cm, "101H 80M", 0U, 80U, 70U);
+    TestPriorityCookieCase(cm.get(), "101H 80M", 0U, 80U, 70U);
 
     // For {low, medium} priorities right on quota, different orders.
     // Round 1 => 1L; round 2 => none, round3 => 30L.
-    TestPriorityCookieCase(cm, "31L 50M 100H", 0U, 50U, 100U);
+    TestPriorityCookieCase(cm.get(), "31L 50M 100H", 0U, 50U, 100U);
     // Round 1 => none; round 2 => 1M, round3 => 30M.
-    TestPriorityCookieCase(cm, "51M 100H 30L", 30U, 20U, 100U);
+    TestPriorityCookieCase(cm.get(), "51M 100H 30L", 30U, 20U, 100U);
     // Round 1 => none; round 2 => none; round3 => 31H.
-    TestPriorityCookieCase(cm, "101H 50M 30L", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "101H 50M 30L", 30U, 50U, 70U);
 
     // Round 1 => 10L; round 2 => 10M; round3 => 11H.
-    TestPriorityCookieCase(cm, "81H 60M 40L", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "81H 60M 40L", 30U, 50U, 70U);
 
     // More complex scenarios.
     // Round 1 => 10L; round 2 => 10M; round 3 => 11H.
-    TestPriorityCookieCase(cm, "21H 60M 40L 60H", 30U, 50U, 70U);
+    TestPriorityCookieCase(cm.get(), "21H 60M 40L 60H", 30U, 50U, 70U);
     // Round 1 => 10L; round 2 => 11M, 10L; round 3 => none.
-    TestPriorityCookieCase(cm, "11H 10M 20L 110M 20L 10H", 20U, 109U, 21U);
+    TestPriorityCookieCase(
+        cm.get(), "11H 10M 20L 110M 20L 10H", 20U, 109U, 21U);
     // Round 1 => none; round 2 => none; round 3 => 11L, 10M, 10H.
-    TestPriorityCookieCase(cm, "11L 10M 140H 10M 10L", 10U, 10U, 130U);
+    TestPriorityCookieCase(cm.get(), "11L 10M 140H 10M 10L", 10U, 10U, 130U);
     // Round 1 => none; round 2 => 1M; round 3 => 10L, 10M, 10H.
-    TestPriorityCookieCase(cm, "11M 10H 10L 60M 90H", 0U, 60U, 90U);
+    TestPriorityCookieCase(cm.get(), "11M 10H 10L 60M 90H", 0U, 60U, 90U);
     // Round 1 => none; round 2 => 10L, 21M; round 3 => none.
-    TestPriorityCookieCase(cm, "11M 10H 10L 90M 60H", 0U, 80U, 70U);
+    TestPriorityCookieCase(cm.get(), "11M 10H 10L 90M 60H", 0U, 80U, 70U);
   }
 
   // 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(base::StringPrintf("http://h%05d.izzle", i)), "a=1");
     }
     return cm;
@@ skipping 184 matching lines @@
                              testing::Action<void(void)> action) {
     EXPECT_CALL(*this, Begin()).WillOnce(action);
     ExpectLoadCall();
     ExpectLoadForKeyCall(key, false);
     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()));
+    EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
+        .WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
+                                 QuitCurrentMessageLoop()));
   }
 
   // Declares an expectation that PersistentCookieStore::LoadCookiesForKey
   // will be called, saving the provided callback and sending a quit to the
   // message loop.
   void ExpectLoadForKeyCall(std::string key, bool quit_queue) {
     if (quit_queue)
-      EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)).
-          WillOnce(testing::DoAll(
-                   PushCallbackAction(&loaded_for_key_callbacks_),
-                   QuitCurrentMessageLoop()));
+      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
+          .WillOnce(
+               testing::DoAll(PushCallbackAction(&loaded_for_key_callbacks_),
+                              QuitCurrentMessageLoop()));
     else
-      EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)).
-          WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
+      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
+          .WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
   }
 
   // Invokes the initial action.
   MOCK_METHOD0(Begin, void(void));
 
   // Returns the CookieMonster instance under test.
-  CookieMonster& cookie_monster() { return *cookie_monster_; }
+  CookieMonster& cookie_monster() { return *cookie_monster_.get(); }
 
  private:
   // Declares that mock expectations in this test suite are strictly ordered.
   testing::InSequence in_sequence_;
   // Holds cookies to be returned from PersistentCookieStore::Load or
   // PersistentCookieStore::LoadCookiesForKey.
   std::vector<CanonicalCookie*> loaded_cookies_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::Load
   CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
@@ skipping 269 matching lines @@
       QuitCurrentMessageLoop());
   EXPECT_CALL(set_cookies_callback, Invoke(true));
   EXPECT_CALL(delete_cookie_callback, Invoke());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "C=D; httponly", options));
-  EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm, url_google_, options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), url_google_, "C=D; httponly", options));
+  EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm.get(), url_google_, options));
 
-  EXPECT_EQ(2, DeleteAll(cm));
-  EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options));
+  EXPECT_EQ(2, DeleteAll(cm.get()));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), 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(SetCookie(
+      cm.get(),
+      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, DeleteAll(cm.get()));  // 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));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), 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()));
+  EXPECT_EQ(
+      0,
+      DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), 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)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-2=DayBefore",
                                             now - TimeDelta::FromDays(2)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-3=ThreeDays",
                                             now - TimeDelta::FromDays(3)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-7=LastWeek",
                                             now - TimeDelta::FromDays(7)));
 
   // Try to delete threedays and the daybefore.
-  EXPECT_EQ(2, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(3),
-                                       now - TimeDelta::FromDays(1)));
+  EXPECT_EQ(2,
+            DeleteAllCreatedBetween(cm.get(),
+                                    now - TimeDelta::FromDays(3),
+                                    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));
+  EXPECT_EQ(
+      1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(2), now));
 
   // Make sure the delete_begin is inclusive.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(7),
-                                       now));
+  EXPECT_EQ(
+      1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
 
   // Delete the last (now) item.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time()));
+  EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
 
   // Really make sure everything is gone.
-  EXPECT_EQ(0, DeleteAll(cm));
+  EXPECT_EQ(0, DeleteAll(cm.get()));
 }
 
 static const int kAccessDelayMs = kLastAccessThresholdMilliseconds + 20;
 
 TEST_F(CookieMonsterTest, TestLastAccess) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  const Time last_access_date(GetFirstCookieAccessDate(cm));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   // 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));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 
   // Reading after a short wait should update the access date.
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
-  EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
   TestHostGarbageCollectHelper();
 }
 
 TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollection) {
   TestPriorityAwareGarbageCollectHelper();
 }
 
 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_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
 
-  EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), 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(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(SetCookie(cm.get(), http_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm.get(), foo_url, "x=1"));
+  EXPECT_TRUE(SetCookie(cm_foo.get(), foo_url, "x=1"));
+  EXPECT_FALSE(SetCookie(cm_foo.get(), 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));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_secure_,
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), url_google_, "A=B; httponly", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_, "C=D; domain=.google.izzle", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(),
+                                   url_google_secure_,
                                    "E=F; domain=.google.izzle; secure",
                                    options));
 
-  const Time last_access_date(GetFirstCookieAccessDate(cm));
+  const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
 
   // Check cookies for url.
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
   CookieList::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());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Check cookies for url excluding http-only cookies.
   cookies =
-      GetAllCookiesForURLWithOptions(cm, url_google_, CookieOptions());
+      GetAllCookiesForURLWithOptions(cm.get(), url_google_, CookieOptions());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Test secure cookies.
-  cookies = GetAllCookiesForURL(cm, url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
   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());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("E", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Reading after a short wait should not update the access date.
-  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
+  EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 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));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_bar_,
-                                   "C=D; path=/bar;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
-                                   "E=F;", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_foo_, "A=B; path=/foo;", options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), url_google_bar_, "C=D; path=/bar;", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "E=F;", options));
 
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), 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());
   EXPECT_EQ("/", it->Path());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
   EXPECT_EQ("/bar", it->Path());
 
   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(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(SetCookie(cm.get(), url_google_, "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/bar"));
 
-  DeleteCookie(cm, GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
+  DeleteCookie(cm.get(), GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
 
-  CookieList cookies = GetAllCookies(cm);
+  CookieList cookies = GetAllCookies(cm.get());
   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));
   EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_bar_,
                                                "A2=D; path=/bar;",
                                                options));
   EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_,
                                                "A3=F;",
                                                options));
 
-  CookieList cookies_1 = GetAllCookies(cm_1);
+  CookieList cookies_1 = GetAllCookies(cm_1.get());
   scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL));
   ASSERT_TRUE(cm_2->InitializeFrom(cookies_1));
-  CookieList cookies_2 = GetAllCookies(cm_2);
+  CookieList cookies_2 = GetAllCookies(cm_2.get());
 
   size_t expected_size = 3;
   EXPECT_EQ(expected_size, cookies_2.size());
 
   CookieList::iterator it = cookies_2.begin();
 
   ASSERT_TRUE(it != cookies_2.end());
   EXPECT_EQ("A1", it->Name());
   EXPECT_EQ("/foo", it->Path());
 
@@ skipping 63 matching lines @@
 
   // Insert 1 cookie with name "Y" on path "/".
   AddCookieToList("www.google.com",
                   "Y=a; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(10),
                   &initial_cookies);
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Verify that duplicates were not imported for path "/".
   // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4).
-  EXPECT_EQ("X=3; Y=a", GetCookies(cm, GURL("http://www.google.com/")));
+  EXPECT_EQ("X=3; Y=a", GetCookies(cm.get(), GURL("http://www.google.com/")));
 
   // Verify that same-named cookie on a different path ("/x2") didn't get
   // messed up.
   EXPECT_EQ("X=a1; X=3; Y=a",
-            GetCookies(cm, GURL("http://www.google.com/2/x")));
+            GetCookies(cm.get(), GURL("http://www.google.com/2/x")));
 
   // Verify that the PersistentCookieStore was told to kill its 4 duplicates.
   ASSERT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[0].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[2].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
 }
 
 // Tests importing from a persistent cookie store that contains cookies
@@ skipping 19 matching lines @@
   AddCookieToList("www.google.com", "X=4; path=/", now, &initial_cookies);
 
   AddCookieToList("www.google.com", "Y=1; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=2; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=3; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=4; path=/", earlier, &initial_cookies);
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
-  CookieList list(GetAllCookies(cm));
+  CookieList list(GetAllCookies(cm.get()));
   EXPECT_EQ(2U, list.size());
   // Confirm that we have one of each.
   std::string name1(list[0].Name());
   std::string name2(list[1].Name());
   EXPECT_TRUE(name1 == "X" || name2 == "X");
   EXPECT_TRUE(name1 == "Y" || name2 == "Y");
   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));
+  scoped_refptr<CookieMonster> cm(
+      new CookieMonster(store.get(), delegate.get()));
 
-  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(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), 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());
   EXPECT_EQ(url_google_.host(), delegate->changes()[2].first.Domain());
   EXPECT_FALSE(delegate->changes()[2].second);
   EXPECT_EQ("E", delegate->changes()[2].first.Name());
   EXPECT_EQ("F", delegate->changes()[2].first.Value());
   delegate->reset();
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_));
+  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
   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_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // 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"));
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        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));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(),
+                                   url_google_,
+                                   "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);
   EXPECT_EQ("a", delegate->changes()[1].first.Name());
   EXPECT_EQ("val2", delegate->changes()[1].first.Value());
   delegate->reset();
 }
 
 TEST_F(CookieMonsterTest, SetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_foo_, "A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_bar_, "C", "D", "google.izzle", "/bar", base::Time(),
-      false, true, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_, "E", "F", std::string(), std::string(), base::Time(),
-      true, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_foo_,
+                                   "A",
+                                   "B",
+                                   std::string(),
+                                   "/foo",
+                                   base::Time(),
+                                   false,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_bar_,
+                                   "C",
+                                   "D",
+                                   "google.izzle",
+                                   "/bar",
+                                   base::Time(),
+                                   false,
+                                   true,
+                                   COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_,
+                                   "E",
+                                   "F",
+                                   std::string(),
+                                   std::string(),
+                                   base::Time(),
+                                   true,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
 
   // Test that malformed attributes fail to set the cookie.
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, " A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A;", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A=", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A", "B", "google.ozzzzzzle", "foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(
-      cm, url_google_foo_, "A=", "B", std::string(), "foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    " A",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A;",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A=",
+                                    "B",
+                                    std::string(),
+                                    "/foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A",
+                                    "B",
+                                    "google.ozzzzzzle",
+                                    "foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(),
+                                    url_google_foo_,
+                                    "A=",
+                                    "B",
+                                    std::string(),
+                                    "foo",
+                                    base::Time(),
+                                    false,
+                                    false,
+                                    COOKIE_PRIORITY_DEFAULT));
 
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("B", it->Value());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("/foo", it->Path());
   EXPECT_FALSE(it->IsPersistent());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
   EXPECT_EQ("D", it->Value());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("/bar", it->Path());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_TRUE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm, url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("F", it->Value());
   EXPECT_EQ("/", it->Path());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_TRUE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 }
 
 TEST_F(CookieMonsterTest, DeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
   // Test probes:
   //    * Non-secure URL, mid-level (http://w.c.b.a)
   //    * Secure URL, mid-level (https://w.c.b.a)
   //    * URL with path, mid-level (https:/w.c.b.a/dir1/xx)
   // All three tests should nuke only the midlevel host cookie,
   // the http_only cookie, the host secure cookie, and the two host
   // path cookies.  http_only, secure, and paths are ignored by
   // this call, and domain cookies arent touched.
   PopulateCmForDeleteAllForHost(cm);
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; host_path_2=X; dom_path_1=X; host_path_1=X; "
             "dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2)));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2)));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure +
-                                         std::string("/dir1/xxx"))));
-  EXPECT_EQ(8U, GetAllCookies(cm).size());
+  EXPECT_EQ(5,
+            DeleteAllForHost(
+                cm.get(),
+                GURL(kTopLevelDomainPlus2Secure + std::string("/dir1/xxx"))));
+  EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
 
   EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus3)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure)));
-  EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1)));
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ("dom_1=X; host_1=X",
+            GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
-            GetCookies(cm, GURL(kTopLevelDomainPlus2Secure +
-                                std::string("/dir1/dir2/xxx"))));
+            GetCookies(cm.get(),
+                       GURL(kTopLevelDomainPlus2Secure +
+                            std::string("/dir1/dir2/xxx"))));
 }
 
 TEST_F(CookieMonsterTest, UniqueCreationTime) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   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, SetCookieWithOptions, SetCookieWithDetails
 
-  SetCookie(cm, url_google_, "SetCookie1=A");
-  SetCookie(cm, url_google_, "SetCookie2=A");
-  SetCookie(cm, url_google_, "SetCookie3=A");
+  SetCookie(cm.get(), url_google_, "SetCookie1=A");
+  SetCookie(cm.get(), url_google_, "SetCookie2=A");
+  SetCookie(cm.get(), 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);
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions1=A", options);
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions2=A", options);
+  SetCookieWithOptions(
+      cm.get(), url_google_, "setCookieWithOptions3=A", options);
 
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails1", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails1",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails2",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
-  SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A",
-                       ".google.com", "/", Time(), false, false,
+  SetCookieWithDetails(cm.get(),
+                       url_google_,
+                       "setCookieWithDetails3",
+                       "A",
+                       ".google.com",
+                       "/",
+                       Time(),
+                       false,
+                       false,
                        COOKIE_PRIORITY_DEFAULT);
 
   // Now we check
-  CookieList cookie_list(GetAllCookies(cm));
+  CookieList cookie_list(GetAllCookies(cm.get()));
   typedef std::map<int64, 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));
     EXPECT_TRUE(existing_cookie_it == check_map.end())
         << "Cookie " << it->Name() << " has same creation date ("
         << it->CreationDate().ToInternalValue()
@@ skipping 48 matching lines @@
      "/path/from/cookie", expires + TimeDelta::FromSeconds(10),
      true, true, COOKIE_PRIORITY_DEFAULT},
     {GURL("https://google.com"), "c", "3", "", "/another/path/to/cookie",
      base::Time::Now() + base::TimeDelta::FromSeconds(100),
      true, false, COOKIE_PRIORITY_DEFAULT}
   };
   const int INPUT_DELETE = 1;
 
   // Create new cookies and flush them to the store.
   {
-    scoped_refptr<CookieMonster> cmout(new CookieMonster(store, NULL));
+    scoped_refptr<CookieMonster> cmout(new CookieMonster(store.get(), NULL));
     for (const CookiesInputInfo* p = input_info;
-         p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
-      EXPECT_TRUE(SetCookieWithDetails(cmout, p->url, p->name, p->value,
-                                       p->domain, p->path, p->expiration_time,
-                                       p->secure, p->http_only, p->priority));
+         p < &input_info[ARRAYSIZE_UNSAFE(input_info)];
+         p++) {
+      EXPECT_TRUE(SetCookieWithDetails(cmout.get(),
+                                       p->url,
+                                       p->name,
+                                       p->value,
+                                       p->domain,
+                                       p->path,
+                                       p->expiration_time,
+                                       p->secure,
+                                       p->http_only,
+                                       p->priority));
     }
     GURL del_url(input_info[INPUT_DELETE].url.Resolve(
                      input_info[INPUT_DELETE].path).spec());
-    DeleteCookie(cmout, del_url, input_info[INPUT_DELETE].name);
+    DeleteCookie(cmout.get(), del_url, 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));
+    scoped_refptr<CookieMonster> cmin(new CookieMonster(store.get(), NULL));
+    CookieList cookies(GetAllCookies(cmin.get()));
     ASSERT_EQ(2u, cookies.size());
     // Ordering is path length, then creation time.  So second cookie
     // will come first, and we need to swap them.
     std::swap(cookies[0], cookies[1]);
     for (int output_index = 0; output_index < 2; output_index++) {
       int input_index = output_index * 2;
       const CookiesInputInfo* input = &input_info[input_index];
       const CanonicalCookie* output = &cookies[output_index];
 
       EXPECT_EQ(input->name, output->Name());
       EXPECT_EQ(input->value, output->Value());
       EXPECT_EQ(input->url.host(), output->Domain());
       EXPECT_EQ(input->path, output->Path());
       EXPECT_LE(current.ToInternalValue(),
                 output->CreationDate().ToInternalValue());
       EXPECT_EQ(input->secure, output->IsSecure());
       EXPECT_EQ(input->http_only, output->IsHttpOnly());
       EXPECT_TRUE(output->IsPersistent());
       EXPECT_EQ(input->expiration_time.ToInternalValue(),
                 output->ExpiryDate().ToInternalValue());
     }
   }
 }
 
 TEST_F(CookieMonsterTest, CookieListOrdering) {
   // 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"),
+  EXPECT_TRUE(
+      SetCookie(cm.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        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"),
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        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"),
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        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(SetCookie(
+      cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), GURL("http://news.bbc.co.uk/midpath/x.html"), "g=10"));
   {
     unsigned int i = 0;
     CookieList cookies(GetAllCookiesForURL(
-        cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+        cm.get(), 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));
+    CookieList cookies(GetAllCookies(cm.get()));
     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());
   }
 }
 
@@ skipping 10 matching lines @@
 #else
 #define MAYBE_GarbageCollectionTriggers GarbageCollectionTriggers
 #endif
 
 TEST_F(CookieMonsterTest, MAYBE_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());
-    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
-    EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, GetAllCookies(cm).size());
+    EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm.get()).size());
+    SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
+    EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1,
+              GetAllCookies(cm.get()).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 {
     size_t num_cookies;
     size_t num_old_cookies;
     size_t expected_initial_cookies;
     // Indexed by ExpiryAndKeyScheme
@@ skipping 26 matching lines @@
       CookieMonster::kMaxCookies - CookieMonster::kPurgeCookies
     }
   };
 
   for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
     const TestCase *test_case = &test_cases[ci];
     scoped_refptr<CookieMonster> cm(
         CreateMonsterFromStoreForGC(
             test_case->num_cookies, test_case->num_old_cookies,
             CookieMonster::kSafeFromGlobalPurgeDays * 2));
-    EXPECT_EQ(test_case->expected_initial_cookies, GetAllCookies(cm).size())
-        << "For test case " << ci;
+    EXPECT_EQ(test_case->expected_initial_cookies,
+              GetAllCookies(cm.get()).size()) << "For test case " << ci;
     // Will trigger GC
-    SetCookie(cm, GURL("http://newdomain.com"), "b=2");
-    EXPECT_EQ(test_case->expected_cookies_after_set, GetAllCookies(cm).size())
-        << "For test case " << ci;
+    SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
+    EXPECT_EQ(test_case->expected_cookies_after_set,
+              GetAllCookies(cm.get()).size()) << "For test case " << ci;
   }
 }
 
 // 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_,
+      cm.get(),
+      url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
       options));
 
   // Get the canonical cookie.
-  CookieList cookie_list = GetAllCookies(cm);
+  CookieList cookie_list = GetAllCookies(cm.get());
   ASSERT_EQ(1U, cookie_list.size());
 
   // Use a past expiry date to delete the cookie.
   ASSERT_TRUE(SetCookieWithOptions(
-      cm, url_google_,
+      cm.get(),
+      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);
+  cookie_list = GetAllCookies(cm.get());
   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) {}
@@ skipping 52 matching lines @@
 
   volatile int callback_count_;
 };
 
 }  // namespace
 
 // Test that FlushStore() is forwarded to the store and callbacks are posted.
 TEST_F(CookieMonsterTest, FlushStore) {
   scoped_refptr<CallbackCounter> counter(new CallbackCounter());
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   ASSERT_EQ(0, store->flush_count());
   ASSERT_EQ(0, counter->callback_count());
 
   // Before initialization, FlushStore() should just run the callback.
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(0, store->flush_count());
   ASSERT_EQ(1, counter->callback_count());
 
   // NULL callback is safe.
   cm->FlushStore(base::Closure());
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(0, store->flush_count());
   ASSERT_EQ(1, counter->callback_count());
 
   // After initialization, FlushStore() should delegate to the store.
-  GetAllCookies(cm);  // Force init.
+  GetAllCookies(cm.get());  // Force init.
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(1, store->flush_count());
   ASSERT_EQ(2, counter->callback_count());
 
   // NULL callback is still safe.
   cm->FlushStore(base::Closure());
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(2, store->flush_count());
   ASSERT_EQ(2, counter->callback_count());
 
   // If there's no backing store, FlushStore() is always a safe no-op.
   cm = new CookieMonster(NULL, NULL);
-  GetAllCookies(cm);  // Force init.
+  GetAllCookies(cm.get());  // Force init.
   cm->FlushStore(base::Closure());
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(2, counter->callback_count());
 
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(3, counter->callback_count());
 }
 
 TEST_F(CookieMonsterTest, HistogramCheck) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   // Should match call in InitializeHistograms, but doesn't really matter
   // since the histogram should have been initialized by the CM construction
   // above.
   base::HistogramBase* expired_histogram =
       base::Histogram::FactoryGet(
           "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50,
           base::Histogram::kUmaTargetedHistogramFlag);
 
   scoped_ptr<base::HistogramSamples> samples1(
       expired_histogram->SnapshotSamples());
-  ASSERT_TRUE(SetCookieWithDetails(
-      cm, GURL("http://fake.a.url"), "a", "b", "a.url", "/",
-      base::Time::Now() + base::TimeDelta::FromMinutes(59),
-      false, false, COOKIE_PRIORITY_DEFAULT));
+  ASSERT_TRUE(
+      SetCookieWithDetails(cm.get(),
+                           GURL("http://fake.a.url"),
+                           "a",
+                           "b",
+                           "a.url",
+                           "/",
+                           base::Time::Now() + base::TimeDelta::FromMinutes(59),
+                           false,
+                           false,
+                           COOKIE_PRIORITY_DEFAULT));
 
   scoped_ptr<base::HistogramSamples> samples2(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
+  ASSERT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
 
   scoped_ptr<base::HistogramSamples> samples3(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples2->TotalCount(), samples3->TotalCount());
 }
 
 namespace {
 
 class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
  public:
@@ skipping 77 matching lines @@
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 }  // namespace
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  CookieList cookies = GetAllCookies(cm);
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  CookieList cookies = GetAllCookies(cm.get());
   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(SetCookie(cm, url_google_, "A=B"));
-  CookieList cookies = GetAllCookiesForURL(cm, url_google_);
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  CookieList cookies = GetAllCookiesForURL(cm.get(), 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(SetCookie(cm, url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
   CookieOptions options;
   CookieList cookies =
-      GetAllCookiesForURLWithOptions(cm, url_google_, options);
+      GetAllCookiesForURLWithOptions(cm.get(), 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(
       &net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLWithOptionsTask,
       base::Unretained(this),
       cm, url_google_, options, &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, ThreadCheckSetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookieWithDetails(
-      cm, url_google_foo_,
-      "A", "B", std::string(), "/foo", base::Time(),
-      false, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(),
+                                   url_google_foo_,
+                                   "A",
+                                   "B",
+                                   std::string(),
+                                   "/foo",
+                                   base::Time(),
+                                   false,
+                                   false,
+                                   COOKIE_PRIORITY_DEFAULT));
   BoolResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
       base::Unretained(this),
       cm, url_google_foo_, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 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()));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_EQ(
+      1,
+      DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
       base::Unretained(this),
       cm, now - TimeDelta::FromDays(99),
       Time(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 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_));
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_EQ(1, DeleteAllForHost(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
       base::Unretained(this),
       cm, url_google_, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  CookieList cookies = GetAllCookies(cm);
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  CookieList cookies = GetAllCookies(cm.get());
   CookieList::iterator it = cookies.begin();
-  EXPECT_TRUE(DeleteCanonicalCookie(cm, *it));
+  EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   BoolResultCookieCallback callback(&other_thread_);
-  cookies = GetAllCookies(cm);
+  cookies = GetAllCookies(cm.get());
   it = cookies.begin();
   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());
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   std::string cookie_line =
       std::string(kValidCookieLine) + "; expires=Blarg arg arg";
   scoped_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url_google_, cookie_line, Time::Now(),
                               CookieOptions()));
   ASSERT_FALSE(cookie->IsPersistent());
 }
 
 // Test that CookieMonster writes session cookies into the underlying
 // CookieStore if the "persist session cookies" option is on.
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   cm->SetPersistSessionCookies(true);
 
   // All cookies set with SetCookie are session cookies.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=B"));
-  EXPECT_EQ("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
 
   // The cookie was written to the backing store.
   EXPECT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   EXPECT_EQ("A", store->commands()[0].cookie.Name());
   EXPECT_EQ("B", store->commands()[0].cookie.Value());
 
   // Modify the cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "A=C"));
-  EXPECT_EQ("A=C", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=C"));
+  EXPECT_EQ("A=C", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ("A", store->commands()[1].cookie.Name());
   EXPECT_EQ("B", store->commands()[1].cookie.Value());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   EXPECT_EQ("A", store->commands()[2].cookie.Name());
   EXPECT_EQ("C", store->commands()[2].cookie.Value());
 
   // Delete the cookie.
-  DeleteCookie(cm, url_google_, "A");
-  EXPECT_EQ("", GetCookies(cm, url_google_));
+  DeleteCookie(cm.get(), url_google_, "A");
+  EXPECT_EQ("", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ("A", store->commands()[3].cookie.Name());
   EXPECT_EQ("C", store->commands()[3].cookie.Value());
 }
 
 // Test the commands sent to the persistent cookie store.
 TEST_F(CookieMonsterTest, PersisentCookieStorageTest) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
-  scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   // Remove it.
-  EXPECT_TRUE(SetCookie(cm, url_google_,"A=B; max-age=0"));
-  this->MatchCookieLines(std::string(), GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B; max-age=0"));
+  this->MatchCookieLines(std::string(), GetCookies(cm.get(), url_google_));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   // Overwrite it.
-  EXPECT_TRUE(SetCookie(cm, url_google_,
-                        "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
-  this->MatchCookieLines("A=Foo", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), url_google_, "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
+  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), url_google_));
   ASSERT_EQ(5u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
-  EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
-  this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=Bar"));
+  this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm.get(), url_google_));
   EXPECT_EQ(5u, store->commands().size());
 }
 
 }  // namespace net