Make ServerBoundCertStore interface async, move SQLiteServerBoundCertStore load onto DB thread.

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 23 matching lines @@
     : public base::RefCountedThreadSafe<SQLiteServerBoundCertStore::Backend> {
  public:
   Backend(const FilePath& path, ClearOnExitPolicy* clear_on_exit_policy)
       : path_(path),
         db_(NULL),
         num_pending_(0),
         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);
+  // Creates or loads the SQLite database.
+  void Load(const LoadedCallback& loaded_callback);
 
   // 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 SetForceKeepSessionState();
 
  private:
+  void LoadOnDBThreadAndNotify(const LoadedCallback& loaded_callback);
+  void LoadOnDBThread(
+      std::vector<net::DefaultServerBoundCertStore::ServerBoundCert*>* certs);
+
   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());
   }
 
   // Database upgrade statements.
   bool EnsureDatabaseVersion();
@@ skipping 72 matching lines @@
                      "expiration_time INTEGER,"
                      "creation_time INTEGER)"))
       return false;
   }
 
   return true;
 }
 
 }  // namespace
 
-bool SQLiteServerBoundCertStore::Backend::Load(
-    std::vector<net::DefaultServerBoundCertStore::ServerBoundCert*>* certs) {
+void SQLiteServerBoundCertStore::Backend::Load(
+    const LoadedCallback& loaded_callback) {
   // This function should be called only once per instance.
   DCHECK(!db_.get());
 
-  // TODO(paivanof@gmail.com): We do a lot of disk access in this function,
-  // thus we do an exception to allow IO on the UI thread. This code will be
-  // moved to the DB thread as part of http://crbug.com/89665.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&Backend::LoadOnDBThreadAndNotify, this, loaded_callback));
+}
+
+void SQLiteServerBoundCertStore::Backend::LoadOnDBThreadAndNotify(
+    const LoadedCallback& loaded_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  scoped_ptr<ScopedVector<net::DefaultServerBoundCertStore::ServerBoundCert> >
+      certs(new ScopedVector<net::DefaultServerBoundCertStore::ServerBoundCert>(
+          ));
+
+  LoadOnDBThread(&certs->get());
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(loaded_callback, base::Passed(&certs)));
+}
+
+void SQLiteServerBoundCertStore::Backend::LoadOnDBThread(
+    std::vector<net::DefaultServerBoundCertStore::ServerBoundCert*>* certs) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+
+  // This method should be called only once per instance.
+  DCHECK(!db_.get());
 
   base::TimeTicks start = base::TimeTicks::Now();
 
   // Ensure the parent directory for storing certs is created before reading
   // from it.
   const FilePath dir = path_.DirName();
   if (!file_util::PathExists(dir) && !file_util::CreateDirectory(dir))
-    return false;
+    return;
 
   int64 db_size = 0;
   if (file_util::GetFileSize(path_, &db_size))
     UMA_HISTOGRAM_COUNTS("DomainBoundCerts.DBSizeInKB", db_size / 1024 );
 
   db_.reset(new sql::Connection);
   if (!db_->Open(path_)) {
     NOTREACHED() << "Unable to open cert DB.";
     db_.reset();
-    return false;
+    return;
   }
 
   if (!EnsureDatabaseVersion() || !InitTable(db_.get())) {
     NOTREACHED() << "Unable to open cert DB.";
     db_.reset();
-    return false;
+    return;
   }
 
   db_->Preload();
 
   // Slurp all the certs into the out-vector.
   sql::Statement smt(db_->GetUniqueStatement(
       "SELECT origin, private_key, cert, cert_type, expiration_time, "
       "creation_time FROM origin_bound_certs"));
   if (!smt.is_valid()) {
     db_.reset();
-    return false;
+    return;
   }
 
   while (smt.Step()) {
     std::string private_key_from_db, cert_from_db;
     smt.ColumnBlobAsString(1, &private_key_from_db);
     smt.ColumnBlobAsString(2, &cert_from_db);
     scoped_ptr<net::DefaultServerBoundCertStore::ServerBoundCert> cert(
         new net::DefaultServerBoundCertStore::ServerBoundCert(
             smt.ColumnString(0),  // origin
             static_cast<net::SSLClientCertType>(smt.ColumnInt(3)),
             base::Time::FromInternalValue(smt.ColumnInt64(5)),
             base::Time::FromInternalValue(smt.ColumnInt64(4)),
             private_key_from_db,
             cert_from_db));
     cert_origins_.insert(cert->server_identifier());
     certs->push_back(cert.release());
   }
 
   UMA_HISTOGRAM_COUNTS_10000("DomainBoundCerts.DBLoadedCount", certs->size());
+  base::TimeDelta load_time = base::TimeTicks::Now() - start;
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.DBLoadTime",
-                             base::TimeTicks::Now() - start,
+                             load_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1),
                              50);
-  return true;
+  DVLOG(1) << "loaded " << certs->size() << " in " << load_time.InMilliseconds()
+           << " ms";
 }
 
 bool SQLiteServerBoundCertStore::Backend::EnsureDatabaseVersion() {
   // Version check.
   if (!meta_table_.Init(
       db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) {
     return false;
   }
 
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
@@ skipping 300 matching lines @@
   base::AutoLock locked(lock_);
   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::Load(
+    const LoadedCallback& loaded_callback) {
+  backend_->Load(loaded_callback);
 }
 
 void SQLiteServerBoundCertStore::AddServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   backend_->AddServerBoundCert(cert);
 }
 
 void SQLiteServerBoundCertStore::DeleteServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   backend_->DeleteServerBoundCert(cert);
 }
 
 void SQLiteServerBoundCertStore::SetForceKeepSessionState() {
   backend_->SetForceKeepSessionState();
 }
 
 void SQLiteServerBoundCertStore::Flush(const base::Closure& completion_task) {
   backend_->Flush(completion_task);
 }
 
 SQLiteServerBoundCertStore::~SQLiteServerBoundCertStore() {
   backend_->Close();
   // We release our reference to the Backend, though it will probably still have
   // a reference if the background thread has not run Close() yet.
 }