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

BUG=133903
TEST=none

TBR=sky@chromium.org,wtc@chromium.org


Review URL: https://chromiumcodereview.appspot.com/10694093

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@146121 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 40 insertions, 63 deletions

diff --git a/chrome/browser/automation/automation_util.cc b/chrome/browser/automation/automation_util.cc
index 86bfaec..12057f5 100644
--- a/chrome/browser/automation/automation_util.cc
+++ b/chrome/browser/automation/automation_util.cc
@@ -263,7 +263,7 @@ void GetCookiesJSON(AutomationProvider* provider,
     cookie_dict->SetString("domain", cookie.Domain());
     cookie_dict->SetBoolean("secure", cookie.IsSecure());
     cookie_dict->SetBoolean("http_only", cookie.IsHttpOnly());
-    if (cookie.DoesExpire())
+    if (cookie.IsPersistent())
       cookie_dict->SetDouble("expiry", cookie.ExpiryDate().ToDoubleT());
     list->Append(cookie_dict);
   }
@@ -368,7 +368,7 @@ void SetCookieJSON(AutomationProvider* provider,
       net::CookieMonster::CanonicalCookie::Create(
           GURL(url), name, value, domain, path,
           mac_key, mac_algorithm, base::Time(),
-          base::Time::FromDoubleT(expiry), secure, http_only, expiry != 0));
+          base::Time::FromDoubleT(expiry), secure, http_only));
   if (!cookie.get()) {
     reply.SendError("given 'cookie' parameters are invalid");
     return;
diff --git a/chrome/browser/extensions/api/cookies/cookies_helpers.cc b/chrome/browser/extensions/api/cookies/cookies_helpers.cc
index a139d5d..55917d5 100644
--- a/chrome/browser/extensions/api/cookies/cookies_helpers.cc
+++ b/chrome/browser/extensions/api/cookies/cookies_helpers.cc
@@ -70,8 +70,8 @@ DictionaryValue* CreateCookieValue(
                     IsStringUTF8(cookie.Path()) ? cookie.Path() : "");
   result->SetBoolean(keys::kSecureKey, cookie.IsSecure());
   result->SetBoolean(keys::kHttpOnlyKey, cookie.IsHttpOnly());
-  result->SetBoolean(keys::kSessionKey, !cookie.DoesExpire());
-  if (cookie.DoesExpire()) {
+  result->SetBoolean(keys::kSessionKey, !cookie.IsPersistent());
+  if (cookie.IsPersistent()) {
     result->SetDouble(keys::kExpirationDateKey,
                       cookie.ExpiryDate().ToDoubleT());
   }
@@ -155,7 +155,7 @@ bool MatchFilter::MatchesCookie(
          MatchesDomain(cookie.Domain()) &&
          MatchesString(keys::kPathKey, cookie.Path()) &&
          MatchesBoolean(keys::kSecureKey, cookie.IsSecure()) &&
-         MatchesBoolean(keys::kSessionKey, !cookie.DoesExpire());
+         MatchesBoolean(keys::kSessionKey, !cookie.IsPersistent());
 }
 
 bool MatchFilter::MatchesString(const char* key, const std::string& value) {
diff --git a/chrome/browser/extensions/api/cookies/cookies_unittest.cc b/chrome/browser/extensions/api/cookies/cookies_unittest.cc
index 05cf211..91c80f7 100644
--- a/chrome/browser/extensions/api/cookies/cookies_unittest.cc
+++ b/chrome/browser/extensions/api/cookies/cookies_unittest.cc
@@ -113,7 +113,7 @@ TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
       GURL(), "ABC", "DEF", "www.foobar.com", "/",
       std::string(), std::string(),
       base::Time(), base::Time(), base::Time(),
-      false, false, false, false);
+      false, false);
   scoped_ptr<DictionaryValue> cookie_value1(
       cookies_helpers::CreateCookieValue(
           cookie1, "some cookie store"));
@@ -141,7 +141,7 @@ TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
   net::CookieMonster::CanonicalCookie cookie2(
       GURL(), "ABC", "DEF", ".foobar.com", "/", std::string(), std::string(),
       base::Time(), base::Time::FromDoubleT(10000), base::Time(),
-      false, false, true, true);
+      false, false);
   scoped_ptr<DictionaryValue> cookie_value2(
       cookies_helpers::CreateCookieValue(
           cookie2, "some cookie store"));
@@ -168,7 +168,7 @@ TEST_F(ExtensionCookiesTest, GetURLFromCanonicalCookie) {
       GURL(), "ABC", "DEF", "www.foobar.com", "/",
       std::string(), std::string(),
       base::Time(), base::Time(), base::Time(),
-      false, false, false, false);
+      false, false);
   EXPECT_EQ("http://www.foobar.com/",
             cookies_helpers::GetURLFromCanonicalCookie(
                 cookie1).spec());
@@ -177,7 +177,7 @@ TEST_F(ExtensionCookiesTest, GetURLFromCanonicalCookie) {
       GURL(), "ABC", "DEF", ".helloworld.com", "/",
       std::string(), std::string(),
       base::Time(), base::Time(), base::Time(),
-      true, false, false, false);
+      true, false);
   EXPECT_EQ("https://helloworld.com/",
             cookies_helpers::GetURLFromCanonicalCookie(
                 cookie2).spec());
@@ -210,7 +210,7 @@ TEST_F(ExtensionCookiesTest, DomainMatching) {
     net::CookieMonster::CanonicalCookie cookie(GURL(), "", "", tests[i].domain,
                                                "", "", "", base::Time(),
                                                base::Time(), base::Time(),
-                                               false, false, false, false);
+                                               false, false);
     EXPECT_EQ(tests[i].matches, filter.MatchesCookie(cookie));
   }
 }
@@ -221,7 +221,7 @@ TEST_F(ExtensionCookiesTest, DecodeUTF8WithErrorHandling) {
                                              "test.com",
                                              "/path\203", "", "", base::Time(),
                                              base::Time(), base::Time(),
-                                             false, false, false, false);
+                                             false, false);
   scoped_ptr<DictionaryValue> cookie_value(
       cookies_helpers::CreateCookieValue(
           cookie, "some cookie store"));
diff --git a/chrome/browser/net/sqlite_persistent_cookie_store.cc b/chrome/browser/net/sqlite_persistent_cookie_store.cc
index 33ddb35..1d7f241 100644
--- a/chrome/browser/net/sqlite_persistent_cookie_store.cc
+++ b/chrome/browser/net/sqlite_persistent_cookie_store.cc
@@ -253,7 +253,7 @@ class SQLitePersistentCookieStore::Backend
 // database can store session cookies as well as persistent cookies. Databases
 // of version 5 are incompatible with older versions of code. If a database of
 // version 5 is read by older code, session cookies will be treated as normal
-// cookies.
+// cookies. Currently, these fields are written, but not read anymore.
 //
 // In version 4, we migrated the time epoch.  If you open the DB with an older
 // version on Mac or Linux, the times will look wonky, but the file will likely
@@ -627,9 +627,7 @@ bool SQLitePersistentCookieStore::Backend::LoadCookiesForDomains(
               Time::FromInternalValue(smt.ColumnInt64(5)),    // expires_utc
               Time::FromInternalValue(smt.ColumnInt64(8)),    // last_access_utc
               smt.ColumnInt(6) != 0,                          // secure
-              smt.ColumnInt(7) != 0,                          // httponly
-              smt.ColumnInt(9) != 0,                          // has_expires
-              smt.ColumnInt(10) != 0));                       // is_persistent
+              smt.ColumnInt(7) != 0));                        // httponly
       DLOG_IF(WARNING,
               cc->CreationDate() > Time::Now()) << L"CreationDate too recent";
       cookies_per_origin_[CookieOrigin(cc->Domain(), cc->IsSecure())]++;
@@ -854,7 +852,7 @@ void SQLitePersistentCookieStore::Backend::Commit() {
         add_smt.BindInt(6, po->cc().IsSecure());
         add_smt.BindInt(7, po->cc().IsHttpOnly());
         add_smt.BindInt64(8, po->cc().LastAccessDate().ToInternalValue());
-        add_smt.BindInt(9, po->cc().DoesExpire());
+        add_smt.BindInt(9, po->cc().IsPersistent());
         add_smt.BindInt(10, po->cc().IsPersistent());
         if (!add_smt.Run())
           NOTREACHED() << "Could not add a cookie to the DB.";
diff --git a/chrome/browser/net/sqlite_persistent_cookie_store_perftest.cc b/chrome/browser/net/sqlite_persistent_cookie_store_perftest.cc
index 8087e13..88d614fc 100644
--- a/chrome/browser/net/sqlite_persistent_cookie_store_perftest.cc
+++ b/chrome/browser/net/sqlite_persistent_cookie_store_perftest.cc
@@ -65,7 +65,7 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
           net::CookieMonster::CanonicalCookie(gurl,
             base::StringPrintf("Cookie_%d", cookie_num), "1",
             domain_name, "/", std::string(), std::string(),
-            t, t, t, false, false, true, true));
+            t, t, t, false, false));
       }
     }
     // Replace the store effectively destroying the current one and forcing it
diff --git a/chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc b/chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc
index 323c7ed..384332d 100644
--- a/chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc
+++ b/chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc
@@ -99,7 +99,7 @@ class SQLitePersistentCookieStoreTest : public testing::Test {
         CookieMonster::CanonicalCookie(GURL(), name, value, domain, path,
                                        std::string(), std::string(),
                                        creation, creation, creation,
-                                       false, false, true, true));
+                                       false, false));
   }
 
   virtual void SetUp() {
@@ -335,8 +335,8 @@ TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
   store_->AddCookie(
       CookieMonster::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", std::string(),
-          std::string(), base::Time::Now(), base::Time::Now(),
-          base::Time::Now(), false, false, true, false /*is_persistent*/));
+          std::string(), base::Time::Now(), base::Time(),
+          base::Time::Now(), false, false));
 
   // Force the store to write its data to the disk.
   DestroyStore();
@@ -362,8 +362,8 @@ TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   store_->AddCookie(
       CookieMonster::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", std::string(),
-          std::string(), base::Time::Now(), base::Time::Now(),
-          base::Time::Now(), false, false, true, false /*is_persistent*/));
+          std::string(), base::Time::Now(), base::Time(),
+          base::Time::Now(), false, false));
 
   // Force the store to write its data to the disk.
   DestroyStore();
@@ -384,45 +384,31 @@ TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   ASSERT_EQ(0U, cookies.size());
 }
 
-TEST_F(SQLitePersistentCookieStoreTest, PersistHasExpiresAndIsPersistent) {
+TEST_F(SQLitePersistentCookieStoreTest, PersistIsPersistent) {
   InitializeStore(true);
-  static const char kSessionHasExpiresName[] = "session-hasexpires";
-  static const char kSessionNoExpiresName[] = "session-noexpires";
+  static const char kSessionName[] = "session";
   static const char kPersistentName[] = "persistent";
 
-  // Add a session cookie with has_expires = false, and another session cookie
-  // with has_expires = true.
-  store_->AddCookie(
-      CookieMonster::CanonicalCookie(
-          GURL(), kSessionHasExpiresName, "val", "sessioncookie.com", "/",
-          std::string(), std::string(),
-          base::Time::Now() - base::TimeDelta::FromDays(3), base::Time::Now(),
-          base::Time::Now(), false, false, true /* has_expires */,
-          false /* is_persistent */));
+  // Add a session cookie.
   store_->AddCookie(
       CookieMonster::CanonicalCookie(
-          GURL(), kSessionNoExpiresName, "val", "sessioncookie.com", "/",
+          GURL(), kSessionName, "val", "sessioncookie.com", "/",
           std::string(), std::string(),
-          base::Time::Now() - base::TimeDelta::FromDays(2), base::Time::Now(),
-          base::Time::Now(), false, false, false /* has_expires */,
-          false /* is_persistent */));
+          base::Time::Now(), base::Time(), base::Time::Now(),
+          false, false));
   // Add a persistent cookie.
   store_->AddCookie(
       CookieMonster::CanonicalCookie(
           GURL(), kPersistentName, "val", "sessioncookie.com", "/",
           std::string(), std::string(),
           base::Time::Now() - base::TimeDelta::FromDays(1), base::Time::Now(),
-          base::Time::Now(), false, false, true /* has_expires */,
-          true /* is_persistent */));
+          base::Time::Now(), false, false));
 
-  // Force the store to write its data to the disk.
-  DestroyStore();
-
-  // Create a store that loads session cookies and test that the the DoesExpire
-  // and IsPersistent attributes are restored.
+  // Create a store that loads session cookie and test that the the IsPersistent
+  // attribute is restored.
   CanonicalCookieVector cookies;
   CreateAndLoad(true, &cookies);
-  ASSERT_EQ(3U, cookies.size());
+  ASSERT_EQ(2U, cookies.size());
 
   std::map<std::string, CookieMonster::CanonicalCookie*> cookie_map;
   for (CanonicalCookieVector::const_iterator it = cookies.begin();
@@ -432,19 +418,12 @@ TEST_F(SQLitePersistentCookieStoreTest, PersistHasExpiresAndIsPersistent) {
   }
 
   std::map<std::string, CookieMonster::CanonicalCookie*>::const_iterator it =
-      cookie_map.find(kSessionHasExpiresName);
-  ASSERT_TRUE(it != cookie_map.end());
-  EXPECT_TRUE(cookie_map[kSessionHasExpiresName]->DoesExpire());
-  EXPECT_FALSE(cookie_map[kSessionHasExpiresName]->IsPersistent());
-
-  it = cookie_map.find(kSessionNoExpiresName);
+      cookie_map.find(kSessionName);
   ASSERT_TRUE(it != cookie_map.end());
-  EXPECT_FALSE(cookie_map[kSessionNoExpiresName]->DoesExpire());
-  EXPECT_FALSE(cookie_map[kSessionNoExpiresName]->IsPersistent());
+  EXPECT_FALSE(cookie_map[kSessionName]->IsPersistent());
 
   it = cookie_map.find(kPersistentName);
   ASSERT_TRUE(it != cookie_map.end());
-  EXPECT_TRUE(cookie_map[kPersistentName]->DoesExpire());
   EXPECT_TRUE(cookie_map[kPersistentName]->IsPersistent());
 
   STLDeleteElements(&cookies);
@@ -506,7 +485,7 @@ TEST_F(SQLitePersistentCookieStoreTest, TestClearOnExitPolicy) {
       CookieMonster::CanonicalCookie(GURL(), "D", "4", session_origin, "/",
                                      std::string(), std::string(),
                                      t, t, t,
-                                     true, false, true, true));
+                                     true, false));
 
   // First, check that we can override the policy.
   store_->SetForceKeepSessionState();
diff --git a/chrome/browser/ui/cocoa/content_settings/cookie_details.mm b/chrome/browser/ui/cocoa/content_settings/cookie_details.mm
index 1b2a767..c36d084 100644
--- a/chrome/browser/ui/cocoa/content_settings/cookie_details.mm
+++ b/chrome/browser/ui/cocoa/content_settings/cookie_details.mm
@@ -121,14 +121,14 @@
    canEditExpiration:(BOOL)canEditExpiration {
   if ((self = [super init])) {
     type_ = kCocoaCookieDetailsTypeCookie;
-    hasExpiration_ = cookie->DoesExpire();
+    hasExpiration_ = cookie->IsPersistent();
     canEditExpiration_ = canEditExpiration && hasExpiration_;
     name_.reset([base::SysUTF8ToNSString(cookie->Name()) retain]);
     content_.reset([base::SysUTF8ToNSString(cookie->Value()) retain]);
     path_.reset([base::SysUTF8ToNSString(cookie->Path()) retain]);
     domain_.reset([origin retain]);
 
-    if (cookie->DoesExpire()) {
+    if (cookie->IsPersistent()) {
       expires_.reset([base::SysUTF16ToNSString(
           base::TimeFormatFriendlyDateAndTime(cookie->ExpiryDate())) retain]);
     } else {
diff --git a/chrome/browser/ui/gtk/gtk_chrome_cookie_view.cc b/chrome/browser/ui/gtk/gtk_chrome_cookie_view.cc
index 07a3701..bccd044 100644
--- a/chrome/browser/ui/gtk/gtk_chrome_cookie_view.cc
+++ b/chrome/browser/ui/gtk/gtk_chrome_cookie_view.cc
@@ -478,7 +478,7 @@ void gtk_chrome_cookie_view_display_cookie(
                      UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
                          cookie.CreationDate())).c_str());
 
-  std::string expire_text = cookie.DoesExpire() ?
+  std::string expire_text = cookie.IsPersistent() ?
       UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) :
       l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION);
 
@@ -490,7 +490,7 @@ void gtk_chrome_cookie_view_display_cookie(
     GtkTreeIter iter;
     gtk_list_store_clear(store);
 
-    if (cookie.DoesExpire()) {
+    if (cookie.IsPersistent()) {
       gtk_list_store_append(store, &iter);
       gtk_list_store_set(store, &iter, 0, expire_text.c_str(), -1);
     }
diff --git a/chrome/browser/ui/views/cookie_info_view.cc b/chrome/browser/ui/views/cookie_info_view.cc
index 758acf8..0b930d2 100644
--- a/chrome/browser/ui/views/cookie_info_view.cc
+++ b/chrome/browser/ui/views/cookie_info_view.cc
@@ -68,13 +68,13 @@ void CookieInfoView::SetCookie(
   created_value_field_->SetText(
       base::TimeFormatFriendlyDateAndTime(cookie.CreationDate()));
 
-  string16 expire_text = cookie.DoesExpire() ?
+  string16 expire_text = cookie.IsPersistent() ?
       base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate()) :
       l10n_util::GetStringUTF16(IDS_COOKIES_COOKIE_EXPIRES_SESSION);
 
   if (editable_expiration_date_) {
     expire_combo_values_.clear();
-    if (cookie.DoesExpire())
+    if (cookie.IsPersistent())
       expire_combo_values_.push_back(expire_text);
     expire_combo_values_.push_back(
         l10n_util::GetStringUTF16(IDS_COOKIES_COOKIE_EXPIRES_SESSION));
diff --git a/chrome/browser/ui/webui/cookies_tree_model_util.cc b/chrome/browser/ui/webui/cookies_tree_model_util.cc
index 318148d..64cef46 100644
--- a/chrome/browser/ui/webui/cookies_tree_model_util.cc
+++ b/chrome/browser/ui/webui/cookies_tree_model_util.cc
@@ -119,7 +119,7 @@ bool CookiesTreeModelUtil::GetCookieTreeNodeDictionary(
       dict->SetString(kKeyAccessibleToScript, accessible);
       dict->SetString(kKeyCreated, UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(cookie.CreationDate())));
-      dict->SetString(kKeyExpires, cookie.DoesExpire() ? UTF16ToUTF8(
+      dict->SetString(kKeyExpires, cookie.IsPersistent() ? UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) :
           l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION));