Remove the force_session cookie option, as it's not used anymore

net/cookies/cookie_monster.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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_H_
 #define NET_COOKIES_COOKIE_MONSTER_H_
 #pragma once
 
@@ skipping 662 matching lines @@
                   const std::string& name,
                   const std::string& value,
                   const std::string& domain,
                   const std::string& path,
                   const std::string& mac_key,
                   const std::string& mac_algorithm,
                   const base::Time& creation,
                   const base::Time& expiration,
                   const base::Time& last_access,
                   bool secure,
-                  bool httponly,
-                  bool has_expires,
-                  bool is_persistent);
+                  bool httponly);
 
   // 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 parsed cookie.
   // Canonicalizes and validates inputs.  May return NULL if an attribute
   // value is invalid.
   static CanonicalCookie* Create(const GURL& url,
                                  const ParsedCookie& pc);
 
   // 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 std::string& mac_key,
                                  const std::string& mac_algorithm,
                                  const base::Time& creation,
                                  const base::Time& expiration,
                                  bool secure,
-                                 bool http_only,
-                                 bool is_persistent);
+                                 bool http_only);
 
   const std::string& 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 std::string& MACKey() const { return mac_key_; }
   const std::string& MACAlgorithm() const { return mac_algorithm_; }
   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 is_persistent_; }
+  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 IsDomainCookie() const {
     return !domain_.empty() && domain_[0] == '.'; }
   bool IsHostCookie() const { return !IsDomainCookie(); }
 
   bool IsExpired(const base::Time& current) {
-    return has_expires_ && current >= expiry_date_;
+    return !expiry_date_.is_null() && 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
@@ skipping 34 matching lines @@
   std::string value_;
   std::string domain_;
   std::string path_;
   std::string mac_key_;  // TODO(abarth): Persist to disk.
   std::string mac_algorithm_;  // TODO(abarth): Persist to disk.
   base::Time creation_date_;
   base::Time expiry_date_;
   base::Time last_access_date_;
   bool secure_;
   bool httponly_;
-  bool has_expires_;
-  bool is_persistent_;
 };
 
 class CookieMonster::Delegate
     : public base::RefCountedThreadSafe<CookieMonster::Delegate> {
  public:
   // The publicly relevant reasons a cookie might be changed.
   enum ChangeCause {
     // The cookie was changed directly by a consumer's action.
     CHANGE_COOKIE_EXPLICIT,
     // The cookie was automatically removed due to an insert operation that
@@ skipping 167 matching lines @@
   friend class base::RefCountedThreadSafe<PersistentCookieStore>;
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 class CookieList : public std::vector<CookieMonster::CanonicalCookie> {
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_H_