Unwire the clear on exit preference from the storage systems.

chrome/browser/net/sqlite_server_bound_cert_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_server_bound_cert_store.h"
 
 #include <list>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 
 // This class is designed to be shared between any calling threads and the
 // database thread.  It batches operations and commits them on a timer.
 class SQLiteServerBoundCertStore::Backend
     : public base::RefCountedThreadSafe<SQLiteServerBoundCertStore::Backend> {
  public:
   Backend(const FilePath& path, ClearOnExitPolicy* clear_on_exit_policy)
       : path_(path),
         db_(NULL),
         num_pending_(0),
-        clear_local_state_on_exit_(false),
+        force_keep_session_state_(false),
         clear_on_exit_policy_(clear_on_exit_policy) {
   }
 
   // Creates or load the SQLite database.
   bool Load(
       std::vector<net::DefaultServerBoundCertStore::ServerBoundCert*>* certs);
 
   // Batch a server bound cert addition.
   void AddServerBoundCert(
       const net::DefaultServerBoundCertStore::ServerBoundCert& cert);
 
   // Batch a server bound cert deletion.
   void DeleteServerBoundCert(
       const net::DefaultServerBoundCertStore::ServerBoundCert& cert);
 
   // Commit pending operations as soon as possible.
   void Flush(const base::Closure& completion_task);
 
   // 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<SQLiteServerBoundCertStore::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 34 matching lines @@
 
   void DeleteCertificatesOnShutdown();
 
   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 |pending_|, |num_pending_| and |clear_local_state_on_exit_|.
+  // True if the persistent store should skip clear on exit rules.
+  bool force_keep_session_state_;
+  // Guard |pending_|, |num_pending_| and |force_keep_session_state_|.
   base::Lock lock_;
 
   // Cache of origins we have certificates stored for.
   std::set<std::string> cert_origins_;
 
   scoped_refptr<ClearOnExitPolicy> clear_on_exit_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
@@ skipping 339 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&Backend::InternalBackgroundClose, this));
 }
 
 void SQLiteServerBoundCertStore::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()) {
     DeleteCertificatesOnShutdown();
   }
 
   db_.reset();
-
-  if (clear_local_state_on_exit_)
-    file_util::Delete(path_, false);
 }
 
 void SQLiteServerBoundCertStore::Backend::DeleteCertificatesOnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   if (!db_.get())
     return;
 
   if (cert_origins_.empty())
     return;
@@ skipping 18 matching lines @@
     del_smt.Reset(true);
     del_smt.BindString(0, *it);
     if (!del_smt.Run())
       NOTREACHED() << "Could not delete a certificate from the DB.";
   }
 
   if (!transaction.Commit())
     LOG(WARNING) << "Unable to delete certificates on shutdown.";
 }
 
-void SQLiteServerBoundCertStore::Backend::SetClearLocalStateOnExit(
-    bool clear_local_state) {
+void SQLiteServerBoundCertStore::Backend::SetForceKeepSessionState() {
   base::AutoLock locked(lock_);
-  clear_local_state_on_exit_ = clear_local_state;
+  force_keep_session_state_ = true;
 }
 
 SQLiteServerBoundCertStore::SQLiteServerBoundCertStore(
     const FilePath& path,
     ClearOnExitPolicy* clear_on_exit_policy)
     : backend_(new Backend(path, clear_on_exit_policy)) {
 }
 
 bool SQLiteServerBoundCertStore::Load(
     std::vector<net::DefaultServerBoundCertStore::ServerBoundCert*>* certs) {
   return backend_->Load(certs);
 }
 
 void SQLiteServerBoundCertStore::AddServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   if (backend_.get())
     backend_->AddServerBoundCert(cert);
 }
 
 void SQLiteServerBoundCertStore::DeleteServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   if (backend_.get())
     backend_->DeleteServerBoundCert(cert);
 }
 
-void SQLiteServerBoundCertStore::SetClearLocalStateOnExit(
-    bool clear_local_state) {
+void SQLiteServerBoundCertStore::SetForceKeepSessionState() {
   if (backend_.get())
-    backend_->SetClearLocalStateOnExit(clear_local_state);
+    backend_->SetForceKeepSessionState();
 }
 
 void SQLiteServerBoundCertStore::Flush(const base::Closure& completion_task) {
   if (backend_.get())
     backend_->Flush(completion_task);
   else if (!completion_task.is_null())
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }
 
 SQLiteServerBoundCertStore::~SQLiteServerBoundCertStore() {
   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;
   }
 }