Last patch in removing MessageLoop* caching.

chrome/browser/extensions/user_script_listener_unittest.cc

 // 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.
 
 #include <algorithm>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/thread.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 47 matching lines @@
 
   scoped_ptr<NotificationService> service_;
 };
 
 // A class to help with making and handling resource requests.
 class ResourceDispatcherHostTester
     : public ResourceDispatcherHost::Receiver,
       public URLRequest::Interceptor,
       public base::RefCountedThreadSafe<ResourceDispatcherHostTester> {
  public:
-  explicit ResourceDispatcherHostTester(MessageLoop* io_loop)
-      : Receiver(ChildProcessInfo::RENDER_PROCESS, -1),
-        host_(io_loop),
-        ui_loop_(MessageLoop::current()),
-        io_loop_(io_loop) {
+  explicit ResourceDispatcherHostTester()
+      : Receiver(ChildProcessInfo::RENDER_PROCESS, -1) {
     URLRequest::RegisterRequestInterceptor(this);
   }
   virtual ~ResourceDispatcherHostTester() {
     URLRequest::UnregisterRequestInterceptor(this);
   }
 
   void MakeTestRequest(int request_id, const GURL& url) {
-    io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &ResourceDispatcherHostTester::MakeTestRequestOnIOThread,
-        request_id, url));
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(
+            this, &ResourceDispatcherHostTester::MakeTestRequestOnIOThread,
+            request_id, url));
     MessageLoop::current()->Run();  // wait for Quit from IO thread
   }
 
   void WaitForScan(MockUserScriptMaster* master) {
     master->TestStartScan();
     MessageLoop::current()->RunAllPending();  // run the scan
-    io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &ResourceDispatcherHostTester::RunPending));
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(this, &ResourceDispatcherHostTester::RunPending));
     MessageLoop::current()->Run();  // wait for Quit from IO thread
   }
 
   bool IsRequestStarted(int request_id) {
     return std::find(started_requests_.begin(), started_requests_.end(),
                      request_id) != started_requests_.end();
   }
 
   bool IsRequestComplete(int request_id) {
     return std::find(completed_requests_.begin(), completed_requests_.end(),
@@ skipping 41 matching lines @@
     request.appcache_host_id = appcache::kNoHostId;
     return request;
   }
 
   void RunPending() {
     MessageLoop::current()->SetNestableTasksAllowed(true);
     MessageLoop::current()->RunAllPending();
     MessageLoop::current()->SetNestableTasksAllowed(false);
 
     // return control to UI thread.
-    ui_loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE, new MessageLoop::QuitTask());
   }
 
   void MakeTestRequestOnIOThread(int request_id, const GURL& url) {
     ViewHostMsg_Resource_Request request = CreateResourceRequest("GET", url);
     ViewHostMsg_RequestResource msg(0, request_id, request);
     bool msg_was_ok;
     host_.OnMessageReceived(msg, this, &msg_was_ok);
     RunPending();
   }
 
   void OnReceivedResponse(int request_id,
                           const ResourceResponseHead& response_head) {
     started_requests_.push_back(request_id);
   }
 
   void OnRequestComplete(int request_id,
                          const URLRequestStatus& status,
                          const std::string& security_info) {
     completed_requests_.push_back(request_id);
   }
 
   ResourceDispatcherHost host_;
-  MessageLoop* ui_loop_;
-  MessageLoop* io_loop_;
 
   // Note: these variables are accessed on both threads, but since we only
   // one thread executes at a time, they are safe.
   std::vector<int> started_requests_;
   std::vector<int> completed_requests_;
 };
 
 class UserScriptListenerTest : public testing::Test {
  public:
   virtual void SetUp() {
     ui_thread_.reset(new ChromeThread(ChromeThread::UI, &loop_));
     file_thread_.reset(new ChromeThread(ChromeThread::FILE, &loop_));
     io_thread_.reset(new MockIOThread());
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
     DCHECK(io_thread_->message_loop());
     DCHECK(io_thread_->IsRunning());
 
     FilePath install_dir = profile_.GetPath()
         .AppendASCII(ExtensionsService::kInstallDirectoryName);
 
-    resource_tester_ =
-        new ResourceDispatcherHostTester(io_thread_->message_loop());
+    resource_tester_ = new ResourceDispatcherHostTester();
 
     master_ = new MockUserScriptMaster(install_dir);
 
     service_ = new ExtensionsService(&profile_,
                                      CommandLine::ForCurrentProcess(),
                                      profile_.GetPrefs(),
                                      install_dir,
                                      false);
     service_->set_extensions_enabled(true);
     service_->set_show_extensions_prompts(false);
@@ skipping 94 matching lines @@
 
   // Make the same requests, and they should complete instantly.
   resource_tester_->MakeTestRequest(2, GURL("http://google.com/"));
   resource_tester_->MakeTestRequest(3, GURL("http://yahoo.com/"));
 
   EXPECT_TRUE(resource_tester_->IsRequestStarted(2));
   EXPECT_TRUE(resource_tester_->IsRequestComplete(2));
   EXPECT_TRUE(resource_tester_->IsRequestStarted(3));
   EXPECT_TRUE(resource_tester_->IsRequestComplete(3));
 }