Implement Origin cookies.

net/base/cookie_monster.cc

 // Copyright (c) 2010 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 631 matching lines @@
 
   *result = cookie_domain;
   return true;
 }
 
 // Determine the cookie domain to use for setting the specified cookie.
 static bool GetCookieDomain(const GURL& url,
                             const CookieMonster::ParsedCookie& pc,
                             std::string* result) {
   std::string domain_string;
-  if (pc.HasDomain())
+  if (pc.HasDomain() && !pc.IsOrigin())
     domain_string = pc.Domain();
   return GetCookieDomainWithString(url, domain_string, result);
 }
 
 static std::string CanonPathWithString(const GURL& url,
                                        const std::string& path_string) {
   // The RFC says the path should be a prefix of the current URL path.
   // However, Mozilla allows you to set any path for compatibility with
   // broken websites.  We unfortunately will mimic this behavior.  We try
   // to be generous and accept cookies with an invalid path attribute, and
@@ skipping 113 matching lines @@
     return false;
   }
 
   std::string cookie_domain;
   if (!GetCookieDomain(url, pc, &cookie_domain)) {
     return false;
   }
 
   std::string cookie_path = CanonPath(url, pc);
 
+  bool cookie_secure = pc.IsOrigin() ? url.SchemeIsSecure() : pc.IsSecure();
+
   scoped_ptr<CanonicalCookie> cc;
   Time cookie_expires = CanonExpiration(pc, creation_time, options);
 
   cc.reset(new CanonicalCookie(pc.Name(), pc.Value(), cookie_domain,
-                               cookie_path,
-                               pc.IsSecure(), pc.IsHttpOnly(),
+                               cookie_path, cookie_secure,
+                               pc.IsHttpOnly(), pc.IsOrigin(),
                                creation_time, creation_time,
                                !cookie_expires.is_null(), cookie_expires));
 
   if (!cc.get()) {
     VLOG(kVlogSetCookies) << "WARNING: Failed to allocate CanonicalCookie";
     return false;
   }
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
   AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
 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) {
+    const base::Time& expiration_time,
+    bool secure, bool http_only, bool origin) {
 
   AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
   InitIfNecessary();
 
   Time creation_time = CurrentTime();
   last_time_seen_ = creation_time;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(
       url, name, value, domain, path,
       creation_time, expiration_time,
-      secure, http_only));
+      secure, http_only, origin));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
@@ skipping 585 matching lines @@
     // If the cookie is expired, delete it.
     if (cc->IsExpired(current)) {
       InternalDeleteCookie(curit, true, DELETE_COOKIE_EXPIRED);
       continue;
     }
 
     // Filter out HttpOnly cookies, per options.
     if (options.exclude_httponly() && cc->IsHttpOnly())
       continue;
 
+    if (options.read_origin() != cc->IsOrigin())
+      continue;
+
     // Filter out secure cookies unless we're https.
     if (!secure && cc->IsSecure())
       continue;
 
     // Filter out cookies that don't apply to this domain.
     if (expiry_and_key_scheme_ == EKS_KEEP_RECENT_AND_PURGE_ETLDP1
         && !cc->IsDomainMatch(scheme, host))
       continue;
 
     if (!cc->IsOnPath(url.path()))
@@ skipping 63 matching lines @@
   last_statistic_record_time_ = current_time;
 }
 
 CookieMonster::ParsedCookie::ParsedCookie(const std::string& cookie_line)
     : is_valid_(false),
       path_index_(0),
       domain_index_(0),
       expires_index_(0),
       maxage_index_(0),
       secure_index_(0),
-      httponly_index_(0) {
+      httponly_index_(0),
+      origin_index_(0) {
 
   if (cookie_line.size() > kMaxCookieSize) {
     VLOG(1) << "Not parsing cookie, too large: " << cookie_line.size();
     return;
   }
 
   ParseTokenValuePairs(cookie_line);
   if (pairs_.size() > 0) {
     is_valid_ = true;
     SetupAttributes();
@@ skipping 214 matching lines @@
   }
 }
 
 void CookieMonster::ParsedCookie::SetupAttributes() {
   static const char kPathTokenName[]      = "path";
   static const char kDomainTokenName[]    = "domain";
   static const char kExpiresTokenName[]   = "expires";
   static const char kMaxAgeTokenName[]    = "max-age";
   static const char kSecureTokenName[]    = "secure";
   static const char kHttpOnlyTokenName[]  = "httponly";
+  static const char kOriginTokenName[]    = "origin";
 
   // We skip over the first token/value, the user supplied one.
   for (size_t i = 1; i < pairs_.size(); ++i) {
     if (pairs_[i].first == kPathTokenName) {
       path_index_ = i;
     } else if (pairs_[i].first == kDomainTokenName) {
       domain_index_ = i;
     } else if (pairs_[i].first == kExpiresTokenName) {
       expires_index_ = i;
     } else if (pairs_[i].first == kMaxAgeTokenName) {
       maxage_index_ = i;
     } else if (pairs_[i].first == kSecureTokenName) {
       secure_index_ = i;
     } else if (pairs_[i].first == kHttpOnlyTokenName) {
       httponly_index_ = i;
+    } else if (pairs_[i].first == kOriginTokenName) {
+      origin_index_ = i;
     } else {
       /* some attribute we don't know or don't care about. */
     }
   }
 }
 
 // Create a cookie-line for the cookie.  For debugging only!
 // If we want to use this for something more than debugging, we
 // should rewrite it better...
 std::string CookieMonster::ParsedCookie::DebugString() const {
   std::string out;
   for (PairList::const_iterator it = pairs_.begin();
        it != pairs_.end(); ++it) {
     out.append(it->first);
     out.append("=");
     out.append(it->second);
     out.append("; ");
   }
   return out;
 }
 
+// TODO(abarth): Do we need to initialize the boolean members here?
 CookieMonster::CanonicalCookie::CanonicalCookie() {
 }
 
 CookieMonster::CanonicalCookie::CanonicalCookie(const std::string& name,
                                                 const std::string& value,
                                                 const std::string& domain,
                                                 const std::string& path,
                                                 bool secure,
                                                 bool httponly,
+                                                bool origin,
                                                 const base::Time& creation,
                                                 const base::Time& last_access,
                                                 bool has_expires,
                                                 const base::Time& expires)
     : name_(name),
     value_(value),
     domain_(domain),
     path_(path),
     creation_date_(creation),
     last_access_date_(last_access),
     expiry_date_(expires),
     has_expires_(has_expires),
     secure_(secure),
-    httponly_(httponly) {
+    httponly_(httponly),
+    origin_(origin) {
 }
 
 CookieMonster::CanonicalCookie::CanonicalCookie(const GURL& url,
                                                 const ParsedCookie& pc)
     : name_(pc.Name()),
       value_(pc.Value()),
       path_(CanonPath(url, pc)),
       creation_date_(Time::Now()),
       last_access_date_(Time()),
       has_expires_(pc.HasExpires()),
       secure_(pc.IsSecure()),
-      httponly_(pc.IsHttpOnly()) {
+      httponly_(pc.IsHttpOnly()),
+      origin_(pc.IsOrigin()) {
   if (has_expires_)
     expiry_date_ = CanonExpiration(pc, creation_date_, CookieOptions());
 
   // Do the best we can with the domain.
   std::string cookie_domain;
   std::string domain_string;
   if (pc.HasDomain()) {
     domain_string = pc.Domain();
   }
   bool result
@@ skipping 18 matching lines @@
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CanonicalCookie::~CanonicalCookie() {
 }
 
 CookieMonster::CanonicalCookie* CookieMonster::CanonicalCookie::Create(
       const GURL& url, const std::string& name, const std::string& value,
       const std::string& domain, const std::string& path,
       const base::Time& creation_time, const base::Time& expiration_time,
-      bool secure, bool http_only) {
+      bool secure, bool http_only, bool origin) {
   // Expect valid attribute tokens and values, as defined by the ParsedCookie
   // logic, otherwise don't create the cookie.
   std::string parsed_name = ParsedCookie::ParseTokenString(name);
   if (parsed_name != name)
     return NULL;
   std::string parsed_value = ParsedCookie::ParseValueString(value);
   if (parsed_value != value)
     return NULL;
 
   std::string parsed_domain = ParsedCookie::ParseValueString(domain);
@@ skipping 14 matching lines @@
   // Canonicalize path again to make sure it escapes characters as needed.
   url_parse::Component path_component(0, cookie_path.length());
   url_canon::RawCanonOutputT<char> canon_path;
   url_parse::Component canon_path_component;
   url_canon::CanonicalizePath(cookie_path.data(), path_component,
                               &canon_path, &canon_path_component);
   cookie_path = std::string(canon_path.data() + canon_path_component.begin,
                             canon_path_component.len);
 
   return new CanonicalCookie(parsed_name, parsed_value, cookie_domain,
-                             cookie_path, secure, http_only,
+                             cookie_path, secure, http_only, origin,
                              creation_time, creation_time,
                              !expiration_time.is_null(), expiration_time);
 }
 
 bool CookieMonster::CanonicalCookie::IsOnPath(
     const std::string& url_path) const {
 
   // A zero length would be unsafe for our trailing '/' checks, and
   // would also make no sense for our prefix match.  The code that
   // creates a CanonicalCookie should make sure the path is never zero length,
@@ skipping 66 matching lines @@
   return base::StringPrintf(
       "name: %s value: %s domain: %s path: %s creation: %"
       PRId64,
       name_.c_str(), value_.c_str(),
       domain_.c_str(), path_.c_str(),
       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace