Replace ancient crufty AppCacheThread with much improved MessageLoopProxy usage.

webkit/appcache/appcache_storage_impl_unittest.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 <stack>
 
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.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_service.h"
 #include "webkit/appcache/appcache_storage_impl.h"
 #include "webkit/quota/quota_manager.h"
-#include "webkit/tools/test_shell/simple_appcache_system.h"
 
 namespace appcache {
 
 namespace {
 
 const base::Time kZeroTime;
 const GURL kManifestUrl("http://blah/manifest");
 const GURL kManifestUrl2("http://blah/manifest2");
 const GURL kManifestUrl3("http://blah/manifest3");
 const GURL kEntryUrl("http://blah/entry");
 const GURL kEntryUrl2("http://blah/entry2");
 const GURL kFallbackNamespace("http://blah/fallback_namespace/");
 const GURL kFallbackNamespace2("http://blah/fallback_namespace/longer");
 const GURL kFallbackTestUrl("http://blah/fallback_namespace/longer/test");
 const GURL kOnlineNamespace("http://blah/online_namespace");
 const GURL kOnlineNamespaceWithinFallback(
     "http://blah/fallback_namespace/online/");
 const GURL kOrigin(kManifestUrl.GetOrigin());
 
 const int kManifestEntryIdOffset = 100;
 const int kFallbackEntryIdOffset = 1000;
 
 const GURL kDefaultEntryUrl("http://blah/makecacheandgroup_default_entry");
 const int kDefaultEntrySize = 10;
 const int kDefaultEntryIdOffset = 12345;
 
 const int kMockQuota = 5000;
 
-// For the duration of this test case, we hijack the AppCacheThread API
-// calls and implement them in terms of the io and db threads created here.
-
 scoped_ptr<base::Thread> io_thread;
 scoped_ptr<base::Thread> db_thread;
 
-class TestThreadProvider : public SimpleAppCacheSystem::ThreadProvider {
- public:
-  virtual bool PostTask(
-      int id,
-      const tracked_objects::Location& from_here,
-      Task* task) {
-    GetMessageLoop(id)->PostTask(from_here, task);
-    return true;
-  }
-
-  virtual bool CurrentlyOn(int id) {
-    return MessageLoop::current() == GetMessageLoop(id);
-  }
-
-  MessageLoop* GetMessageLoop(int id) {
-    DCHECK(io_thread.get() && db_thread.get());
-    if (id == SimpleAppCacheSystem::IO_THREAD_ID)
-      return io_thread->message_loop();
-    if (id == SimpleAppCacheSystem::DB_THREAD_ID)
-      return db_thread->message_loop();
-    NOTREACHED() << "Invalid AppCacheThreadID value";
-    return NULL;
-  }
-};
-
-TestThreadProvider thread_provider;
-
 }  // namespace
 
 class AppCacheStorageImplTest : public testing::Test {
  public:
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheStorageImplTest* test)
         : loaded_cache_id_(0), stored_group_success_(false),
           would_exceed_quota_(false), obsoleted_success_(false),
           found_cache_id_(kNoCacheId), test_(test) {
@@ skipping 166 matching lines @@
   };
 
 
   static void SetUpTestCase() {
     io_thread.reset(new base::Thread("AppCacheTest.IOThread"));
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     ASSERT_TRUE(io_thread->StartWithOptions(options));
 
     db_thread.reset(new base::Thread("AppCacheTest::DBThread"));
     ASSERT_TRUE(db_thread->Start());
-
-    SimpleAppCacheSystem::set_thread_provider(&thread_provider);
   }
 
   static void TearDownTestCase() {
-    SimpleAppCacheSystem::set_thread_provider(NULL);
     io_thread.reset(NULL);
     db_thread.reset(NULL);
   }
 
   // Test harness --------------------------------------------------
 
   AppCacheStorageImplTest() {
   }
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread->message_loop());
     service_.reset(new AppCacheService(NULL));
-    service_->Initialize(FilePath(), NULL);
+    service_->Initialize(FilePath(), db_thread->message_loop_proxy(), NULL);
     mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
     service_->quota_manager_proxy_ = mock_quota_manager_proxy_;
     delegate_.reset(new MockStorageDelegate(this));
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread->message_loop());
     storage()->CancelDelegateCallbacks(delegate());
     group_ = NULL;
     cache_ = NULL;
@@ skipping 1045 matching lines @@
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
 
 // AppCacheStorageImplTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);