Remove the old synchronous CookieMonster API.

chrome/browser/net/sqlite_persistent_cookie_store.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 "chrome/browser/net/sqlite_persistent_cookie_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/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
@@ skipping 11 matching lines @@
     : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> {
  public:
   explicit Backend(const FilePath& path)
       : path_(path),
         db_(NULL),
         num_pending_(0),
         clear_local_state_on_exit_(false) {
   }
 
   // Creates or load the SQLite database.
-  bool Load(std::vector<net::CookieMonster::CanonicalCookie*>* cookies);
+  bool Load(const LoadedCallback& loaded_callback);
 
   // Batch a cookie addition.
   void AddCookie(const net::CookieMonster::CanonicalCookie& cc);
 
   // Batch a cookie access time update.
   void UpdateCookieAccessTime(const net::CookieMonster::CanonicalCookie& cc);
 
   // Batch a cookie deletion.
   void DeleteCookie(const net::CookieMonster::CanonicalCookie& cc);
 
@@ skipping 32 matching lines @@
 
     OperationType op() const { return op_; }
     const net::CookieMonster::CanonicalCookie& cc() const { return cc_; }
 
    private:
     OperationType op_;
     net::CookieMonster::CanonicalCookie cc_;
   };
 
  private:
+  // Creates or load the SQLite database on DB thread.
+  void LoadOnDBThread();
+  // Notify the CookieMonster when loading complete.
+  void Notify(bool load_success_);
+
   // Batch a cookie operation (add or delete)
   void BatchOperation(PendingOperation::OperationType op,
                       const net::CookieMonster::CanonicalCookie& cc);
   // Commit our pending operations to the database.
   void Commit();
   // Close() executed on the background thread.
   void InternalBackgroundClose();
 
   FilePath path_;
   scoped_ptr<sql::Connection> db_;
   sql::MetaTable meta_table_;
 
+  std::vector<net::CookieMonster::CanonicalCookie*> cookies_;
+  LoadedCallback loaded_callback_;
+
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
@@ skipping 31 matching lines @@
   // Try to create the index every time. Older versions did not have this index,
   // so we want those people to get it. Ignore errors, since it may exist.
   db->Execute("CREATE INDEX IF NOT EXISTS cookie_times ON cookies"
               " (creation_utc)");
   return true;
 }
 
 }  // namespace
 
 bool SQLitePersistentCookieStore::Backend::Load(
-    std::vector<net::CookieMonster::CanonicalCookie*>* cookies) {
+    const LoadedCallback& loaded_callback) {
   // This function should be called only once per instance.
   DCHECK(!db_.get());
+  loaded_callback_ = loaded_callback;

[erikwright (departed), 2011/08/11 15:13:52]

DCHECK(loaded_callback_.is_null());

[ycxiao, 2011/08/12 02:35:24]

Done.

+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&Backend::LoadOnDBThread, base::Unretained(this)));
+  return true;
+}
 
+void SQLitePersistentCookieStore::Backend::LoadOnDBThread() {

[erikwright (departed), 2011/08/11 15:13:52]

Write LoadAndNotifyOnDBThread that does Notify(LoadInternal());

Then you can just return true/false from LoadInternal.

[ycxiao, 2011/08/12 02:35:24]

Done.

   // Ensure the parent directory for storing cookies is created before reading

[erikwright (departed), 2011/08/11 15:13:52]

Comment is now out of date.

[ycxiao, 2011/08/12 02:35:24]

Done.

   // from it.  We make an exception to allow IO on the UI thread here because
   // we are going to disk anyway in db_->Open.  (This code will be moved to the
   // DB thread as part of http://crbug.com/52909.)
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;

[erikwright (departed), 2011/08/11 15:13:52]

ScopedAllowIO, no longer required. Move other code to outer scope.

[ycxiao, 2011/08/12 02:35:24]

Done.

     const FilePath dir = path_.DirName();
-    if (!file_util::PathExists(dir) && !file_util::CreateDirectory(dir))
-      return false;
+    if (!file_util::PathExists(dir) && !file_util::CreateDirectory(dir)) {
+      Notify(false);
+      return;
+    }
   }
 
   db_.reset(new sql::Connection);
   if (!db_->Open(path_)) {
     NOTREACHED() << "Unable to open cookie DB.";
     db_.reset();
-    return false;
+    Notify(false);
+    return;
   }
 
   db_->set_error_delegate(GetErrorHandlerForCookieDb());
 
   if (!EnsureDatabaseVersion() || !InitTable(db_.get())) {
     NOTREACHED() << "Unable to open cookie DB.";
     db_.reset();
-    return false;
+    Notify(false);
+    return;
   }
 
   db_->Preload();

[erikwright (departed), 2011/08/11 15:13:52]

Lines 184-208 should be a helper method like 'InitializeDatabase' or similar.

[ycxiao, 2011/08/12 02:35:24]

Done.

 
   // Slurp all the cookies into the out-vector.
   sql::Statement smt(db_->GetUniqueStatement(
       "SELECT creation_utc, host_key, name, value, path, expires_utc, secure, "
       "httponly, last_access_utc FROM cookies"));
   if (!smt) {
     NOTREACHED() << "select statement prep failed";
     db_.reset();
-    return false;
+    Notify(false);
+    return;
   }
 
+  // Reserve space for the maximum amount of cookies a database should have.
+  // This prevents multiple vector growth / copies as we append cookies.
+  const size_t kMaxCookies = 3300;
+  cookies_.reserve(kMaxCookies);
+
   while (smt.Step()) {
     scoped_ptr<net::CookieMonster::CanonicalCookie> cc(
         new net::CookieMonster::CanonicalCookie(
             // The "source" URL is not used with persisted cookies.
             GURL(),                                         // Source
             smt.ColumnString(2),                            // name
             smt.ColumnString(3),                            // value
             smt.ColumnString(1),                            // domain
             smt.ColumnString(4),                            // path
             std::string(),  // TODO(abarth): Persist mac_key
             std::string(),  // TODO(abarth): Persist mac_algorithm
             Time::FromInternalValue(smt.ColumnInt64(0)),    // creation_utc
             Time::FromInternalValue(smt.ColumnInt64(5)),    // expires_utc
             Time::FromInternalValue(smt.ColumnInt64(8)),    // last_access_utc
             smt.ColumnInt(6) != 0,                          // secure
             smt.ColumnInt(7) != 0,                          // httponly
             true));                                         // has_expires
     DLOG_IF(WARNING,
             cc->CreationDate() > Time::Now()) << L"CreationDate too recent";
-    cookies->push_back(cc.release());
+    cookies_.push_back(cc.release());
   }
 
-  return true;
+  Notify(true);
+}
+
+void SQLitePersistentCookieStore::Backend::Notify(bool load_success) {

[erikwright (departed), 2011/08/11 15:13:52]

It seems the success value is not used? Remove it?

[ycxiao, 2011/08/12 02:35:24]

I also notice that it is not used. But this flag passes useful information which
maybe wanted in the future. So I am not sure how to deal with it. 

+  if (BrowserThread::CurrentlyOn(BrowserThread::DB)) {

[erikwright (departed), 2011/08/11 15:13:52]

Instead of having a thread switch here, you can simply do the PostTask to IO
thread in LoadAndNotifyOnDBThread.

So rename this to NotifyOnIOThread and remove lines 252-258.

[ycxiao, 2011/08/12 02:35:24]

Done.

+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&SQLitePersistentCookieStore::Backend::Notify,
+                   base::Unretained(this), load_success));
+    return;
+  }
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  loaded_callback_.Run(cookies_);
 }
 
 bool SQLitePersistentCookieStore::Backend::EnsureDatabaseVersion() {
   // Version check.
   if (!meta_table_.Init(
       db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) {
     return false;
   }
 
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
@@ skipping 244 matching lines @@
 
 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;
   }
 }
 
-bool SQLitePersistentCookieStore::Load(
-    std::vector<net::CookieMonster::CanonicalCookie*>* cookies) {
-  return backend_->Load(cookies);
+bool SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
+  return backend_->Load(loaded_callback);
 }
 
 void SQLitePersistentCookieStore::AddCookie(
     const net::CookieMonster::CanonicalCookie& cc) {
   if (backend_.get())
     backend_->AddCookie(cc);
 }
 
 void SQLitePersistentCookieStore::UpdateCookieAccessTime(
     const net::CookieMonster::CanonicalCookie& cc) {
@@ skipping 12 matching lines @@
   if (backend_.get())
     backend_->SetClearLocalStateOnExit(clear_local_state);
 }
 
 void SQLitePersistentCookieStore::Flush(Task* completion_task) {
   if (backend_.get())
     backend_->Flush(completion_task);
   else if (completion_task)
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }