Rename first-party-only cookies to same-site cookies.

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 370 matching lines @@
 bool CookieMonster::ImportCookies(const CookieList& list) {
   base::AutoLock autolock(lock_);
   MarkCookieStoreAsInitialized();
   if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
     FetchAllCookiesIfNecessary();
   for (CookieList::const_iterator iter = list.begin(); iter != list.end();
        ++iter) {
     scoped_ptr<CanonicalCookie> cookie(new CanonicalCookie(*iter));
     CookieOptions options;
     options.set_include_httponly();
-    options.set_include_first_party_only_cookies();
+    options.set_include_same_site();
     if (!SetCanonicalCookie(&cookie, cookie->CreationDate(), options))
       return false;
   }
   return true;
 }
 
 // Task classes for queueing the coming request.
 
 class CookieMonster::CookieMonsterTask
     : public base::RefCountedThreadSafe<CookieMonsterTask> {
@@ skipping 56 matching lines @@
  public:
   SetCookieWithDetailsTask(CookieMonster* cookie_monster,
                            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,
+                           bool same_site,
                            bool enforce_prefixes,
                            bool enforce_strict_secure,
                            CookiePriority priority,
                            const SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         name_(name),
         value_(value),
         domain_(domain),
         path_(path),
         expiration_time_(expiration_time),
         secure_(secure),
         http_only_(http_only),
-        first_party_only_(first_party_only),
+        same_site_(same_site),
         enforce_prefixes_(enforce_prefixes),
         enforce_strict_secure_(enforce_strict_secure),
         priority_(priority),
         callback_(callback) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetCookieWithDetailsTask() override {}
 
  private:
   GURL url_;
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
   base::Time expiration_time_;
   bool secure_;
   bool http_only_;
-  bool first_party_only_;
+  bool same_site_;
   bool enforce_prefixes_;
   bool enforce_strict_secure_;
   CookiePriority priority_;
   SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCookieWithDetailsTask);
 };
 
 void CookieMonster::SetCookieWithDetailsTask::Run() {
   bool success = this->cookie_monster()->SetCookieWithDetails(
       url_, name_, value_, domain_, path_, expiration_time_, secure_,
-      http_only_, first_party_only_, enforce_prefixes_, enforce_strict_secure_,
+      http_only_, same_site_, enforce_prefixes_, enforce_strict_secure_,
       priority_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&SetCookiesCallback::Run,
                                     base::Unretained(&callback_), success));
   }
 }
 
 // Task class for GetAllCookies call.
 class CookieMonster::GetAllCookiesTask : public CookieMonsterTask {
  public:
@@ skipping 428 matching lines @@
 
 void CookieMonster::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     const Time& expiration_time,
     bool secure,
     bool http_only,
-    bool first_party_only,
+    bool same_site,
     bool enforce_prefixes,
     bool enforce_strict_secure,
     CookiePriority priority,
     const SetCookiesCallback& callback) {
   scoped_refptr<SetCookieWithDetailsTask> task = new SetCookieWithDetailsTask(
       this, url, name, value, domain, path, expiration_time, secure, http_only,
-      first_party_only, enforce_prefixes, enforce_strict_secure, priority,
-      callback);
+      same_site, enforce_prefixes, enforce_strict_secure, priority, callback);
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetAllCookiesForURLWithOptionsAsync(
     const GURL& url,
     const CookieOptions& options,
     const GetCookieListCallback& callback) {
   scoped_refptr<GetAllCookiesForURLWithOptionsTask> task =
       new GetAllCookiesForURLWithOptionsTask(this, url, options, callback);
 
@@ skipping 57 matching lines @@
       new GetCookiesWithOptionsTask(this, url, options, callback);
 
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetAllCookiesForURLAsync(
     const GURL& url,
     const GetCookieListCallback& callback) {
   CookieOptions options;
   options.set_include_httponly();
-  options.set_include_first_party_only_cookies();
+  options.set_include_same_site();
   scoped_refptr<GetAllCookiesForURLWithOptionsTask> task =
       new GetAllCookiesForURLWithOptionsTask(this, url, options, callback);
 
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   scoped_refptr<GetAllCookiesTask> task = new GetAllCookiesTask(this, callback);
 
   DoCookieTask(task);
@@ skipping 123 matching lines @@
 }
 
 bool CookieMonster::SetCookieWithDetails(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,
+                                         bool same_site,
                                          bool enforce_prefixes,
                                          bool enforce_strict_secure,
                                          CookiePriority priority) {
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
   Time creation_time = CurrentTime();
   last_time_seen_ = creation_time;
 
   scoped_ptr<CanonicalCookie> cc(CanonicalCookie::Create(
       url, name, value, domain, path, creation_time, expiration_time, secure,
-      http_only, first_party_only, enforce_strict_secure, priority));
+      http_only, same_site, enforce_strict_secure, priority));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
-  options.set_include_first_party_only_cookies();
+  options.set_include_same_site();
   if (enforce_strict_secure)
     options.set_enforce_strict_secure();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 CookieList CookieMonster::GetAllCookies() {
   base::AutoLock autolock(lock_);
 
   // This function is being called to scrape the cookie list for management UI
   // or similar.  We shouldn't show expired cookies in this list since it will
@@ skipping 165 matching lines @@
 
 void CookieMonster::DeleteCookie(const GURL& url,
                                  const std::string& cookie_name) {
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return;
 
   CookieOptions options;
   options.set_include_httponly();
-  options.set_include_first_party_only_cookies();
+  options.set_include_same_site();
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, true, &cookies);
   std::set<CanonicalCookie*> matching_cookies;
 
   for (std::vector<CanonicalCookie*>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     if ((*it)->Name() != cookie_name)
       continue;
     if (url.path().find((*it)->Path()))
@@ skipping 442 matching lines @@
       sync_to_store)
     store_->AddCookie(*cc);
   CookieMap::iterator inserted =
       cookies_.insert(CookieMap::value_type(key, cc));
   if (delegate_.get()) {
     delegate_->OnCookieChanged(*cc, false,
                                CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT);
   }
 
   // See InitializeHistograms() for details.
-  int32_t cookie_type_sample =
-      cc->IsFirstPartyOnly() ? 1 << COOKIE_TYPE_FIRSTPARTYONLY : 0;
-  cookie_type_sample |= cc->IsHttpOnly() ? 1 << COOKIE_TYPE_HTTPONLY : 0;
-  cookie_type_sample |= cc->IsSecure() ? 1 << COOKIE_TYPE_SECURE : 0;
-  histogram_cookie_type_->Add(cookie_type_sample);
+  int32_t type_sample = cc->IsSameSite() ? 1 << COOKIE_TYPE_SAME_SITE : 0;
+  type_sample |= cc->IsHttpOnly() ? 1 << COOKIE_TYPE_HTTPONLY : 0;
+  type_sample |= cc->IsSecure() ? 1 << COOKIE_TYPE_SECURE : 0;
+  histogram_cookie_type_->Add(type_sample);
 
   // Histogram the type of scheme used on URLs that set cookies. This
   // intentionally includes cookies that are set or overwritten by
   // http:// URLs, but not cookies that are cleared by http:// URLs, to
   // understand if the former behavior can be deprecated for Secure
   // cookies.
   if (!cc->Source().is_empty()) {
     CookieSource cookie_source_sample;
     if (cc->Source().SchemeIsCryptographic()) {
       cookie_source_sample =
@@ skipping 588 matching lines @@
   std::set_difference(new_cookies->begin(), new_cookies->end(),
                       old_cookies->begin(), old_cookies->end(),
                       std::inserter(*cookies_to_add, cookies_to_add->begin()),
                       FullDiffCookieSorter);
 }
 
 void CookieMonster::RunCallbacks(const CanonicalCookie& cookie, bool removed) {
   lock_.AssertAcquired();
   CookieOptions opts;
   opts.set_include_httponly();
-  opts.set_include_first_party_only_cookies();
+  opts.set_include_same_site();
   // Note that the callbacks in hook_map_ are wrapped with MakeAsync(), so they
   // are guaranteed to not take long - they just post a RunAsync task back to
   // the appropriate thread's message loop and return. It is important that this
   // method not run user-supplied callbacks directly, since the CookieMonster
   // lock is held and it is easy to accidentally introduce deadlocks.
   for (CookieChangedHookMap::iterator it = hook_map_.begin();
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, removed);
     }
   }
 }
 
 }  // namespace net