Get rid of a dependency on MessageLoop::DestructionObserver....

webkit/tools/test_shell/simple_appcache_system.h

 // 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.
 
 #ifndef WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_
 #define WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/thread.h"
@@ skipping 10 matching lines @@
 class SimpleBackendProxy;
 class SimpleFrontendProxy;
 class URLRequest;
 class URLRequestContext;
 
 // A class that composes the constituent parts of an appcache system
 // together for use in a single process with two relavant threads,
 // a UI thread on which webkit runs and an IO thread on which URLRequests
 // are handled. This class conspires with SimpleResourceLoaderBridge to
 // retrieve resources from the appcache.
-class SimpleAppCacheSystem : public MessageLoop::DestructionObserver {
+class SimpleAppCacheSystem {
  public:
   // Should be instanced somewhere in main(). If not instanced, the public
   // static methods are all safe no-ops.
   SimpleAppCacheSystem();
   virtual ~SimpleAppCacheSystem();
 
   // One-time main UI thread initialization.
   static void InitializeOnUIThread(const FilePath& cache_directory) {
     if (instance_)
       instance_->InitOnUIThread(cache_directory);
   }
 
   // Called by SimpleResourceLoaderBridge's IOThread class.
   // Per IO thread initialization. Only one IO thread can exist
   // at a time, but after IO thread termination a new one can be
   // started on which this method should be called. The instance
   // is assumed to outlive the IO thread.
   static void InitializeOnIOThread(URLRequestContext* request_context) {
     if (instance_)
       instance_->InitOnIOThread(request_context);
   }
 
+  static void CleanupOnIOThread() {
+    if (instance_)
+      instance_->CleanupIOThread();
+  }
+
   // Called by TestShellWebKitInit to manufacture a 'host' for webcore.
   static WebKit::WebApplicationCacheHost* CreateApplicationCacheHost(
       WebKit::WebApplicationCacheHostClient* client) {
     return instance_ ? instance_->CreateCacheHostForWebKit(client) : NULL;
   }
 
   // Called by SimpleResourceLoaderBridge to hook into resource loads.
   static void SetExtraRequestInfo(URLRequest* request,
                                   int host_id,
                                   ResourceType::Type resource_type) {
@@ skipping 37 matching lines @@
   }
 
  private:
   friend class SimpleBackendProxy;
   friend class SimpleFrontendProxy;
   friend class appcache::AppCacheThread;
 
   // Instance methods called by our static public methods
   void InitOnUIThread(const FilePath& cache_directory);
   void InitOnIOThread(URLRequestContext* request_context);
+  void CleanupIOThread();
   WebKit::WebApplicationCacheHost* CreateCacheHostForWebKit(
       WebKit::WebApplicationCacheHostClient* client);
   void SetExtraRequestBits(URLRequest* request,
                            int host_id,
                            ResourceType::Type resource_type);
   void GetExtraResponseBits(URLRequest* request,
                             int64* cache_id,
                             GURL* manifest_url);
 
   // Helpers
@@ skipping 11 matching lines @@
     if (instance_) {
       if (id == IO_THREAD_ID)
         return instance_->io_message_loop_;
       if (id == DB_THREAD_ID)
         return instance_->db_thread_.message_loop();
       NOTREACHED() << "Invalid AppCacheThreadID value";
     }
     return NULL;
   }
 
-  // IOThread DestructionObserver
-  virtual void WillDestroyCurrentMessageLoop();
-
   FilePath cache_directory_;
   MessageLoop* io_message_loop_;
   MessageLoop* ui_message_loop_;
   scoped_refptr<SimpleBackendProxy> backend_proxy_;
   scoped_refptr<SimpleFrontendProxy> frontend_proxy_;
   appcache::AppCacheFrontendImpl frontend_impl_;
 
   // Created and used only on the IO thread, these do
   // not survive IO thread termination. If a new IO thread
   // is started new instances will be created.
   appcache::AppCacheBackendImpl* backend_impl_;
   appcache::AppCacheService* service_;
 
   // We start a thread for use as the DB thread.
   base::Thread db_thread_;
 
   // Some unittests create there own IO and DB threads.
   ThreadProvider* thread_provider_;
 
   // A low-tech singleton.
   static SimpleAppCacheSystem* instance_;
 };
 
 #endif  // WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_