Don't force non-session only cookies to be session only cookies, instead delete on shutdown

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
+#include "chrome/browser/net/clear_on_exit_policy.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/ssl_client_cert_type.h"
 #include "net/base/x509_certificate.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using content::BrowserThread;
 
 // 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:
-  explicit Backend(const FilePath& path)
+  Backend(const FilePath& path, ClearOnExitPolicy* clear_on_exit_policy)
       : path_(path),
         db_(NULL),
         num_pending_(0),
-        clear_local_state_on_exit_(false) {
+        clear_local_state_on_exit_(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);
 
@@ skipping 47 matching lines @@
  private:
   // Batch a server bound cert operation (add or delete)
   void BatchOperation(
       PendingOperation::OperationType op,
       const net::DefaultServerBoundCertStore::ServerBoundCert& cert);
   // Commit our pending operations to the database.
   void Commit();
   // Close() executed on the background thread.
   void InternalBackgroundClose();
 
+  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_|.
   base::Lock lock_;
 
+  scoped_refptr<ClearOnExitPolicy> clear_on_exit_policy_;
+
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 // Version number of the database.
 static const int kCurrentVersionNumber = 4;
 static const int kCompatibleVersionNumber = 1;
 
 namespace {
 
 // Initializes the certs table, returning true on success.
@@ skipping 329 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() &&
+      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;
+
+  sql::Statement select_smt(db_->GetCachedStatement(

[erikwright (departed), 2012/05/29 13:09:03]

Can you comment on the difference between the cookie DB and the
origin_bound_certs DB that leads to the former caching origin counts and not the
latter?

Although Will said it SGTH for me to review this whole directory, I would ask
the author/owner of this store about the performance implications, if any, here.

[jochen (gone - plz use gerrit), 2012/05/30 11:28:42]

I expect less data in the store (there's only one cert per origin, and this
feature is still hardly used)

+      SQL_FROM_HERE, "SELECT origin FROM origin_bound_certs"));
+  if (!select_smt.is_valid()) {
+    LOG(WARNING) << "Unable to delete certificates on shutdown.";
+    return;
+  }
+
+  std::vector<std::string> origins_to_delete;
+  while (select_smt.Step()) {
+    std::string origin = select_smt.ColumnString(0);
+    if (!clear_on_exit_policy_->ShouldClearOriginOnExit(origin, true))
+      continue;
+    origins_to_delete.push_back(origin);
+  }
+
+  if (origins_to_delete.empty())
+    return;
+
+  sql::Statement del_smt(db_->GetCachedStatement(
+      SQL_FROM_HERE, "DELETE FROM origin_bound_certs WHERE origin=?"));
+  if (!del_smt.is_valid()) {
+    LOG(WARNING) << "Unable to delete certificates on shutdown.";
+    return;
+  }
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin()) {
+    LOG(WARNING) << "Unable to delete certificates on shutdown.";
+    return;
+  }
+
+  for (unsigned i = 0; i < origins_to_delete.size(); ++i) {
+    del_smt.Reset(true);
+    del_smt.BindString(0, origins_to_delete[i]);
+    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) {
   base::AutoLock locked(lock_);
   clear_local_state_on_exit_ = clear_local_state;
 }
 
-SQLiteServerBoundCertStore::SQLiteServerBoundCertStore(const FilePath& path)
-    : backend_(new Backend(path)) {
+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())
@@ skipping 20 matching lines @@
 }
 
 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;
   }
 }