SameSite: Implement 'Strict'/'Lax' attribute parsing.

net/cookies/canonical_cookie.h

 // 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.
 
 #ifndef NET_COOKIES_CANONICAL_COOKIE_H_
 #define NET_COOKIES_CANONICAL_COOKIE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 20 matching lines @@
   CanonicalCookie(const GURL& url,
                   const std::string& name,
                   const std::string& value,
                   const std::string& domain,
                   const std::string& path,
                   const base::Time& creation,
                   const base::Time& expiration,
                   const base::Time& last_access,
                   bool secure,
                   bool httponly,
-                  bool same_site,
+                  CookieSameSite same_site,
                   CookiePriority priority);
 
   // 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(const CanonicalCookie& other);
 
   ~CanonicalCookie();
@@ skipping 13 matching lines @@
   // value is invalid.
   static scoped_ptr<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,
                                             const base::Time& expiration,
                                             bool secure,
                                             bool http_only,
-                                            bool same_site,
+                                            CookieSameSite same_site,
                                             bool enforce_strict_secure,
                                             CookiePriority priority);
 
   const GURL& Source() const { return source_; }
   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 IsPersistent() const { return !expiry_date_.is_null(); }
   const base::Time& ExpiryDate() const { return expiry_date_; }
   bool IsSecure() const { return secure_; }
   bool IsHttpOnly() const { return httponly_; }
-  bool IsSameSite() const { return same_site_; }
+  CookieSameSite SameSite() const { return same_site_; }
   CookiePriority Priority() const { return priority_; }
   bool IsDomainCookie() const {
     return !domain_.empty() && domain_[0] == '.'; }
   bool IsHostCookie() const { return !IsDomainCookie(); }
 
   bool IsExpired(const base::Time& current) const {
     return !expiry_date_.is_null() && current >= expiry_date_;
   }
 
   // Are the cookies considered equivalent in the eyes of RFC 2965.
@@ skipping 98 matching lines @@
   GURL source_;
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
   base::Time creation_date_;
   base::Time expiry_date_;
   base::Time last_access_date_;
   bool secure_;
   bool httponly_;
-  bool same_site_;
+  CookieSameSite same_site_;
   CookiePriority priority_;
 };
 
 typedef std::vector<CanonicalCookie> CookieList;
 
 }  // namespace net
 
 #endif  // NET_COOKIES_CANONICAL_COOKIE_H_