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

chrome/browser/net/sqlite_persistent_cookie_store_unittest.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.
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 81 matching lines @@
   // Adds a persistent cookie to store_.
   void AddCookie(const std::string& name,
                  const std::string& value,
                  const std::string& domain,
                  const std::string& path,
                  const base::Time& creation) {
     store_->AddCookie(
         CookieMonster::CanonicalCookie(GURL(), name, value, domain, path,
                                        std::string(), std::string(),
                                        creation, creation, creation,
-                                       false, false, true, true));
+                                       false, false));
   }
 
   virtual void SetUp() {
     ui_thread_.Start();
     db_thread_.Start();
     io_thread_.Start();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
  protected:
@@ skipping 215 matching lines @@
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
   InitializeStore(true);
 
   // Add a session cookie.
   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();
 
   // Create a store that loads session cookies and test that the session cookie
   // was loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(true, &cookies);
 
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("sessioncookie.com", cookies[0]->Domain().c_str());
   ASSERT_STREQ("C", cookies[0]->Name().c_str());
   ASSERT_STREQ("D", cookies[0]->Value().c_str());
 
   STLDeleteElements(&cookies);
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   InitializeStore(true);
 
   // Add a session cookie.
   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();
 
   // Create a store that doesn't load old session cookies and test that the
   // session cookie was not loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
   // The store should also delete the session cookie. Wait until that has been
   // done.
   DestroyStore();
 
   // Create a store that loads old session cookies and test that the session
   // cookie is gone.
   CreateAndLoad(true, &cookies);
   ASSERT_EQ(0U, cookies.size());
 }
 
-TEST_F(SQLitePersistentCookieStoreTest, PersistHasExpiresAndIsPersistent) {
+TEST_F(SQLitePersistentCookieStoreTest, PersistHasExpires) {

[erikwright (departed), 2012/07/11 13:56:34]

nit: rename to 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.
+  // Add a session cookie.
   store_->AddCookie(
       CookieMonster::CanonicalCookie(
-          GURL(), kSessionHasExpiresName, "val", "sessioncookie.com", "/",
+          GURL(), kSessionName, "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 */));
-  store_->AddCookie(
-      CookieMonster::CanonicalCookie(
-          GURL(), kSessionNoExpiresName, "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();
        it != cookies.end();
        ++it) {
     cookie_map[(*it)->Name()] = *it;
   }
 
   std::map<std::string, CookieMonster::CanonicalCookie*>::const_iterator it =
-      cookie_map.find(kSessionHasExpiresName);
+      cookie_map.find(kSessionName);
   ASSERT_TRUE(it != cookie_map.end());
-  EXPECT_TRUE(cookie_map[kSessionHasExpiresName]->DoesExpire());
-  EXPECT_FALSE(cookie_map[kSessionHasExpiresName]->IsPersistent());
-
-  it = cookie_map.find(kSessionNoExpiresName);
-  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);
 }
 
 namespace {
 
 // True if the given cookie is in the vector.
 bool IsCookiePresent(const CanonicalCookieVector& cookies,
                      const std::string& domain,
@@ skipping 41 matching lines @@
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("B", "2", session_origin, "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("C", "3", other_origin, "/", t);
   // A secure cookie on session_origin.
   t += base::TimeDelta::FromInternalValue(10);
   store_->AddCookie(
       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();
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store test that the cookie on session_origin does not exist.
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.path().Append(chrome::kCookieFilename),
@@ skipping 19 matching lines @@
   Load(&cookies);
 
   EXPECT_EQ(3U, cookies.size());
   EXPECT_TRUE(IsCookiePresent(cookies, protected_origin, "A", "1", false));
   EXPECT_TRUE(IsCookiePresent(cookies, other_origin, "C", "3", false));
   EXPECT_TRUE(IsCookiePresent(cookies, session_origin, "D", "4", true));
 
   DestroyStore();
   STLDeleteElements(&cookies);
 }