Implement Origin cookies.

net/base/cookie_monster.h

 // 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 #pragma once
 
@@ skipping 141 matching lines @@
   // function expects each attribute to be well-formed. It will check for
   // disallowed characters (e.g. the ';' character is disallowed within the
   // cookie value attribute) and will return false without setting the cookie
   // if such characters are found.
   bool 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 secure, bool http_only, bool origin);
 
   // Returns all the cookies, for use in management UI, etc. This does not mark
   // the cookies as having been accessed.
   // The returned cookies are ordered by longest path, then by earliest
   // creation date.
   CookieList GetAllCookies();
 
   // Returns all the cookies, for use in management UI, etc. Filters results
   // using given url scheme, host / domain and path. This does not mark the
   // cookies as having been accessed.
@@ skipping 307 matching lines @@
   // the resulting CanonicalCookies should not be relied on to be canonical
   // unless the caller has done appropriate validation and canonicalization
   // themselves.
   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);
 
   // This constructor does canonicalization but not validation.
   // The result of this constructor should not be relied on in contexts
   // in which pre-validation of the ParsedCookie has not been done.
   CanonicalCookie(const GURL& url, const ParsedCookie& pc);
 
   ~CanonicalCookie();
 
   // Supports the default copy constructor.
 
   // Creates a canonical cookie from unparsed attribute values.
   // Canonicalizes and validates inputs.  May return NULL if an attribute
   // value is invalid.
   static 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);
 
   const std::string& Name() const { return name_; }
   const std::string& Value() const { return value_; }
   const std::string& Domain() const { return domain_; }
   const std::string& Path() const { return path_; }
   const base::Time& CreationDate() const { return creation_date_; }
   const base::Time& LastAccessDate() const { return last_access_date_; }
   bool DoesExpire() const { return has_expires_; }
   bool IsPersistent() const { return DoesExpire(); }
   const base::Time& ExpiryDate() const { return expiry_date_; }
   bool IsSecure() const { return secure_; }
   bool IsHttpOnly() const { return httponly_; }
+  bool IsOrigin() const { return origin_; }
   bool IsDomainCookie() const {
     return !domain_.empty() && domain_[0] == '.'; }
   bool IsHostCookie() const { return !IsDomainCookie(); }
 
   bool IsExpired(const base::Time& current) {
     return has_expires_ && current >= expiry_date_;
   }
 
   // Are the cookies considered equivalent in the eyes of RFC 2965.
   // The RFC says that name must match (case-sensitive), domain must
   // match (case insensitive), and path must match (case sensitive).
   // For the case insensitive domain compare, we rely on the domain
   // having been canonicalized (in
   // GetCookieDomainWithString->CanonicalizeHost).
   bool IsEquivalent(const CanonicalCookie& ecc) const {
-    // It seems like it would make sense to take secure and httponly into
-    // account, but the RFC doesn't specify this.
-    // NOTE: Keep this logic in-sync with TrimDuplicateCookiesForHost().
-    return (name_ == ecc.Name() && domain_ == ecc.Domain()
-            && path_ == ecc.Path());
+    if (origin_ != ecc.IsOrigin())
+      return false;
+    if (origin_ && secure_ != ecc.IsSecure())
+      return false;
+    return (name_ == ecc.Name() &&
+            domain_ == ecc.Domain() &&
+            path_ == ecc.Path());
   }
 
   void SetLastAccessDate(const base::Time& date) {
     last_access_date_ = date;
   }
 
   bool IsOnPath(const std::string& url_path) const;
   bool IsDomainMatch(const std::string& scheme, const std::string& host) const;
 
   std::string DebugString() const;
  private:
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
   base::Time creation_date_;
   base::Time last_access_date_;
   base::Time expiry_date_;
   bool has_expires_;
   bool secure_;
   bool httponly_;
+  bool origin_;
 };
 
 class CookieMonster::Delegate
     : public base::RefCountedThreadSafe<CookieMonster::Delegate> {
  public:
   // Will be called when a cookie is added or removed. The function is passed
   // the respective |cookie| which was added to or removed from the cookies.
   // If |removed| is true, the cookie was deleted.
   virtual void OnCookieChanged(const CookieMonster::CanonicalCookie& cookie,
                                bool removed) = 0;
@@ skipping 26 matching lines @@
   bool HasPath() const { return path_index_ != 0; }
   const std::string& Path() const { return pairs_[path_index_].second; }
   bool HasDomain() const { return domain_index_ != 0; }
   const std::string& Domain() const { return pairs_[domain_index_].second; }
   bool HasExpires() const { return expires_index_ != 0; }
   const std::string& Expires() const { return pairs_[expires_index_].second; }
   bool HasMaxAge() const { return maxage_index_ != 0; }
   const std::string& MaxAge() const { return pairs_[maxage_index_].second; }
   bool IsSecure() const { return secure_index_ != 0; }
   bool IsHttpOnly() const { return httponly_index_ != 0; }
+  bool IsOrigin() const { return origin_index_ != 0; }
 
   // Returns the number of attributes, for example, returning 2 for:
   //   "BLAH=hah; path=/; domain=.google.com"
   size_t NumberOfAttributes() const { return pairs_.size() - 1; }
 
   // For debugging only!
   std::string DebugString() const;
 
   // Returns an iterator pointing to the first terminator character found in
   // the given string.
@@ skipping 38 matching lines @@
   // These will default to 0, but that should never be valid since the
   // 0th index is the user supplied token/value, not an attribute.
   // We're really never going to have more than like 8 attributes, so we
   // could fit these into 3 bits each if we're worried about size...
   size_t path_index_;
   size_t domain_index_;
   size_t expires_index_;
   size_t maxage_index_;
   size_t secure_index_;
   size_t httponly_index_;
+  size_t origin_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParsedCookie);
 };
 
 typedef base::RefCountedThreadSafe<CookieMonster::PersistentCookieStore>
     RefcountedPersistentCookieStore;
 
 class CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
  public:
@@ skipping 10 matching lines @@
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_