Simplify threading in browser thread by making only ChromeThread deal with di...

chrome/browser/net/sqlite_persistent_cookie_store.cc

 // Copyright (c) 2009 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 "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/thread.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
 
 using base::Time;
 
 // 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 SQLitePersistentCookieStore::Backend
     : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> {
  public:
   // The passed database pointer must be already-initialized. This object will
   // take ownership.
-  explicit Backend(sql::Connection* db, MessageLoop* loop)
+  explicit Backend(sql::Connection* db)
       : db_(db),
-        background_loop_(loop),
         num_pending_(0) {
     DCHECK(db_) << "Database must exist.";
   }
 
   // You should call Close() before destructing this object.
   ~Backend() {
     DCHECK(!db_) << "Close should have already been called.";
     DCHECK(num_pending_ == 0 && pending_.empty());
   }
 
@@ skipping 39 matching lines @@
   // Batch a cookie operation (add or delete)
   void BatchOperation(PendingOperation::OperationType op,
                       const std::string& key,
                       const net::CookieMonster::CanonicalCookie& cc);
   // Commit our pending operations to the database.
   void Commit();
   // Close() executed on the background thread.
   void InternalBackgroundClose();
 
   sql::Connection* db_;
-  MessageLoop* background_loop_;
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
   Lock pending_lock_;  // Guard pending_ and num_pending_
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 void SQLitePersistentCookieStore::Backend::AddCookie(
@@ skipping 13 matching lines @@
 }
 
 void SQLitePersistentCookieStore::Backend::BatchOperation(
     PendingOperation::OperationType op,
     const std::string& key,
     const net::CookieMonster::CanonicalCookie& cc) {
   // Commit every 30 seconds.
   static const int kCommitIntervalMs = 30 * 1000;
   // Commit right away if we have more than 512 outstanding operations.
   static const size_t kCommitAfterBatchSize = 512;
-  DCHECK(MessageLoop::current() != background_loop_);
+  DCHECK(!ChromeThread::CurrentlyOn(ChromeThread::DB));
 
   // We do a full copy of the cookie here, and hopefully just here.
   scoped_ptr<PendingOperation> po(new PendingOperation(op, key, cc));
   CHECK(po.get());
 
   PendingOperationsList::size_type num_pending;
   {
     AutoLock locked(pending_lock_);
     pending_.push_back(po.release());
     num_pending = ++num_pending_;
   }
 
-  // TODO(abarth): What if the DB thread is being destroyed on the UI thread?
   if (num_pending == 1) {
     // We've gotten our first entry for this batch, fire off the timer.
-    background_loop_->PostDelayedTask(FROM_HERE,
+    ChromeThread::PostDelayedTask(
+        ChromeThread::DB, FROM_HERE,
         NewRunnableMethod(this, &Backend::Commit), kCommitIntervalMs);
   } else if (num_pending == kCommitAfterBatchSize) {
     // We've reached a big enough batch, fire off a commit now.
-    background_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &Backend::Commit));
+    ChromeThread::PostTask(
+        ChromeThread::DB, FROM_HERE, NewRunnableMethod(this, &Backend::Commit));
   }
 }
 
 void SQLitePersistentCookieStore::Backend::Commit() {
-  DCHECK(MessageLoop::current() == background_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   PendingOperationsList ops;
   {
     AutoLock locked(pending_lock_);
     pending_.swap(ops);
     num_pending_ = 0;
   }
 
   // Maybe an old timer fired or we are already Close()'ed.
   if (!db_ || ops.empty())
     return;
@@ skipping 68 matching lines @@
         break;
     }
   }
   transaction.Commit();
 }
 
 // Fire off a close message to the background thread.  We could still have a
 // pending commit timer that will be holding a reference on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
 void SQLitePersistentCookieStore::Backend::Close() {
-  DCHECK(MessageLoop::current() != background_loop_);
+  DCHECK(!ChromeThread::CurrentlyOn(ChromeThread::DB));
   // Must close the backend on the background thread.
-  // TODO(abarth): What if the DB thread is being destroyed on the UI thread?
-  background_loop_->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::DB, FROM_HERE,
       NewRunnableMethod(this, &Backend::InternalBackgroundClose));
 }
 
 void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() {
-  DCHECK(MessageLoop::current() == background_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   // Commit any pending operations
   Commit();
 
   delete db_;
   db_ = NULL;
 }
 
-SQLitePersistentCookieStore::SQLitePersistentCookieStore(
-    const FilePath& path,
-    MessageLoop* background_loop)
-    : path_(path),
-      background_loop_(background_loop) {
-  DCHECK(background_loop) << "SQLitePersistentCookieStore needs a MessageLoop";
+SQLitePersistentCookieStore::SQLitePersistentCookieStore(const FilePath& path)
+    : path_(path) {
 }
 
 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;
   }
 }
@@ skipping 75 matching lines @@
             true,                                           // has_expires
             Time::FromInternalValue(smt.ColumnInt64(5))));  // expires_utc
     DLOG_IF(WARNING,
             cc->CreationDate() > Time::Now()) << L"CreationDate too recent";
     cookies->push_back(
         net::CookieMonster::KeyedCanonicalCookie(smt.ColumnString(1),
                                                  cc.release()));
   }
 
   // Create the backend, this will take ownership of the db pointer.
-  backend_ = new Backend(db.release(), background_loop_);
+  backend_ = new Backend(db.release());
   return true;
 }
 
 bool SQLitePersistentCookieStore::EnsureDatabaseVersion(sql::Connection* db) {
   // Version check.
   if (!meta_table_.Init(db, kCurrentVersionNumber, kCompatibleVersionNumber))
     return false;
 
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
     LOG(WARNING) << "Cookie database is too new.";
@@ skipping 73 matching lines @@
     const net::CookieMonster::CanonicalCookie& cc) {
   if (backend_.get())
     backend_->UpdateCookieAccessTime(cc);
 }
 
 void SQLitePersistentCookieStore::DeleteCookie(
     const net::CookieMonster::CanonicalCookie& cc) {
   if (backend_.get())
     backend_->DeleteCookie(cc);
 }