AppCache: Use a dedicated thread for the disk cache.

webkit/appcache/appcache_storage_impl.cc

 // Copyright (c) 2010 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 "app/sql/connection.h"
 #include "app/sql/transaction.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 826 matching lines @@
   STLDeleteElements(&pending_simple_tasks_);
 
   std::for_each(scheduled_database_tasks_.begin(),
                 scheduled_database_tasks_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
 
   if (database_)
     AppCacheThread::DeleteSoon(AppCacheThread::db(), FROM_HERE, database_);
 }
 
-void AppCacheStorageImpl::Initialize(const FilePath& cache_directory) {
+void AppCacheStorageImpl::Initialize(const FilePath& cache_directory,
+                                     base::MessageLoopProxy* cache_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);
 
   scoped_refptr<InitTask> task = new InitTask(this);
   task->Schedule();
 }
@@ skipping 407 matching lines @@
 
   if (!disk_cache_.get()) {
     int rv = net::OK;
     disk_cache_.reset(new AppCacheDiskCache);
     if (is_incognito_) {
       rv = disk_cache_->InitWithMemBackend(
           kMaxMemDiskCacheSize, &init_callback_);
     } else {
       rv = disk_cache_->InitWithDiskBackend(
           cache_directory_.Append(kDiskCacheDirectoryName),
-          kMaxDiskCacheSize, false, &init_callback_);
+          kMaxDiskCacheSize, false, cache_thread_, &init_callback_);
     }
 
+    // We should not keep this reference around.
+    cache_thread_ = NULL;
+
     if (rv != net::ERR_IO_PENDING)
       OnDiskCacheInitialized(rv);
   }
   return disk_cache_.get();
 }
 
 void AppCacheStorageImpl::OnDiskCacheInitialized(int rv) {
   if (rv != net::OK) {
     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_) {
       LOG(INFO) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache