Replace ancient crufty AppCacheThread with much improved MessageLoopProxy usage.

webkit/appcache/appcache_storage_impl.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 "webkit/appcache/appcache_storage_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "sql/connection.h"
 #include "sql/transaction.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_histograms.h"
 #include "webkit/appcache/appcache_quota_client.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_service.h"
-#include "webkit/appcache/appcache_thread.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace appcache {
 
 // Hard coded default when not using quota management.
 static const int kDefaultQuota = 5 * 1024 * 1024;
 
 static const int kMaxDiskCacheSize = 250 * 1024 * 1024;
@@ skipping 81 matching lines @@
 }
 
 }  // namespace
 
 // DatabaseTask -----------------------------------------
 
 class AppCacheStorageImpl::DatabaseTask
     : public base::RefCountedThreadSafe<DatabaseTask> {
  public:
   explicit DatabaseTask(AppCacheStorageImpl* storage)
-      : storage_(storage), database_(storage->database_) {}
+      : storage_(storage), database_(storage->database_),
+        io_thread_(base::MessageLoopProxy::current()) {
+    DCHECK(io_thread_);
+  }
 
   virtual ~DatabaseTask() {}
 
   void AddDelegate(DelegateReference* delegate_reference) {
     delegates_.push_back(make_scoped_refptr(delegate_reference));
   }
 
   // Schedules a task to be Run() on the DB thread. Tasks
   // are run in the order in which they are scheduled.
   void Schedule();
@@ skipping 16 matching lines @@
 
  protected:
   AppCacheStorageImpl* storage_;
   AppCacheDatabase* database_;
   DelegateReferenceVector delegates_;
 
  private:
   void CallRun();
   void CallRunCompleted();
   void CallDisableStorage();
+
+  scoped_refptr<base::MessageLoopProxy> io_thread_;
 };
 
 void AppCacheStorageImpl::DatabaseTask::Schedule() {
   DCHECK(storage_);
-  DCHECK(AppCacheThread::CurrentlyOn(AppCacheThread::io()));
-  if (AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
+  DCHECK(io_thread_->BelongsToCurrentThread());
+  if (storage_->db_thread_->PostTask(FROM_HERE,
           NewRunnableMethod(this, &DatabaseTask::CallRun))) {
     storage_->scheduled_database_tasks_.push_back(this);
   } else {
     NOTREACHED() << "The database thread is not running.";
   }
 }
 
 void AppCacheStorageImpl::DatabaseTask::CancelCompletion() {
-  DCHECK(AppCacheThread::CurrentlyOn(AppCacheThread::io()));
+  DCHECK(io_thread_->BelongsToCurrentThread());
   delegates_.clear();
   storage_ = NULL;
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallRun() {
-  DCHECK(AppCacheThread::CurrentlyOn(AppCacheThread::db()));
+  DCHECK(!io_thread_->BelongsToCurrentThread());
   if (!database_->is_disabled()) {
     Run();
     if (database_->is_disabled()) {
-      AppCacheThread::PostTask(AppCacheThread::io(), FROM_HERE,
+      io_thread_->PostTask(FROM_HERE,
           NewRunnableMethod(this, &DatabaseTask::CallDisableStorage));
     }
   }
-  AppCacheThread::PostTask(AppCacheThread::io(), FROM_HERE,
+  io_thread_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &DatabaseTask::CallRunCompleted));
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallRunCompleted() {
   if (storage_) {
-    DCHECK(AppCacheThread::CurrentlyOn(AppCacheThread::io()));
+    DCHECK(io_thread_->BelongsToCurrentThread());
     DCHECK(storage_->scheduled_database_tasks_.front() == this);
     storage_->scheduled_database_tasks_.pop_front();
     RunCompleted();
     delegates_.clear();
   }
 }
 
 void AppCacheStorageImpl::DatabaseTask::CallDisableStorage() {
   if (storage_) {
-    DCHECK(AppCacheThread::CurrentlyOn(AppCacheThread::io()));
+    DCHECK(io_thread_->BelongsToCurrentThread());
     storage_->Disable();
   }
 }
 
 // InitTask -------
 
 class AppCacheStorageImpl::InitTask : public DatabaseTask {
  public:
   explicit InitTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage), last_group_id_(0),
@@ skipping 931 matching lines @@
   STLDeleteElements(&pending_simple_tasks_);
 
   std::for_each(pending_quota_queries_.begin(),
                 pending_quota_queries_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
   std::for_each(scheduled_database_tasks_.begin(),
                 scheduled_database_tasks_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
 
   if (database_) {
-    AppCacheThread::PostTask(
-        AppCacheThread::db(),
+    db_thread_->PostTask(
         FROM_HERE,
         NewRunnableFunction(
             CleanUpOnDatabaseThread,
             database_,
             make_scoped_refptr(service_->special_storage_policy()),
             service()->clear_local_state_on_exit()));
   }
 }
 
 void AppCacheStorageImpl::Initialize(const FilePath& cache_directory,
+                                     base::MessageLoopProxy* db_thread,
                                      base::MessageLoopProxy* cache_thread) {
+  DCHECK(db_thread);
+
   cache_directory_ = cache_directory;
-  cache_thread_ = cache_thread;
   is_incognito_ = cache_directory_.empty();
 
   FilePath db_file_path;
   if (!is_incognito_)
     db_file_path = cache_directory_.Append(kAppCacheDatabaseName);
   database_ = new AppCacheDatabase(db_file_path);
 
+  db_thread_ = db_thread;
+  cache_thread_ = cache_thread;
+
   scoped_refptr<InitTask> task(new InitTask(this));
   task->Schedule();
 }
 
 void AppCacheStorageImpl::Disable() {
   if (is_disabled_)
     return;
   VLOG(1) << "Disabling appcache storage.";
   is_disabled_ = true;
   ClearUsageMapAndNotify();
@@ skipping 435 matching lines @@
     LOG(ERROR) << "Failed to open the appcache diskcache.";
     AppCacheHistograms::CountInitResult(AppCacheHistograms::DISK_CACHE_ERROR);
 
     // We're unable to open the disk cache, this is a fatal error that we can't
     // really recover from. We handle it by disabling the appcache for this
     // browser session and deleting the directory on disk. The next browser
     // session should start with a clean slate.
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
-      AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
+      db_thread_->PostTask(FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache