Handle extension webrequest API on the IO thread. This speeds up blocking event

chrome/browser/extensions/extension_webrequest_api_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 <queue>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 
 #include "chrome/browser/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/extensions/extension_webrequest_api.h"
 #include "chrome/browser/extensions/extension_webrequest_api_constants.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/prefs/pref_member.h"
+#include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_pref_service.h"
 #include "chrome/test/testing_profile.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace keys = extension_webrequest_api_constants;
 
 namespace {
 static void EventHandledOnIOThread(
     ProfileId profile_id,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     ExtensionWebRequestEventRouter::EventResponse* response) {
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id, extension_id, event_name, sub_event_name, request_id,
       response);
 }
 }  // namespace
 
 // A mock event router that responds to events with a pre-arranged queue of
 // Tasks.
-class TestEventRouter : public ExtensionEventRouterForwarder {
+class TestIPCSender : public IPC::Message::Sender {
 public:
   // Adds a Task to the queue. We will fire these in order as events are
   // dispatched.
   void PushTask(Task* task) {
     task_queue_.push(task);
   }
 
   size_t GetNumTasks() { return task_queue_.size(); }
 
 private:
-  // ExtensionEventRouterForwarder:
-  virtual void HandleEvent(const std::string& extension_id,
-                           const std::string& event_name,
-                           const std::string& event_args,
-                           ProfileId profile_id,
-                           bool use_profile_to_restrict_events,
-                           const GURL& event_url) {
-    ASSERT_FALSE(task_queue_.empty());
+  // IPC::Message::Sender
+  virtual bool Send(IPC::Message* message) {
+    EXPECT_EQ(ExtensionMsg_MessageInvoke::ID, message->type());
+
+    EXPECT_FALSE(task_queue_.empty());
     MessageLoop::current()->PostTask(FROM_HERE, task_queue_.front());
     task_queue_.pop();
+
+    return false;
   }
 
   std::queue<Task*> task_queue_;
 };
 
 class ExtensionWebRequestTest : public testing::Test {
 protected:
   virtual void SetUp() {
-    event_router_ = new TestEventRouter();
+    event_router_ = new ExtensionEventRouterForwarder();
     enable_referrers_.Init(
         prefs::kEnableReferrers, profile_.GetTestingPrefService(), NULL);
     network_delegate_.reset(new ChromeNetworkDelegate(
-        event_router_.get(), profile_.GetRuntimeId(),
+        event_router_.get(), NULL, profile_.GetRuntimeId(),
         &enable_referrers_));
     context_ = new TestURLRequestContext();
     context_->set_network_delegate(network_delegate_.get());
   }
 
   MessageLoopForIO io_loop_;
   TestingProfile profile_;
   TestDelegate delegate_;
   BooleanPrefMember enable_referrers_;
-  scoped_refptr<TestEventRouter> event_router_;
+  TestIPCSender ipc_sender_;
+  scoped_refptr<ExtensionEventRouterForwarder> event_router_;
+  scoped_refptr<ExtensionInfoMap> extension_info_map_;
   scoped_ptr<ChromeNetworkDelegate> network_delegate_;
   scoped_refptr<TestURLRequestContext> context_;
 };
 
 // Tests that we handle disagreements among extensions about responses to
 // blocking events by choosing the response from the most-recently-installed
 // extension.
 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedence) {
   std::string extension1_id("1");
   std::string extension2_id("2");
   ExtensionWebRequestEventRouter::RequestFilter filter;
   const std::string kEventName(keys::kOnBeforeRequest);
+  base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       profile_.GetRuntimeId(), extension1_id, kEventName,
       kEventName + "/1", filter,
-      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING);
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING,
+      ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       profile_.GetRuntimeId(), extension2_id, kEventName,
       kEventName + "/2", filter,
-      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING);
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING,
+      ipc_sender_factory.GetWeakPtr());
 
   net::URLRequest request(GURL("about:blank"), &delegate_);
   request.set_context(context_);
 
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
     // the redirect - should win, since it has a later |install_time|. The
     // redirect will dispatch another pair of onBeforeRequest. There, the first
     // response should win (later |install_time|).
     GURL redirect_url("about:redirected");
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension1 response. Arrives first, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->cancel = true;
-    event_router_->PushTask(
+    ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
             profile_.GetRuntimeId(), extension1_id,
             kEventName, kEventName + "/1", request.identifier(), response));
 
     // Extension2 response. Arrives second, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
-    event_router_->PushTask(
+    ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
             profile_.GetRuntimeId(), extension2_id,
             kEventName, kEventName + "/2", request.identifier(), response));
 
     // Extension2 response to the redirected URL. Arrives first, and chosen.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
-    event_router_->PushTask(
+    ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
             profile_.GetRuntimeId(), extension2_id,
             kEventName, kEventName + "/2", request.identifier(), response));
 
     // Extension1 response to the redirected URL. Arrives second, and ignored.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->cancel = true;
-    event_router_->PushTask(
+    ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
             profile_.GetRuntimeId(), extension1_id,
             kEventName, kEventName + "/1", request.identifier(), response));
 
     request.Start();
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(!request.is_pending());
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
     EXPECT_EQ(0, request.status().os_error());
     EXPECT_EQ(redirect_url, request.url());
     EXPECT_EQ(2U, request.url_chain().size());
-    EXPECT_EQ(0U, event_router_->GetNumTasks());
+    EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 }