SessionRestore: Store session cookies and restore them if chrome crashes or auto-restarts.

chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
@@ skipping 43 matching lines @@
   void WaitOnDBEvent() {
     db_thread_event_.Wait();
   }
 
   virtual void SetUp() {
     ui_thread_.Start();
     db_thread_.Start();
     io_thread_.Start();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     store_ = new SQLitePersistentCookieStore(
-        temp_dir_.path().Append(chrome::kCookieFilename));
+        temp_dir_.path().Append(chrome::kCookieFilename), false);
     std::vector<net::CookieMonster::CanonicalCookie*> cookies;
     Load(&cookies);
     ASSERT_EQ(0u, cookies.size());
     // Make sure the store gets written at least once.
     store_->AddCookie(
         net::CookieMonster::CanonicalCookie(GURL(), "A", "B", "http://foo.bar",
                                             "/", std::string(), std::string(),
                                             base::Time::Now(),
                                             base::Time::Now(),
                                             base::Time::Now(),
@@ skipping 49 matching lines @@
   // Replace the store effectively destroying the current one and forcing it
   // to write it's data to disk. Then we can see if after loading it again it
   // is still there.
   store_ = NULL;
   scoped_refptr<base::ThreadTestHelper> helper(
       new base::ThreadTestHelper(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   // Make sure we wait until the destructor has run.
   ASSERT_TRUE(helper->Run());
   store_ = new SQLitePersistentCookieStore(
-      temp_dir_.path().Append(chrome::kCookieFilename));
+      temp_dir_.path().Append(chrome::kCookieFilename), false);
 
   // Reload and test for persistence
   Load(&cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("http://foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
 
   // Now delete the cookie and check persistence again.
   store_->DeleteCookie(*cookies[0]);
   store_ = NULL;
   // Make sure we wait until the destructor has run.
   ASSERT_TRUE(helper->Run());
   STLDeleteContainerPointers(cookies.begin(), cookies.end());
   cookies.clear();
   store_ = new SQLitePersistentCookieStore(
-      temp_dir_.path().Append(chrome::kCookieFilename));
+      temp_dir_.path().Append(chrome::kCookieFilename), false);
 
   // Reload and check if the cookie has been removed.
   Load(&cookies);
   ASSERT_EQ(0U, cookies.size());
 }
 
 // Test that priority load of cookies for a specfic domain key could be
 // completed before the entire store is loaded
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadCookiesForKey) {
   base::Time t = base::Time::Now() + base::TimeDelta::FromInternalValue(10);
@@ skipping 17 matching lines @@
                                         t, t, t, false, false, true, true));
   store_ = NULL;
 
   scoped_refptr<base::ThreadTestHelper> helper(
       new base::ThreadTestHelper(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   // Make sure we wait until the destructor has run.
   ASSERT_TRUE(helper->Run());
 
   store_ = new SQLitePersistentCookieStore(
-    temp_dir_.path().Append(chrome::kCookieFilename));
+      temp_dir_.path().Append(chrome::kCookieFilename), false);
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and LoadCookiesForKey have been posted to its task queue.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                  base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   store_->LoadCookiesForKey("aaa.com",
     base::Bind(&SQLitePersistentCookieStoreTest::OnKeyLoaded,
@@ skipping 95 matching lines @@
 
   store_->Flush(NewRunnableMethod(counter.get(), &CallbackCounter::Callback));
 
   scoped_refptr<base::ThreadTestHelper> helper(
       new base::ThreadTestHelper(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   ASSERT_TRUE(helper->Run());
 
   ASSERT_EQ(1, counter->callback_count());
 }