Implement the "first-party-only" cookie flag.

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 134 matching lines @@
 
   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 first_party_only,
                             CookiePriority priority) {
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
-        priority, base::Bind(&ResultSavingCookieCallback<bool>::Run,
-                             base::Unretained(&callback)));
+        first_party_only, priority,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteAll(CookieMonster* cm) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
                                   base::Unretained(&callback)));
@@ skipping 61 matching lines @@
     GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
     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)
+    //    * first-party 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.get(), url_top_level_domain_plus_1, "dom_1", "X", ".harvard.edu",
-        "/", base::Time(), false, false, COOKIE_PRIORITY_DEFAULT));
+        "/", base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2, "dom_2", "X",
-        ".math.harvard.edu", "/", base::Time(), false, false,
+        ".math.harvard.edu", "/", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_3, "dom_3", "X",
-        ".bourbaki.math.harvard.edu", "/", base::Time(), false, false,
+        ".bourbaki.math.harvard.edu", "/", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
 
     // Host cookies
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_1, "host_1", "X", std::string(),
-        "/", base::Time(), false, false, COOKIE_PRIORITY_DEFAULT));
+        "/", base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2, "host_2", "X", std::string(),
-        "/", base::Time(), false, false, COOKIE_PRIORITY_DEFAULT));
+        "/", base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_3, "host_3", "X", std::string(),
-        "/", base::Time(), false, false, COOKIE_PRIORITY_DEFAULT));
+        "/", base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
 
-    // Http_only cookie
+    // http_only cookie
     EXPECT_TRUE(this->SetCookieWithDetails(
-        cm.get(), url_top_level_domain_plus_2, "httpo_check", "X",
-        std::string(), "/", base::Time(), false, true,
+        cm.get(), url_top_level_domain_plus_2, "httpo_check", "x",
+        std::string(), "/", base::Time(), false, true, false,
+        COOKIE_PRIORITY_DEFAULT));
+
+    // first-party cookie
+    EXPECT_TRUE(this->SetCookieWithDetails(
+        cm.get(), url_top_level_domain_plus_2, "firstp_check", "x",
+        std::string(), "/", base::Time(), false, false, true,
         COOKIE_PRIORITY_DEFAULT));
 
     // Secure cookies
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2_secure, "sec_dom", "X",
-        ".math.harvard.edu", "/", base::Time(), true, false,
+        ".math.harvard.edu", "/", base::Time(), true, false, false,
         COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2_secure, "sec_host", "X",
-        std::string(), "/", base::Time(), true, false,
+        std::string(), "/", base::Time(), true, false, false,
         COOKIE_PRIORITY_DEFAULT));
 
     // Domain path cookies
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2, "dom_path_1", "X",
-        ".math.harvard.edu", "/dir1", base::Time(), false, false,
+        ".math.harvard.edu", "/dir1", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
     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,
+        ".math.harvard.edu", "/dir1/dir2", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
 
     // Host path cookies
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2, "host_path_1", "X",
-        std::string(), "/dir1", base::Time(), false, false,
+        std::string(), "/dir1", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
     EXPECT_TRUE(this->SetCookieWithDetails(
         cm.get(), url_top_level_domain_plus_2, "host_path_2", "X",
-        std::string(), "/dir1/dir2", base::Time(), false, false,
+        std::string(), "/dir1/dir2", base::Time(), false, false, false,
         COOKIE_PRIORITY_DEFAULT));
 
-    EXPECT_EQ(13U, this->GetAllCookies(cm.get()).size());
+    EXPECT_EQ(14U, 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 269 matching lines @@
 
 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;
+  bool first_party_only;
   CookiePriority priority;
 };
 
 ACTION(QuitCurrentMessageLoop) {
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::MessageLoop::QuitClosure());
 }
 
 // TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed,
 // rename these, removing the 'Action' suffix.
@@ skipping 12 matching lines @@
           cookie_monster,
           delete_begin,
           delete_end,
           callback) {
   cookie_monster->DeleteAllCreatedBetweenAsync(delete_begin, delete_end,
                                                callback->AsCallback());
 }
 ACTION_P3(SetCookieWithDetailsAction, cookie_monster, cc, callback) {
   cookie_monster->SetCookieWithDetailsAsync(
       cc.url, cc.name, cc.value, cc.domain, cc.path, cc.expiration_time,
-      cc.secure, cc.http_only, cc.priority, callback->AsCallback());
+      cc.secure, cc.http_only, cc.first_party_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 195 matching lines @@
   MockSetCookiesCallback set_cookies_callback;
 
   CookiesInputInfo cookie_info = {url_google_foo_,
                                   "A",
                                   "B",
                                   std::string(),
                                   "/foo",
                                   base::Time(),
                                   false,
                                   false,
+                                  false,
                                   COOKIE_PRIORITY_DEFAULT};
   BeginWithForDomainKey(
       "google.izzle", SetCookieWithDetailsAction(&cookie_monster(), cookie_info,
                                                  &set_cookies_callback));
 
   WaitForLoadCall();
 
   CookiesInputInfo cookie_info_exp = {url_google_foo_,
                                       "A",
                                       "B",
                                       std::string(),
                                       "/foo",
                                       base::Time(),
                                       false,
                                       false,
+                                      false,
                                       COOKIE_PRIORITY_DEFAULT};
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(SetCookieWithDetailsAction(&cookie_monster(), cookie_info_exp,
                                            &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
@@ skipping 660 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.get(), url_google_foo_, "A", "B",
                                    std::string(), "/foo", base::Time(), false,
-                                   false, COOKIE_PRIORITY_DEFAULT));
+                                   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));
+  EXPECT_TRUE(SetCookieWithDetails(
+      cm.get(), url_google_, "E", "F", std::string(), std::string(),
+      base::Time(), true, false, false, COOKIE_PRIORITY_DEFAULT));
 
   // Test that malformed attributes fail to set the cookie.
   EXPECT_FALSE(SetCookieWithDetails(cm.get(), url_google_foo_, " A", "B",
                                     std::string(), "/foo", base::Time(), false,
-                                    false, COOKIE_PRIORITY_DEFAULT));
+                                    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));
+                                    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", "google.ozzzzzzle", "foo",
+      base::Time(), false, 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));
+                                    false, false, COOKIE_PRIORITY_DEFAULT));
 
   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());
@@ skipping 46 matching lines @@
   EXPECT_EQ("dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
             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.get(), GURL(kTopLevelDomainPlus2Secure +
                                 std::string("/dir1/dir2/xxx"))));
 
-  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2)));
+  EXPECT_EQ(6, 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.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
             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.get(), GURL(kTopLevelDomainPlus2Secure +
                                       std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
+  EXPECT_EQ(6, 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.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
             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.get(), GURL(kTopLevelDomainPlus2Secure +
                                       std::string("/dir1/dir2/xxx"))));
 
   PopulateCmForDeleteAllForHost(cm);
-  EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2Secure +
+  EXPECT_EQ(6, 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.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
             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",
@@ skipping 20 matching lines @@
   SetCookie(cm.get(), url_google_, "SetCookie3=A");
 
   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.get(), url_google_, "setCookieWithDetails1", "A",
-                       ".google.com", "/", Time(), false, false,
+                       ".google.com", "/", Time(), false, false, false,
                        COOKIE_PRIORITY_DEFAULT);
   SetCookieWithDetails(cm.get(), url_google_, "setCookieWithDetails2", "A",
-                       ".google.com", "/", Time(), false, false,
+                       ".google.com", "/", Time(), false, false, false,
                        COOKIE_PRIORITY_DEFAULT);
   SetCookieWithDetails(cm.get(), url_google_, "setCookieWithDetails3", "A",
-                       ".google.com", "/", Time(), false, false,
+                       ".google.com", "/", Time(), false, false, false,
                        COOKIE_PRIORITY_DEFAULT);
 
   // Now we check
   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(
@@ skipping 47 matching lines @@
 
   const CookiesInputInfo input_info[] = {
       {GURL("http://a.b.google.com"),
        "a",
        "1",
        "",
        "/path/to/cookie",
        expires,
        false,
        false,
+       false,
        COOKIE_PRIORITY_DEFAULT},
       {GURL("https://www.google.com"),
        "b",
        "2",
        ".google.com",
        "/path/from/cookie",
        expires + TimeDelta::FromSeconds(10),
        true,
        true,
+       false,
        COOKIE_PRIORITY_DEFAULT},
       {GURL("https://google.com"),
        "c",
        "3",
        "",
        "/another/path/to/cookie",
        base::Time::Now() + base::TimeDelta::FromSeconds(100),
        true,
        false,
+       true,
        COOKIE_PRIORITY_DEFAULT}};
   const int INPUT_DELETE = 1;
 
   // Create new cookies and flush them to the store.
   {
     scoped_refptr<CookieMonster> cmout(new CookieMonster(store.get(), NULL));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[arraysize(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));
+                                       p->secure, p->http_only,
+                                       p->first_party_only, p->priority));
     }
     GURL del_url(input_info[INPUT_DELETE]
                      .url.Resolve(input_info[INPUT_DELETE].path)
                      .spec());
     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.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_EQ(input->first_party_only, output->IsFirstPartyOnly());
       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.
@@ skipping 254 matching lines @@
   // 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.get(), GURL("http://fake.a.url"), "a", "b", "a.url", "/",
-      base::Time::Now() + base::TimeDelta::FromMinutes(59), false, false,
+      base::Time::Now() + base::TimeDelta::FromMinutes(59), 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.get(), url_google_, kValidCookieLine));
 
   scoped_ptr<base::HistogramSamples> samples3(
@@ skipping 36 matching lines @@
                                 ResultSavingCookieCallback<bool>* 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;
+    bool first_party_only = false;
     CookiePriority priority = COOKIE_PRIORITY_DEFAULT;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
-        priority, base::Bind(&ResultSavingCookieCallback<bool>::Run,
-                             base::Unretained(callback)));
+        first_party_only, priority,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                   base::Unretained(callback)));
   }
 
   void DeleteAllCreatedBetweenTask(CookieMonster* cm,
                                    const base::Time& delete_begin,
                                    const base::Time& delete_end,
                                    ResultSavingCookieCallback<int>* callback) {
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(callback)));
@@ skipping 105 matching lines @@
   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.get(), url_google_foo_, "A", "B",
                                    std::string(), "/foo", base::Time(), false,
-                                   false, COOKIE_PRIORITY_DEFAULT));
+                                   false, false, COOKIE_PRIORITY_DEFAULT));
   ResultSavingCookieCallback<bool> 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) {
@@ skipping 246 matching lines @@
   const std::string path("/path");
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
 
   std::vector<CanonicalCookie*> initial_cookies;
 
   AddCookieToList(domain, "foo=bar; path=" + path, now1, &initial_cookies);
 
   // We have to manually build this cookie because it contains a control
   // character, and our cookie line parser rejects control characters.
-  CanonicalCookie* cc = new CanonicalCookie(
-      url, "baz",
-      "\x05"
-      "boo",
-      domain, path, now2, later, now2, false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie* cc =
+      new CanonicalCookie(url, "baz",
+                          "\x05"
+                          "boo",
+                          domain, path, now2, later, now2, false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
   initial_cookies.push_back(cc);
 
   AddCookieToList(domain, "hello=world; path=" + path, now3, &initial_cookies);
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   EXPECT_EQ("foo=bar; hello=world", GetCookies(cm.get(), url));
@@ skipping 149 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net