Adding Priority field to cookies.

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 <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_monster_store_test.h"  // For CookieStore mock
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using base::Time;
@@ skipping 106 matching lines @@
     return callback.cookies();
   }
 
   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) {
+                            bool secure,
+                            bool http_only,
+                            CookiePriority priority) {
     DCHECK(cm);
     SetCookieCallback callback;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
+        priority,
         base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteAll(CookieMonster*cm) {
     DCHECK(cm);
     DeleteCallback callback;
     cm->DeleteAllAsync(
@@ skipping 52 matching lines @@
     // 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));
+                                           "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));
+                                           "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));
+                                           "dom_3", "X",
+                                           ".bourbaki.math.harvard.edu", "/",
+                                           base::Time(), false, false,
+                                           COOKIE_PRIORITY_DEFAULT));
 
     // Host cookies
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_1,
                                            "host_1",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
-                                           false));
+                                           false,
+                                           COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_2,
                                            "host_2",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
-                                           false));
+                                           false,
+                                           COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_3,
                                            "host_3",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
-                                           false));
+                                           false,
+                                           COOKIE_PRIORITY_DEFAULT));
 
     // Http_only cookie
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_2,
                                            "httpo_check",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            false,
-                                           true));
+                                           true,
+                                           COOKIE_PRIORITY_DEFAULT));
 
     // Secure cookies
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
-                                          url_top_level_domain_plus_2_secure,
-                                         "sec_dom", "X", ".math.harvard.edu",
-                                         "/", base::Time(), true, false));
+                                           url_top_level_domain_plus_2_secure,
+                                           "sec_dom", "X", ".math.harvard.edu",
+                                           "/", base::Time(), true, false,
+                                           COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_2_secure,
                                            "sec_host",
                                            "X",
                                            std::string(),
                                            "/",
                                            base::Time(),
                                            true,
-                                           false));
+                                           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));
+                                           "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));
+                                           "dom_path_2", "X",
+                                           ".math.harvard.edu", "/dir1/dir2",
+                                           base::Time(), false, false,
+                                           COOKIE_PRIORITY_DEFAULT));
 
     // Host path cookies
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_2,
                                            "host_path_1",
                                            "X",
                                            std::string(),
                                            "/dir1",
                                            base::Time(),
                                            false,
-                                           false));
+                                           false,
+                                           COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(cm,
                                            url_top_level_domain_plus_2,
                                            "host_path_2",
                                            "X",
                                            std::string(),
                                            "/dir1/dir2",
                                            base::Time(),
                                            false,
-                                           false));
+                                           false,
+                                           COOKIE_PRIORITY_DEFAULT));
 
     EXPECT_EQ(13U, this->GetAllCookies(cm).size());
   }
 
   Time GetFirstCookieAccessDate(CookieMonster* cm) {
     const CookieList all_cookies(this->GetAllCookies(cm));
     return all_cookies.front().LastAccessDate();
   }
 
   bool FindAndDeleteCookie(CookieMonster* cm,
@@ skipping 116 matching lines @@
   MOCK_METHOD1(Invoke, void(int num_deleted));
 };
 
 class MockDeleteCookieCallback
   : public MockCookieCallback<MockDeleteCookieCallback,
                               CookieMonster::DeleteCookieCallback> {
  public:
   MOCK_METHOD1(Invoke, void(bool success));
 };
 
+struct CookiesInputInfo {
+  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;
+  CookiePriority priority;
+};
+
 ACTION(QuitCurrentMessageLoop) {
   MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 // TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed,
 // rename these, removing the 'Action' suffix.
 ACTION_P4(DeleteCookieAction, cookie_monster, url, name, callback) {
   cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback());
 }
 ACTION_P3(GetCookiesAction, cookie_monster, url, callback) {
   cookie_monster->GetCookiesWithOptionsAsync(
       url, CookieOptions(), callback->AsCallback());
 }
 ACTION_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) {
   cookie_monster->SetCookieWithOptionsAsync(
       url, cookie_line, CookieOptions(), callback->AsCallback());
 }
 ACTION_P4(DeleteAllCreatedBetweenAction,
           cookie_monster, delete_begin, delete_end, callback) {
   cookie_monster->DeleteAllCreatedBetweenAsync(
       delete_begin, delete_end, callback->AsCallback());
 }
-ACTION_P10(SetCookieWithDetailsAction,
-           cookie_monster, url, name, value, domain, path, expiration_time,
-           secure, http_only, callback) {
+ACTION_P3(SetCookieWithDetailsAction, cookie_monster, cc, callback) {
   cookie_monster->SetCookieWithDetailsAsync(
-      url, name, value, domain, path, expiration_time, secure, http_only,
+      cc.url, cc.name, cc.value, cc.domain, cc.path, cc.expiration_time,
+      cc.secure, cc.http_only, cc.priority,
       callback->AsCallback());
 }
 
 ACTION_P2(GetAllCookiesAction, cookie_monster, callback) {
   cookie_monster->GetAllCookiesAsync(callback->AsCallback());
 }
 
 ACTION_P3(DeleteAllForHostAction, cookie_monster, url, callback) {
   cookie_monster->DeleteAllForHostAsync(url, callback->AsCallback());
 }
@@ skipping 184 matching lines @@
           &cookie_monster(), url_google_, "X", &delete_cookie_callback));
   EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(
       QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
   MockSetCookiesCallback set_cookies_callback;
 
+  CookiesInputInfo cookie_info = {
+    url_google_foo_, "A", "B", std::string(), "/foo",
+    base::Time(), false, false, COOKIE_PRIORITY_DEFAULT
+  };
   BeginWithForDomainKey("google.izzle", SetCookieWithDetailsAction(
-      &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo",
-      base::Time(), false, false, &set_cookies_callback));
+      &cookie_monster(), cookie_info, &set_cookies_callback));
 
   WaitForLoadCall();
 
+  CookiesInputInfo cookie_info_exp = {
+    url_google_foo_, "A", "B", std::string(), "/foo",
+    base::Time(), false, false, COOKIE_PRIORITY_DEFAULT
+  };
   EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
       SetCookieWithDetailsAction(
-          &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo",
-          base::Time(), false, false, &set_cookies_callback));
+          &cookie_monster(), cookie_info_exp, &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
       QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
   DeclareLoadedCookie("www.google.izzle",
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
@@ skipping 671 matching lines @@
   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));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
       cm, url_google_bar_, "C", "D", "google.izzle", "/bar", base::Time(),
-      false, true));
+      false, true, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
       cm, url_google_, "E", "F", std::string(), std::string(), base::Time(),
-      true, false));
+      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));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(SetCookieWithDetails(
       cm, url_google_foo_, "A;", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(SetCookieWithDetails(
       cm, url_google_foo_, "A=", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(SetCookieWithDetails(
       cm, url_google_foo_, "A", "B", "google.ozzzzzzle", "foo", base::Time(),
-      false, false));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(SetCookieWithDetails(
       cm, url_google_foo_, "A=", "B", std::string(), "foo", base::Time(),
-      false, false));
+      false, false, COOKIE_PRIORITY_DEFAULT));
 
   CookieList cookies = GetAllCookiesForURL(cm, 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());
@@ skipping 107 matching lines @@
 
   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,
+                       COOKIE_PRIORITY_DEFAULT);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A",
-                       ".google.com", "/", Time(), false, false);
+                       ".google.com", "/", Time(), false, false,
+                       COOKIE_PRIORITY_DEFAULT);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A",
-                       ".google.com", "/", Time(), false, false);
+                       ".google.com", "/", Time(), false, false,
+                       COOKIE_PRIORITY_DEFAULT);
 
   // Now we check
   CookieList cookie_list(GetAllCookies(cm));
   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));
@@ skipping 37 matching lines @@
 // Test that cookies transfer from/to the backing store correctly.
 TEST_F(CookieMonsterTest, BackingStoreCommunication) {
   // Store details for cookies transforming through the backing store interface.
 
   base::Time current(base::Time::Now());
   scoped_refptr<MockSimplePersistentCookieStore> store(
       new MockSimplePersistentCookieStore);
   base::Time new_access_time;
   base::Time expires(base::Time::Now() + base::TimeDelta::FromSeconds(100));
 
-  struct CookiesInputInfo {
-    std::string gurl;
-    std::string name;
-    std::string value;
-    std::string domain;
-    std::string path;
-    base::Time expires;
-    bool secure;
-    bool http_only;
-  };
   const CookiesInputInfo input_info[] = {
-    {"http://a.b.google.com", "a", "1", "", "/path/to/cookie", expires,
-     false, false},
-    {"https://www.google.com", "b", "2", ".google.com", "/path/from/cookie",
-     expires + TimeDelta::FromSeconds(10), true, true},
-    {"https://google.com", "c", "3", "", "/another/path/to/cookie",
+    {GURL("http://a.b.google.com"), "a", "1", "", "/path/to/cookie", expires,
+     false, false, COOKIE_PRIORITY_DEFAULT},
+    {GURL("https://www.google.com"), "b", "2", ".google.com",
+     "/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}
+     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));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
-      EXPECT_TRUE(SetCookieWithDetails(cmout, GURL(p->gurl), p->name, p->value,
-                                       p->domain, p->path, p->expires,
-                                       p->secure, p->http_only));
+      EXPECT_TRUE(SetCookieWithDetails(cmout, p->url, p->name, p->value,
+                                       p->domain, p->path, p->expiration_time,
+                                       p->secure, p->http_only, p->priority));
     }
-    DeleteCookie(cmout, GURL(std::string(input_info[INPUT_DELETE].gurl) +
-                             input_info[INPUT_DELETE].path),
-                 input_info[INPUT_DELETE].name);
+    GURL del_url(input_info[INPUT_DELETE].url.Resolve(
+                     input_info[INPUT_DELETE].path).spec());
+    DeleteCookie(cmout, 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));
     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(GURL(input->gurl).host(), output->Domain());
+      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->expires.ToInternalValue(),
+      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"),
@@ skipping 263 matching lines @@
   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));
+      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));
 
   scoped_ptr<base::HistogramSamples> samples3(
       expired_histogram->SnapshotSamples());
@@ skipping 36 matching lines @@
                                 SetCookieCallback* callback) {
     // Define the parameters here instead of in the calling fucntion.
     // The maximum number of parameters for Bind function is 6.
     std::string name = "A";
     std::string value = "B";
     std::string domain = std::string();
     std::string path = "/foo";
     base::Time expiration_time = base::Time();
     bool secure = false;
     bool http_only = false;
+    CookiePriority priority = COOKIE_PRIORITY_DEFAULT;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
+        priority,
         base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
   }
 
   void DeleteAllCreatedBetweenTask(CookieMonster* cm,
                                    const base::Time& delete_begin,
                                    const base::Time& delete_end,
                                    DeleteCallback* callback) {
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
         base::Bind(&DeleteCallback::Run,
@@ skipping 98 matching lines @@
   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));
+      false, false, COOKIE_PRIORITY_DEFAULT));
   SetCookieCallback 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));
   DeleteCallback callback(&other_thread_);
   base::Closure task = base::Bind(
@@ skipping 123 matching lines @@
   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_EQ(5u, store->commands().size());
 }
 
 }  // namespace net