Unwire the clear on exit preference from the storage systems.

chrome/browser/net/sqlite_persistent_cookie_store.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 "chrome/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 48 matching lines @@
 // whichever occurs first.
 class SQLitePersistentCookieStore::Backend
     : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> {
  public:
   Backend(const FilePath& path,
           bool restore_old_session_cookies,
           ClearOnExitPolicy* clear_on_exit_policy)
       : path_(path),
         db_(NULL),
         num_pending_(0),
-        clear_local_state_on_exit_(false),
+        force_keep_session_state_(false),
         initialized_(false),
         restore_old_session_cookies_(restore_old_session_cookies),
         clear_on_exit_policy_(clear_on_exit_policy),
         num_cookies_read_(0),
         num_priority_waiting_(0),
         total_priority_requests_(0) {
   }
 
   // Creates or loads the SQLite database.
   void Load(const LoadedCallback& loaded_callback);
@@ skipping 11 matching lines @@
   // Batch a cookie deletion.
   void DeleteCookie(const net::CookieMonster::CanonicalCookie& cc);
 
   // Commit pending operations as soon as possible.
   void Flush(const base::Closure& callback);
 
   // Commit any pending operations and close the database.  This must be called
   // before the object is destructed.
   void Close();
 
-  void SetClearLocalStateOnExit(bool clear_local_state);
+  void SetForceKeepSessionState();
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
 
   // You should call Close() before destructing this object.
   ~Backend() {
     DCHECK(!db_.get()) << "Close should have already been called.";
     DCHECK(num_pending_ == 0 && pending_.empty());
   }
 
@@ skipping 77 matching lines @@
 
   void DeleteSessionCookiesOnShutdown();
 
   FilePath path_;
   scoped_ptr<sql::Connection> db_;
   sql::MetaTable meta_table_;
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
-  // True if the persistent store should be deleted upon destruction.
-  bool clear_local_state_on_exit_;
-  // Guard |cookies_|, |pending_|, |num_pending_|, |clear_local_state_on_exit_|
+  // True if the persistent store should skip delete on exit rules.
+  bool force_keep_session_state_;
+  // Guard |cookies_|, |pending_|, |num_pending_|, |force_keep_session_state_|
   base::Lock lock_;
 
   // Temporary buffer for cookies loaded from DB. Accumulates cookies to reduce
   // the number of messages sent to the IO thread. Sent back in response to
   // individual load requests for domain keys or when all loading completes.
   std::vector<net::CookieMonster::CanonicalCookie*> cookies_;
 
   // Map of domain keys(eTLD+1) to domains/hosts that are to be loaded from DB.
   std::map<std::string, std::set<std::string> > keys_to_load_;
 
@@ skipping 702 matching lines @@
         BrowserThread::DB, FROM_HERE,
         base::Bind(&Backend::InternalBackgroundClose, this));
   }
 }
 
 void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   // Commit any pending operations
   Commit();
 
-  if (!clear_local_state_on_exit_ && clear_on_exit_policy_.get() &&
+  if (!force_keep_session_state_ && clear_on_exit_policy_.get() &&
       clear_on_exit_policy_->HasClearOnExitOrigins()) {
     DeleteSessionCookiesOnShutdown();
   }
 
   db_.reset();
-
-  if (clear_local_state_on_exit_)
-    file_util::Delete(path_, false);
 }
 
 void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   if (!db_.get())
     return;
 
   sql::Statement del_smt(db_->GetCachedStatement(
       SQL_FROM_HERE, "DELETE FROM cookies WHERE host_key=? AND secure=?"));
@@ skipping 23 matching lines @@
     del_smt.BindString(0, it->first.first);
     del_smt.BindInt(1, it->first.second);
     if (!del_smt.Run())
       NOTREACHED() << "Could not delete a cookie from the DB.";
   }
 
   if (!transaction.Commit())
     LOG(WARNING) << "Unable to delete cookies on shutdown.";
 }
 
-void SQLitePersistentCookieStore::Backend::SetClearLocalStateOnExit(
-    bool clear_local_state) {
+void SQLitePersistentCookieStore::Backend::SetForceKeepSessionState() {
   base::AutoLock locked(lock_);
-  clear_local_state_on_exit_ = clear_local_state;
+  force_keep_session_state_ = true;
 }
 
 void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnStartup() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!db_->Execute("DELETE FROM cookies WHERE persistent == 0"))
     LOG(WARNING) << "Unable to delete session cookies.";
 }
 
 SQLitePersistentCookieStore::SQLitePersistentCookieStore(
     const FilePath& path,
@@ skipping 24 matching lines @@
   if (backend_.get())
     backend_->UpdateCookieAccessTime(cc);
 }
 
 void SQLitePersistentCookieStore::DeleteCookie(
     const net::CookieMonster::CanonicalCookie& cc) {
   if (backend_.get())
     backend_->DeleteCookie(cc);
 }
 
-void SQLitePersistentCookieStore::SetClearLocalStateOnExit(
-    bool clear_local_state) {
+void SQLitePersistentCookieStore::SetForceKeepSessionState() {

[erikwright (departed), 2012/06/01 15:17:18]

I gather that, by design, one would never _un_set force-keep-session?

   if (backend_.get())
-    backend_->SetClearLocalStateOnExit(clear_local_state);
+    backend_->SetForceKeepSessionState();
 }
 
 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
   if (backend_.get())
     backend_->Flush(callback);
   else if (!callback.is_null())
     MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   if (backend_.get()) {
     backend_->Close();
     // Release our reference, it will probably still have a reference if the
     // background thread has not run Close() yet.
     backend_ = NULL;
   }
 }