Replace ancient crufty AppCacheThread with much improved MessageLoopProxy usage.

webkit/tools/test_shell/simple_appcache_system.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/tools/test_shell/simple_appcache_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/task.h"
 #include "base/synchronization/waitable_event.h"
 #include "webkit/appcache/appcache_interceptor.h"
 #include "webkit/appcache/web_application_cache_host_impl.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 using WebKit::WebApplicationCacheHost;
 using WebKit::WebApplicationCacheHostClient;
 using appcache::WebApplicationCacheHostImpl;
 using appcache::AppCacheBackendImpl;
 using appcache::AppCacheInterceptor;
-using appcache::AppCacheThread;
-
-namespace appcache {
-
-// An impl of AppCacheThread we need to provide to the appcache lib.
-
-bool AppCacheThread::PostTask(
-    int id,
-    const tracked_objects::Location& from_here,
-    Task* task) {
-  if (SimpleAppCacheSystem::thread_provider()) {
-    return SimpleAppCacheSystem::thread_provider()->PostTask(
-        id, from_here, task);
-  }
-  scoped_ptr<Task> task_ptr(task);
-  MessageLoop* loop = SimpleAppCacheSystem::GetMessageLoop(id);
-  if (loop)
-    loop->PostTask(from_here, task_ptr.release());
-  return loop ? true : false;
-}
-
-bool AppCacheThread::CurrentlyOn(int id) {
-  if (SimpleAppCacheSystem::thread_provider())
-    return SimpleAppCacheSystem::thread_provider()->CurrentlyOn(id);
-  return MessageLoop::current() == SimpleAppCacheSystem::GetMessageLoop(id);
-}
-
-}  // namespace appcache
 
 // SimpleFrontendProxy --------------------------------------------------------
 // Proxies method calls from the backend IO thread to the frontend UI thread.
 
 class SimpleFrontendProxy
     : public base::RefCountedThreadSafe<SimpleFrontendProxy>,
       public appcache::AppCacheFrontend {
  public:
   explicit SimpleFrontendProxy(SimpleAppCacheSystem* appcache_system)
       : system_(appcache_system) {
@@ skipping 299 matching lines @@
 
 // A not so thread safe singleton, but should work for test_shell.
 SimpleAppCacheSystem* SimpleAppCacheSystem::instance_ = NULL;
 
 SimpleAppCacheSystem::SimpleAppCacheSystem()
     : io_message_loop_(NULL), ui_message_loop_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           backend_proxy_(new SimpleBackendProxy(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           frontend_proxy_(new SimpleFrontendProxy(this))),
-      backend_impl_(NULL), service_(NULL), db_thread_("AppCacheDBThread"),
-      thread_provider_(NULL) {
+      backend_impl_(NULL), service_(NULL), db_thread_("AppCacheDBThread") {
   DCHECK(!instance_);
   instance_ = this;
 }
 
 static void SignalEvent(base::WaitableEvent* event) {
   event->Signal();
 }
 
 SimpleAppCacheSystem::~SimpleAppCacheSystem() {
   DCHECK(!io_message_loop_ && !backend_impl_ && !service_);
   frontend_proxy_->clear_appcache_system();  // in case a task is in transit
   instance_ = NULL;
 
   if (db_thread_.IsRunning()) {
     // We pump a task thru the db thread to ensure any tasks previously
     // scheduled on that thread have been performed prior to return.
     base::WaitableEvent event(false, false);
     db_thread_.message_loop()->PostTask(FROM_HERE,
         NewRunnableFunction(&SignalEvent, &event));
     event.Wait();
   }
 }
 
 void SimpleAppCacheSystem::InitOnUIThread(const FilePath& cache_directory) {
   DCHECK(!ui_message_loop_);
-  AppCacheThread::Init(DB_THREAD_ID, IO_THREAD_ID);
   ui_message_loop_ = MessageLoop::current();
   cache_directory_ = cache_directory;
 }
 
 void SimpleAppCacheSystem::InitOnIOThread(
     net::URLRequestContext* request_context) {
   if (!is_initailized_on_ui_thread())
     return;
 
   DCHECK(!io_message_loop_);
   io_message_loop_ = MessageLoop::current();
 
   if (!db_thread_.IsRunning())
     db_thread_.Start();
 
   // Recreate and initialize per each IO thread.
   service_ = new appcache::AppCacheService(NULL);
   backend_impl_ = new appcache::AppCacheBackendImpl();
   service_->Initialize(cache_directory_,
+                       db_thread_.message_loop_proxy(),
                        SimpleResourceLoaderBridge::GetCacheThread());
   service_->set_request_context(request_context);
   backend_impl_->Initialize(service_, frontend_proxy_.get(), kSingleProcessId);
 
   AppCacheInterceptor::EnsureRegistered();
 }
 
 void SimpleAppCacheSystem::CleanupIOThread() {
   DCHECK(is_io_thread());
 
@@ skipping 32 matching lines @@
 }
 
 void SimpleAppCacheSystem::GetExtraResponseBits(
     net::URLRequest* request, int64* cache_id, GURL* manifest_url) {
   if (is_initialized()) {
     DCHECK(is_io_thread());
     AppCacheInterceptor::GetExtraResponseInfo(
         request, cache_id, manifest_url);
   }
 }