Remove ENABLE_PERSISTENT_SESSION_COOKIES

net/cookies/canonical_cookie.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 42 matching lines @@
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace net {
 
 namespace {
 
-#if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
-const int kPersistentSessionCookieExpiryInDays = 14;
-#endif
-
 // Determine the cookie domain to use for setting the specified cookie.
 bool GetCookieDomain(const GURL& url,
                      const ParsedCookie& pc,
                      std::string* result) {
   std::string domain_string;
   if (pc.HasDomain())
     domain_string = pc.Domain();
   return cookie_util::GetCookieDomainWithString(url, domain_string, result);
 }
 
@@ skipping 25 matching lines @@
 
   // Return up to the rightmost '/'.
   return url_path.substr(0, idx);
 }
 
 }  // namespace
 
 CanonicalCookie::CanonicalCookie()
     : secure_(false),
       httponly_(false) {
-  SetSessionCookieExpiryTime();
 }
 
 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)
     : 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) {
-  if (expiration.is_null())
-    SetSessionCookieExpiryTime();
 }
 
 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()) {
   if (pc.HasExpires())
     expiry_date_ = CanonExpiration(pc, creation_date_, 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();
   }
   bool result
       = cookie_util::GetCookieDomainWithString(url, domain_string,
                                                 &cookie_domain);
@@ skipping 45 matching lines @@
   // Try the Expires attribute.
   if (pc.HasExpires()) {
     // Adjust for clock skew between server and host.
     return current + (cookie_util::ParseCookieTime(pc.Expires()) - server_time);
   }
 
   // Invalid or no expiration, persistent cookie.
   return Time();
 }
 
-void 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);
-#endif
-}
-
 CanonicalCookie* 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;
   }
@@ skipping 135 matching lines @@
 std::string 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 net