[RWS] Remove SameParty state from CanonicalCookie and ParsedCookie

This does not change any behavior, since the SameParty attribute
no longer has any associated semantics. This also does not update
the database schema or affect how cookies are recreated from the
database; that will be done in a separate migration.

Bug: 1348588
Change-Id: Ic9bad0e11dc12616e4eb3ec774d579a156a7c73d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5029221
Reviewed-by: Alex Ilin <alexilin@chromium.org>
Reviewed-by: Dominic Farolino <dom@chromium.org>
Auto-Submit: Chris Fredrickson <cfredric@chromium.org>
Reviewed-by: Steven Bingler <bingler@chromium.org>
Commit-Queue: Chris Fredrickson <cfredric@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1224955}

google_apis/gaia/oauth_multilogin_result_unittest.cc

@@ -176,7 +176,7 @@ TEST(OAuthMultiloginResultTest, TryParseCookiesFromValue) {
               ElementsAre(Property(&CanonicalCookie::IsSameParty, Eq(false)),
                           Property(&CanonicalCookie::IsSameParty, Eq(false)),
                           Property(&CanonicalCookie::IsSameParty, Eq(false)),
-                          Property(&CanonicalCookie::IsSameParty, Eq(true))));
+                          Property(&CanonicalCookie::IsSameParty, Eq(false))));
 
   EXPECT_THAT(result.cookies()[0].CreationDate().InSecondsFSinceUnixEpoch(),
               DoubleNear(now, 0.5));

net/cookies/canonical_cookie.cc

@@ -385,7 +385,6 @@ CanonicalCookie::CanonicalCookie(
       httponly_(httponly),
       same_site_(same_site),
       priority_(priority),
-      same_party_(same_party),
       partition_key_(std::move(partition_key)),
       source_scheme_(source_scheme),
       source_port_(source_port) {}
@@ -684,8 +683,7 @@ std::unique_ptr<CanonicalCookie> CanonicalCookie::Create(
       cookie_expires, creation_time,
       /*last_update=*/base::Time::Now(), parsed_cookie.IsSecure(),
       parsed_cookie.IsHttpOnly(), samesite, parsed_cookie.Priority(),
-      parsed_cookie.IsSameParty(), cookie_partition_key, source_scheme,
-      source_port);
+      /*same_party=*/false, cookie_partition_key, source_scheme, source_port);
 
   // TODO(chlily): Log metrics.
   if (!cc->IsCanonical()) {

net/cookies/canonical_cookie.h

@@ -223,7 +223,7 @@ class NET_EXPORT CanonicalCookie {
   bool IsHttpOnly() const { return httponly_; }
   CookieSameSite SameSite() const { return same_site_; }
   CookiePriority Priority() const { return priority_; }
-  bool IsSameParty() const { return same_party_; }
+  bool IsSameParty() const { return false; }
   bool IsPartitioned() const { return partition_key_.has_value(); }
   const absl::optional<CookiePartitionKey>& PartitionKey() const {
     return partition_key_;
@@ -327,7 +327,7 @@ class NET_EXPORT CanonicalCookie {
            last_access_date_ == other.last_access_date_ &&
            expiry_date_ == other.expiry_date_ && secure_ == other.secure_ &&
            httponly_ == other.httponly_ && same_site_ == other.same_site_ &&
-           priority_ == other.priority_ && same_party_ == other.same_party_ &&
+           priority_ == other.priority_ &&
            partition_key_ == other.partition_key_ && name_ == other.name_ &&
            value_ == other.value_ && domain_ == other.domain_ &&
            path_ == other.path_ &&
@@ -341,9 +341,8 @@ class NET_EXPORT CanonicalCookie {
     auto f = [](const CanonicalCookie& c) {
       return std::tie(c.creation_date_, c.last_access_date_, c.expiry_date_,
                       c.secure_, c.httponly_, c.same_site_, c.priority_,
-                      c.same_party_, c.partition_key_, c.name_, c.value_,
-                      c.domain_, c.path_, c.last_update_date_, c.source_scheme_,
-                      c.source_port_);
+                      c.partition_key_, c.name_, c.value_, c.domain_, c.path_,
+                      c.last_update_date_, c.source_scheme_, c.source_port_);
     };
     return f(*this) < f(other);
   }
@@ -590,7 +589,6 @@ class NET_EXPORT CanonicalCookie {
   bool httponly_{false};
   CookieSameSite same_site_{CookieSameSite::NO_RESTRICTION};
   CookiePriority priority_{COOKIE_PRIORITY_MEDIUM};
-  bool same_party_{false};
   // This will be absl::nullopt for all cookies not set with the Partitioned
   // attribute or without a nonce. If the value is non-null, then the cookie
   // will only be delivered when the top-frame site matches the partition key

net/cookies/canonical_cookie_unittest.cc

@@ -76,7 +76,7 @@ TEST(CanonicalCookieTest, Constructor) {
   auto cookie2 = CanonicalCookie::CreateUnsafeCookieForTesting(
       "A", "2", ".www.example.com", "/", current_time, base::Time(),
       base::Time(), base::Time(), false, false, CookieSameSite::NO_RESTRICTION,
-      COOKIE_PRIORITY_DEFAULT, true,
+      COOKIE_PRIORITY_DEFAULT, /*same_party=*/true,
       CookiePartitionKey::FromURLForTesting(GURL("https://foo.com")),
       CookieSourceScheme::kNonSecure, 65536);
   EXPECT_EQ("A", cookie2->Name());
@@ -87,7 +87,7 @@ TEST(CanonicalCookieTest, Constructor) {
   EXPECT_FALSE(cookie2->IsHttpOnly());
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie2->SameSite());
   EXPECT_EQ(CookiePriority::COOKIE_PRIORITY_DEFAULT, cookie2->Priority());
-  EXPECT_TRUE(cookie2->IsSameParty());
+  EXPECT_FALSE(cookie2->IsSameParty());
   EXPECT_TRUE(cookie2->IsPartitioned());
   EXPECT_EQ(cookie2->SourceScheme(), CookieSourceScheme::kNonSecure);
   // Because the port can be set explicitly in the constructor its value can be
@@ -666,7 +666,7 @@ TEST(CanonicalCookieTest, CreateSameParty) {
   ASSERT_TRUE(cookie.get());
   EXPECT_TRUE(status.IsInclude());
   EXPECT_TRUE(cookie->IsSecure());
-  EXPECT_TRUE(cookie->IsSameParty());
+  EXPECT_FALSE(cookie->IsSameParty());
   EXPECT_EQ(CookieSameSite::UNSPECIFIED, cookie->SameSite());
 
   cookie = CanonicalCookie::Create(url, "A=2; SameParty; SameSite=None; Secure",
@@ -676,7 +676,7 @@ TEST(CanonicalCookieTest, CreateSameParty) {
   ASSERT_TRUE(cookie.get());
   EXPECT_TRUE(status.IsInclude());
   EXPECT_TRUE(cookie->IsSecure());
-  EXPECT_TRUE(cookie->IsSameParty());
+  EXPECT_FALSE(cookie->IsSameParty());
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie->SameSite());
 
   cookie = CanonicalCookie::Create(url, "A=2; SameParty; SameSite=Lax; Secure",
@@ -686,7 +686,7 @@ TEST(CanonicalCookieTest, CreateSameParty) {
   ASSERT_TRUE(cookie.get());
   EXPECT_TRUE(status.IsInclude());
   EXPECT_TRUE(cookie->IsSecure());
-  EXPECT_TRUE(cookie->IsSameParty());
+  EXPECT_FALSE(cookie->IsSameParty());
   EXPECT_EQ(CookieSameSite::LAX_MODE, cookie->SameSite());
 
   // SameParty cookie with SameSite=Strict is valid, since SameParty is ignored.
@@ -2124,7 +2124,7 @@ TEST(CanonicalCookieTest, IncludeForRequestURLSameParty) {
             cookie_samesite_unspecified->SameSite());
   EXPECT_EQ(CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
             cookie_samesite_unspecified->GetEffectiveSameSiteForTesting());
-  EXPECT_TRUE(cookie_samesite_unspecified->IsSameParty());
+  EXPECT_FALSE(cookie_samesite_unspecified->IsSameParty());
 
   // SameSite=None.
   std::unique_ptr<CanonicalCookie> cookie_samesite_none =
@@ -2136,7 +2136,7 @@ TEST(CanonicalCookieTest, IncludeForRequestURLSameParty) {
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie_samesite_none->SameSite());
   EXPECT_EQ(CookieEffectiveSameSite::NO_RESTRICTION,
             cookie_samesite_none->GetEffectiveSameSiteForTesting());
-  EXPECT_TRUE(cookie_samesite_none->IsSameParty());
+  EXPECT_FALSE(cookie_samesite_none->IsSameParty());
 
   // SameSite=Lax.
   std::unique_ptr<CanonicalCookie> cookie_samesite_lax =
@@ -2148,7 +2148,7 @@ TEST(CanonicalCookieTest, IncludeForRequestURLSameParty) {
   EXPECT_EQ(CookieSameSite::LAX_MODE, cookie_samesite_lax->SameSite());
   EXPECT_EQ(CookieEffectiveSameSite::LAX_MODE,
             cookie_samesite_lax->GetEffectiveSameSiteForTesting());
-  EXPECT_TRUE(cookie_samesite_lax->IsSameParty());
+  EXPECT_FALSE(cookie_samesite_lax->IsSameParty());
 }
 
 TEST(CanonicalCookieTest, IncludeForRequestURL_SameSiteNone_Metrics) {
@@ -3797,7 +3797,7 @@ TEST(CanonicalCookieTest, CreateSanitizedCookie_Inputs) {
       false /*httponly*/, CookieSameSite::NO_RESTRICTION, COOKIE_PRIORITY_LOW,
       true /*same_party*/, absl::nullopt /*partition_key*/, &status);
   EXPECT_TRUE(cc);
-  EXPECT_TRUE(cc->IsSameParty());
+  EXPECT_FALSE(cc->IsSameParty());
   EXPECT_TRUE(status.IsInclude());
 
   // Partitioned

net/cookies/cookie_monster_store_test.cc

@@ -120,7 +120,7 @@ std::unique_ptr<CanonicalCookie> BuildCanonicalCookie(
   return CanonicalCookie::CreateUnsafeCookieForTesting(
       pc.Name(), pc.Value(), "." + url.host(), cookie_path, creation_time,
       cookie_expires, base::Time(), base::Time(), pc.IsSecure(),
-      pc.IsHttpOnly(), pc.SameSite(), pc.Priority(), pc.IsSameParty());
+      pc.IsHttpOnly(), pc.SameSite(), pc.Priority(), /*same_party=*/false);
 }
 
 void AddCookieToList(const GURL& url,

net/cookies/parse_cookie_line_fuzzer.cc

@@ -36,7 +36,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   // Call zero or one of ParsedCookie's mutator methods.  Should not call
   // anything other than SetName/SetValue when !IsValid().
-  const uint8_t action = data_provider.ConsumeIntegralInRange(0, 12);
+  const uint8_t action = data_provider.ConsumeIntegralInRange(0, 11);
   switch (action) {
     case 1:
       parsed_cookie.SetName(GetArbitraryNameValueString(&data_provider));
@@ -80,9 +80,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
             GetArbitraryAttributeValueString(&data_provider));
         break;
       case 11:
-        parsed_cookie.SetIsSameParty(data_provider.ConsumeBool());
-        break;
-      case 12:
         parsed_cookie.SetIsPartitioned(data_provider.ConsumeBool());
         break;
     }

net/cookies/parsed_cookie.cc

@@ -63,7 +63,6 @@ const char kSecureTokenName[] = "secure";
 const char kHttpOnlyTokenName[] = "httponly";
 const char kSameSiteTokenName[] = "samesite";
 const char kPriorityTokenName[] = "priority";
-const char kSamePartyTokenName[] = "sameparty";
 const char kPartitionedTokenName[] = "partitioned";
 
 const char kTerminator[] = "\n\r\0";
@@ -271,10 +270,6 @@ bool ParsedCookie::SetPriority(const std::string& priority) {
   return SetString(&priority_index_, kPriorityTokenName, priority);
 }
 
-bool ParsedCookie::SetIsSameParty(bool is_same_party) {
-  return SetBool(&same_party_index_, kSamePartyTokenName, is_same_party);
-}
-
 bool ParsedCookie::SetIsPartitioned(bool is_partitioned) {
   return SetBool(&partitioned_index_, kPartitionedTokenName, is_partitioned);
 }
@@ -290,7 +285,6 @@ std::string ParsedCookie::ToCookieLine() const {
     // we need to consider whether the name component is a special token.
     if (it == pairs_.begin() ||
         (it->first != kSecureTokenName && it->first != kHttpOnlyTokenName &&
-         it->first != kSamePartyTokenName &&
          it->first != kPartitionedTokenName)) {
       out.append("=");
       out.append(it->second);
@@ -674,8 +668,6 @@ void ParsedCookie::SetupAttributes() {
       same_site_index_ = i;
     } else if (pairs_[i].first == kPriorityTokenName) {
       priority_index_ = i;
-    } else if (pairs_[i].first == kSamePartyTokenName) {
-      same_party_index_ = i;
     } else if (pairs_[i].first == kPartitionedTokenName) {
       partitioned_index_ = i;
     } else {
@@ -749,10 +741,10 @@ void ParsedCookie::ClearAttributePair(size_t index) {
   if (index == 0)
     return;
 
-  size_t* indexes[] = {&path_index_,       &domain_index_,   &expires_index_,
-                       &maxage_index_,     &secure_index_,   &httponly_index_,
-                       &same_site_index_,  &priority_index_, &same_party_index_,
-                       &partitioned_index_};
+  size_t* indexes[] = {
+      &path_index_,      &domain_index_,   &expires_index_,
+      &maxage_index_,    &secure_index_,   &httponly_index_,
+      &same_site_index_, &priority_index_, &partitioned_index_};
   for (size_t* attribute_index : indexes) {
     if (*attribute_index == index)
       *attribute_index = 0;

net/cookies/parsed_cookie.h

@@ -85,7 +85,6 @@ class NET_EXPORT ParsedCookie {
   CookieSameSite SameSite(
       CookieSameSiteString* samesite_string = nullptr) const;
   CookiePriority Priority() const;
-  bool IsSameParty() const { return same_party_index_ != 0; }
   bool IsPartitioned() const { return partitioned_index_ != 0; }
   bool HasInternalHtab() const { return internal_htab_; }
   TruncatingCharacterInCookieStringType
@@ -116,7 +115,6 @@ class NET_EXPORT ParsedCookie {
   bool SetIsHttpOnly(bool is_http_only);
   bool SetSameSite(const std::string& same_site);
   bool SetPriority(const std::string& priority);
-  bool SetIsSameParty(bool is_same_party);
   bool SetIsPartitioned(bool is_partitioned);
 
   // Returns the cookie description as it appears in a HTML response header.
@@ -213,7 +211,6 @@ class NET_EXPORT ParsedCookie {
   size_t httponly_index_ = 0;
   size_t same_site_index_ = 0;
   size_t priority_index_ = 0;
-  size_t same_party_index_ = 0;
   size_t partitioned_index_ = 0;
   TruncatingCharacterInCookieStringType truncating_char_in_cookie_string_type_ =
       TruncatingCharacterInCookieStringType::kTruncatingCharNone;

net/cookies/parsed_cookie_unittest.cc

@@ -18,7 +18,6 @@ TEST(ParsedCookieTest, TestBasic) {
   EXPECT_TRUE(pc1.IsValid());
   EXPECT_FALSE(pc1.IsSecure());
   EXPECT_FALSE(pc1.IsHttpOnly());
-  EXPECT_FALSE(pc1.IsSameParty());
   EXPECT_FALSE(pc1.IsPartitioned());
   EXPECT_EQ("a", pc1.Name());
   EXPECT_EQ("b", pc1.Value());
@@ -35,7 +34,6 @@ TEST(ParsedCookieTest, TestBasic) {
   EXPECT_TRUE(pc2.IsValid());
   EXPECT_TRUE(pc2.IsSecure());
   EXPECT_TRUE(pc2.IsHttpOnly());
-  EXPECT_TRUE(pc2.IsSameParty());
   EXPECT_TRUE(pc2.IsPartitioned());
   EXPECT_EQ("c", pc2.Name());
   EXPECT_EQ("d", pc2.Value());
@@ -219,7 +217,6 @@ TEST(ParsedCookieTest, TestAttributeCase) {
   EXPECT_TRUE(pc.IsValid());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.IsHttpOnly());
-  EXPECT_TRUE(pc.IsSameParty());
   EXPECT_TRUE(pc.IsPartitioned());
   EXPECT_EQ(CookieSameSite::LAX_MODE, pc.SameSite());
   EXPECT_TRUE(pc.HasPath());
@@ -763,12 +760,11 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_TRUE(pc.SetIsHttpOnly(true));
   EXPECT_TRUE(pc.SetSameSite("LAX"));
   EXPECT_TRUE(pc.SetPriority("HIGH"));
-  EXPECT_TRUE(pc.SetIsSameParty(true));
   EXPECT_TRUE(pc.SetIsPartitioned(true));
   EXPECT_EQ(
       "name=value; domain=domain.com; path=/; "
       "expires=Sun, 18-Apr-2027 21:06:29 GMT; max-age=12345; secure; "
-      "httponly; samesite=LAX; priority=HIGH; sameparty; partitioned",
+      "httponly; samesite=LAX; priority=HIGH; partitioned",
       pc.ToCookieLine());
   EXPECT_TRUE(pc.HasDomain());
   EXPECT_TRUE(pc.HasPath());
@@ -778,7 +774,6 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_TRUE(pc.IsHttpOnly());
   EXPECT_EQ(CookieSameSite::LAX_MODE, pc.SameSite());
   EXPECT_EQ(COOKIE_PRIORITY_HIGH, pc.Priority());
-  EXPECT_TRUE(pc.IsSameParty());
 
   // Modify one attribute in the middle.
   EXPECT_TRUE(pc.SetPath("/foo"));
@@ -788,11 +783,10 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_TRUE(pc.HasExpires());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.IsHttpOnly());
-  EXPECT_TRUE(pc.IsSameParty());
   EXPECT_EQ(
       "name=value; domain=domain.com; path=/foo; "
       "expires=Sun, 18-Apr-2027 21:06:29 GMT; max-age=12345; secure; "
-      "httponly; samesite=LAX; priority=HIGH; sameparty; partitioned",
+      "httponly; samesite=LAX; priority=HIGH; partitioned",
       pc.ToCookieLine());
 
   // Set priority to medium.
@@ -801,7 +795,7 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_EQ(
       "name=value; domain=domain.com; path=/foo; "
       "expires=Sun, 18-Apr-2027 21:06:29 GMT; max-age=12345; secure; "
-      "httponly; samesite=LAX; priority=medium; sameparty; partitioned",
+      "httponly; samesite=LAX; priority=medium; partitioned",
       pc.ToCookieLine());
 
   // Clear attribute from the end.
@@ -810,7 +804,7 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_EQ(
       "name=value; domain=domain.com; path=/foo; "
       "expires=Sun, 18-Apr-2027 21:06:29 GMT; max-age=12345; secure; "
-      "httponly; samesite=LAX; priority=medium; sameparty",
+      "httponly; samesite=LAX; priority=medium",
       pc.ToCookieLine());
 
   // Clear the rest and change the name and value.
@@ -831,10 +825,8 @@ TEST(ParsedCookieTest, SetAttributes) {
   EXPECT_FALSE(pc.IsSecure());
   EXPECT_FALSE(pc.IsHttpOnly());
   EXPECT_EQ(CookieSameSite::UNSPECIFIED, pc.SameSite());
-  EXPECT_TRUE(pc.SetIsSameParty(false));
   EXPECT_TRUE(pc.SetIsPartitioned(false));
   EXPECT_EQ("name2=value2", pc.ToCookieLine());
-  EXPECT_FALSE(pc.IsSameParty());
   EXPECT_FALSE(pc.IsPartitioned());
 }
 
@@ -1044,10 +1036,6 @@ TEST(ParsedCookieTest, ToCookieLineSpecialTokens) {
     ParsedCookie pc("name=foo; httponly=baz");
     EXPECT_EQ(pc.ToCookieLine(), "name=foo; httponly");
   }
-  {
-    ParsedCookie pc("name=foo; sameparty=baz");
-    EXPECT_EQ(pc.ToCookieLine(), "name=foo; sameparty");
-  }
   {
     ParsedCookie pc("name=foo; bar=secure");
     EXPECT_EQ(pc.ToCookieLine(), "name=foo; bar=secure");
@@ -1058,14 +1046,12 @@ TEST(ParsedCookieTest, ToCookieLineSpecialTokens) {
     EXPECT_TRUE(pc.IsValid());
     EXPECT_TRUE(pc.IsSecure());
     EXPECT_FALSE(pc.IsHttpOnly());
-    EXPECT_FALSE(pc.IsSameParty());
   }
   {
     ParsedCookie pc("sameparty; sameparty; secure; httponly; httponly; secure");
     EXPECT_EQ("", pc.Name());
     EXPECT_EQ("sameparty", pc.Value());
     EXPECT_TRUE(pc.IsSecure());
-    EXPECT_TRUE(pc.IsSameParty());
     EXPECT_TRUE(pc.IsHttpOnly());
   }
   {

net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc

@@ -954,7 +954,7 @@ TEST_F(SQLitePersistentCookieStoreTest, SamePartyIsPersistent) {
   EXPECT_FALSE(cookie_map[kNonSamePartyCookieName]->IsSameParty());
 
   ASSERT_EQ(1u, cookie_map.count(kSamePartyCookieName));
-  EXPECT_TRUE(cookie_map[kSamePartyCookieName]->IsSameParty());
+  EXPECT_FALSE(cookie_map[kSamePartyCookieName]->IsSameParty());
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, SourcePortIsPersistent) {
@@ -1788,7 +1788,6 @@ bool AddV18CookiesToDB(sql::Database* db) {
 // Confirm the cookie list passed in has the above cookies in it.
 void ConfirmCookiesAfterMigrationTest(
     std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies,
-    bool expect_same_party_cookies = false,
     bool expect_last_update_date = false) {
   std::sort(read_in_cookies.begin(), read_in_cookies.end(), &CompareCookies);
   int i = 0;
@@ -1826,7 +1825,7 @@ void ConfirmCookiesAfterMigrationTest(
   EXPECT_EQ("/", read_in_cookies[i]->Path());
   EXPECT_TRUE(read_in_cookies[i]->IsSecure());
   EXPECT_EQ(CookieSourceScheme::kUnset, read_in_cookies[i]->SourceScheme());
-  EXPECT_EQ(expect_same_party_cookies, read_in_cookies[i]->IsSameParty());
+  EXPECT_FALSE(read_in_cookies[i]->IsSameParty());
   EXPECT_EQ(read_in_cookies[i]->LastUpdateDate(),
             expect_last_update_date ? read_in_cookies[i]->CreationDate()
                                     : base::Time());
@@ -1840,7 +1839,7 @@ void ConfirmCookiesAfterMigrationTest(
   EXPECT_EQ("/", read_in_cookies[i]->Path());
   EXPECT_TRUE(read_in_cookies[i]->IsSecure());
   EXPECT_EQ(CookieSourceScheme::kUnset, read_in_cookies[i]->SourceScheme());
-  EXPECT_EQ(expect_same_party_cookies, read_in_cookies[i]->IsSameParty());
+  EXPECT_FALSE(read_in_cookies[i]->IsSameParty());
   EXPECT_EQ(read_in_cookies[i]->LastUpdateDate(),
             expect_last_update_date ? read_in_cookies[i]->CreationDate()
                                     : base::Time());
@@ -1889,8 +1888,7 @@ TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion16) {
 
   std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies;
   CreateAndLoad(false, false, &read_in_cookies);
-  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies),
-                                   /*expect_same_party_cookies=*/true);
+  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies));
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion17) {
@@ -1903,8 +1901,7 @@ TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion17) {
 
   std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies;
   CreateAndLoad(false, false, &read_in_cookies);
-  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies),
-                                   /*expect_same_party_cookies=*/true);
+  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies));
   ASSERT_GE(GetDBCurrentVersionNumber(&connection), 17);
   connection.Close();
 }
@@ -1921,8 +1918,7 @@ TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion17FromFaultyV16) {
 
   std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies;
   CreateAndLoad(false, false, &read_in_cookies);
-  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies),
-                                   /*expect_same_party_cookies=*/true);
+  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies));
   ASSERT_GE(GetDBCurrentVersionNumber(&connection), 17);
   connection.Close();
 }
@@ -1937,8 +1933,7 @@ TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion18) {
 
   std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies;
   CreateAndLoad(false, false, &read_in_cookies);
-  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies),
-                                   /*expect_same_party_cookies=*/true);
+  ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies));
   ASSERT_GE(GetDBCurrentVersionNumber(&connection), 18);
   connection.Close();
 }
@@ -1954,7 +1949,6 @@ TEST_F(SQLitePersistentCookieStoreTest, UpgradeToSchemaVersion19) {
   std::vector<std::unique_ptr<CanonicalCookie>> read_in_cookies;
   CreateAndLoad(false, false, &read_in_cookies);
   ConfirmCookiesAfterMigrationTest(std::move(read_in_cookies),
-                                   /*expect_same_party_cookies=*/true,
                                    /*expect_last_update_date=*/true);
   ASSERT_GE(GetDBCurrentVersionNumber(&connection), 19);
   connection.Close();

services/network/cookie_manager_unittest.cc

@@ -512,7 +512,7 @@ TEST_F(CookieManagerTest, GetAllCookies) {
   EXPECT_FALSE(cookies[4].IsHttpOnly());
   EXPECT_EQ(net::CookieSameSite::LAX_MODE, cookies[4].SameSite());
   EXPECT_EQ(net::COOKIE_PRIORITY_MEDIUM, cookies[4].Priority());
-  EXPECT_TRUE(cookies[4].IsSameParty());
+  EXPECT_FALSE(cookies[4].IsSameParty());
 }
 
 TEST_F(CookieManagerTest, GetAllCookiesWithAccessSemantics) {

services/network/public/cpp/cookie_manager_mojom_traits.cc

@@ -692,7 +692,7 @@ bool StructTraits<
       std::move(name), std::move(value), std::move(domain), std::move(path),
       std::move(creation_time), std::move(expiry_time),
       std::move(last_access_time), std::move(last_update_time), cookie.secure(),
-      cookie.httponly(), site_restrictions, priority, cookie.same_party(),
+      cookie.httponly(), site_restrictions, priority, /*same_party=*/false,
       partition_key, source_scheme, cookie.source_port());
   if (!cc)
     return false;

services/network/public/cpp/cookie_manager_mojom_traits.h

@@ -270,9 +270,6 @@ struct StructTraits<network::mojom::CanonicalCookieDataView,
   static net::CookieSourceScheme source_scheme(const net::CanonicalCookie& c) {
     return c.SourceScheme();
   }
-  static bool same_party(const net::CanonicalCookie& c) {
-    return c.IsSameParty();
-  }
   static const absl::optional<net::CookiePartitionKey>& partition_key(
       const net::CanonicalCookie& c) {
     return c.PartitionKey();

services/network/public/mojom/cookie_manager.mojom

@@ -183,7 +183,6 @@ struct CanonicalCookie {
   CookieSameSite site_restrictions = NO_RESTRICTION;
   CookiePriority priority = MEDIUM;
   CookieSourceScheme source_scheme = kUnset;
-  bool same_party = false;
   CookiePartitionKey? partition_key;
   // -1 because of url::PORT_UNSPECIFIED
   // url/third_party/mozilla/url_parse.h