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

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 1174 matching lines @@
 
   // TODO(abarth): Take these values as parameters.
   std::string mac_key;
   std::string mac_algorithm;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(
       url, name, value, domain, path,
       mac_key, mac_algorithm,
       creation_time, expiration_time,
-      secure, http_only, !expiration_time.is_null()));
+      secure, http_only));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::InitializeFrom(const CookieList& list) {
@@ skipping 703 matching lines @@
   }
 
   std::string cookie_path = CanonPath(url, pc);
   std::string mac_key = pc.HasMACKey() ? pc.MACKey() : std::string();
   std::string mac_algorithm = pc.HasMACAlgorithm() ?
       pc.MACAlgorithm() : std::string();
 
   scoped_ptr<CanonicalCookie> cc;
   Time cookie_expires = CanonExpiration(pc, creation_time);
 
-  bool session_only = options.force_session() || cookie_expires.is_null();
   cc.reset(new CanonicalCookie(url, pc.Name(), pc.Value(), cookie_domain,
                                cookie_path, mac_key, mac_algorithm,
                                creation_time, cookie_expires,
-                               creation_time, pc.IsSecure(), pc.IsHttpOnly(),
-                               !cookie_expires.is_null(),
-                               !session_only));
+                               creation_time, pc.IsSecure(), pc.IsHttpOnly()));
 
   if (!cc.get()) {
     VLOG(kVlogSetCookies) << "WARNING: Failed to allocate CanonicalCookie";
     return false;
   }
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                                        const Time& creation_time,
                                        const CookieOptions& options) {
   const std::string key(GetKey((*cc)->Domain()));
   bool already_expired = (*cc)->IsExpired(creation_time);
   if (DeleteAnyEquivalentCookie(key, **cc, options.exclude_httponly(),
                                 already_expired)) {
     VLOG(kVlogSetCookies) << "SetCookie() not clobbering httponly cookie";
     return false;
   }
 
   VLOG(kVlogSetCookies) << "SetCookie() key: " << key << " cc: "
                         << (*cc)->DebugString();
 
   // Realize that we might be setting an expired cookie, and the only point
   // was to delete the cookie which we've already done.
   if (!already_expired || keep_expired_cookies_) {
     // See InitializeHistograms() for details.
-    if ((*cc)->DoesExpire()) {
+    if ((*cc)->IsPersistent()) {
       histogram_expiration_duration_minutes_->Add(
           ((*cc)->ExpiryDate() - creation_time).InMinutes());
     }
 
     InternalInsertCookie(key, cc->release(), true);
   }
 
   // We assume that hopefully setting a cookie will be less common than
   // querying a cookie.  Since setting a cookie can put us over our limits,
   // make sure that we garbage collect...  We can also make the assumption that
@@ skipping 639 matching lines @@
     } else if (pairs_[i].first == kHttpOnlyTokenName) {
       httponly_index_ = i;
     } else {
       /* some attribute we don't know or don't care about. */
     }
   }
 }
 
 CookieMonster::CanonicalCookie::CanonicalCookie()
     : secure_(false),
-      httponly_(false),
-      has_expires_(false),
-      is_persistent_(false) {
+      httponly_(false) {
   SetSessionCookieExpiryTime();
 }
 
 CookieMonster::CanonicalCookie::CanonicalCookie(
     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,
-    const base::Time& last_access, bool secure, bool httponly, bool has_expires,
-    bool is_persistent)
+    const base::Time& last_access, bool secure, bool httponly)
     : source_(GetCookieSourceFromURL(url)),
       name_(name),
       value_(value),
       domain_(domain),
       path_(path),
       mac_key_(mac_key),
       mac_algorithm_(mac_algorithm),
       creation_date_(creation),
       expiry_date_(expiration),
       last_access_date_(last_access),
       secure_(secure),
-      httponly_(httponly),
-      has_expires_(has_expires),
-      is_persistent_(is_persistent) {
-  if (!has_expires_) {
-    DCHECK(!is_persistent_);
+      httponly_(httponly) {
+  if (expiration.is_null())
     SetSessionCookieExpiryTime();
-  }
 }
 
 CookieMonster::CanonicalCookie::CanonicalCookie(const GURL& url,
                                                 const ParsedCookie& pc)
     : source_(GetCookieSourceFromURL(url)),
       name_(pc.Name()),
       value_(pc.Value()),
       path_(CanonPath(url, pc)),
       mac_key_(pc.MACKey()),
       mac_algorithm_(pc.MACAlgorithm()),
       creation_date_(Time::Now()),
       last_access_date_(Time()),
       secure_(pc.IsSecure()),
-      httponly_(pc.IsHttpOnly()),
-      has_expires_(pc.HasExpires()),
-      is_persistent_(pc.HasExpires()) {
-  if (has_expires_)
+      httponly_(pc.IsHttpOnly()) {
+  if (pc.HasExpires())
     expiry_date_ = CanonExpiration(pc, creation_date_);
   else
     SetSessionCookieExpiryTime();
 
   // Do the best we can with the domain.
   std::string cookie_domain;
   std::string domain_string;
   if (pc.HasDomain()) {
     domain_string = pc.Domain();
   }
@@ skipping 20 matching lines @@
 
   return url.GetOrigin().ReplaceComponents(replacements).spec();
 }
 
 void CookieMonster::CanonicalCookie::SetSessionCookieExpiryTime() {
 #if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
   // Mobile apps can sometimes be shut down without any warning, so the session
   // cookie has to be persistent and given a default expiration time.
   expiry_date_ = base::Time::Now() +
       base::TimeDelta::FromDays(kPersistentSessionCookieExpiryInDays);
-  has_expires_ = true;
 #endif
 }
 
 CookieMonster::CanonicalCookie* CookieMonster::CanonicalCookie::Create(
     const GURL& url,
     const ParsedCookie& pc) {
   if (!pc.IsValid()) {
     return NULL;
   }
 
   std::string domain_string;
   if (!GetCookieDomain(url, pc, &domain_string)) {
     return NULL;
   }
   std::string path_string = CanonPath(url, pc);
   std::string mac_key = pc.HasMACKey() ? pc.MACKey() : std::string();
   std::string mac_algorithm = pc.HasMACAlgorithm() ?
       pc.MACAlgorithm() : std::string();
   Time creation_time = Time::Now();
   Time expiration_time;
   if (pc.HasExpires())
     expiration_time =  net::CookieMonster::ParseCookieTime(pc.Expires());
 
   return (Create(url, pc.Name(), pc.Value(), domain_string, path_string,
                  mac_key, mac_algorithm, creation_time, expiration_time,
-                 pc.IsSecure(), pc.IsHttpOnly(), !expiration_time.is_null()));
+                 pc.IsSecure(), pc.IsHttpOnly()));
 }
 
 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 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) {
   // 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 17 matching lines @@
   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(url, parsed_name, parsed_value, cookie_domain,
                              cookie_path, mac_key, mac_algorithm, creation,
-                             expiration, creation, secure, http_only,
-                             !expiration.is_null(), is_persistent);
+                             expiration, creation, secure, http_only);
 }
 
 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,
   // but we double check anyway.
   if (path_.empty())
@@ skipping 64 matching lines @@
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   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