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

chrome/browser/extensions/extension_webrequest_api.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 "chrome/browser/extensions/extension_webrequest_api.h"
 
 #include <algorithm>
 
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/extension_event_router_forwarder.h"
+#include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_id_map.h"
 #include "chrome/browser/extensions/extension_webrequest_api_constants.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/browser_message_filter.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "googleurl/src/gurl.h"
 
 namespace keys = extension_webrequest_api_constants;
 
@@ skipping 44 matching lines @@
 const char* ResourceTypeToString(ResourceType::Type type) {
   ResourceType::Type* iter =
       std::find(kResourceTypeValues, ARRAYEND(kResourceTypeValues), type);
   if (iter == ARRAYEND(kResourceTypeValues))
     return "other";
 
   return kResourceTypeStrings[iter - kResourceTypeValues];
 }
 
 bool ParseResourceType(const std::string& type_str,
-                              ResourceType::Type* type) {
+                       ResourceType::Type* type) {
   const char** iter =
       std::find(kResourceTypeStrings, ARRAYEND(kResourceTypeStrings), type_str);
   if (iter == ARRAYEND(kResourceTypeStrings))
     return false;
   *type = kResourceTypeValues[iter - kResourceTypeStrings];
   return true;
 }
 
 void ExtractRequestInfo(net::URLRequest* request,
-                               int* tab_id,
-                               int* window_id,
-                               ResourceType::Type* resource_type) {
+                        int* tab_id,
+                        int* window_id,
+                        ResourceType::Type* resource_type) {
   if (!request->GetUserData(NULL))
     return;
 
   ResourceDispatcherHostRequestInfo* info =
       ResourceDispatcherHost::InfoForRequest(request);
   ExtensionTabIdMap::GetInstance()->GetTabAndWindowId(
       info->child_id(), info->route_id(), tab_id, window_id);
 
   // Restrict the resource type to the values we care about.
   ResourceType::Type* iter =
       std::find(kResourceTypeValues, ARRAYEND(kResourceTypeValues),
                 info->resource_type());
   *resource_type = (iter != ARRAYEND(kResourceTypeValues)) ?
       *iter : ResourceType::LAST_TYPE;
 }
 
-void AddEventListenerOnIOThread(
-    ProfileId profile_id,
-    const std::string& extension_id,
-    const std::string& event_name,
-    const std::string& sub_event_name,
-    const ExtensionWebRequestEventRouter::RequestFilter& filter,
-    int extra_info_spec) {
-  ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-      profile_id, extension_id, event_name, sub_event_name, filter,
-      extra_info_spec);
-}
-
-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);
-}
-
 // Creates a list of HttpHeaders (see extension_api.json). If |headers| is
 // NULL, the list is empty. Ownership is passed to the caller.
 ListValue* GetResponseHeadersList(const net::HttpResponseHeaders* headers) {
   ListValue* headers_value = new ListValue();
   if (headers) {
     void* iter = NULL;
     std::string name;
     std::string value;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       DictionaryValue* header = new DictionaryValue();
@@ skipping 27 matching lines @@
 }  // namespace
 
 // Represents a single unique listener to an event, along with whatever filter
 // parameters and extra_info_spec were specified at the time the listener was
 // added.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
+  base::WeakPtr<IPC::Message::Sender> ipc_sender;
   mutable std::set<uint64> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
     if (extension_id < that.extension_id)
       return true;
     if (extension_id == that.extension_id &&
         sub_event_name < that.sub_event_name)
       return true;
     return false;
@@ skipping 137 matching lines @@
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter() {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     net::CompletionCallback* callback,
     GURL* new_url) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (profile_id == Profile::kInvalidProfileId)
     return net::OK;
 
   // If this is an HTTP request, keep track of it. HTTP-specific events only
   // have the request ID, so we'll need to look up the URLRequest from that.
   // We need to do this even if no extension subscribes to OnBeforeRequest to
   // guarantee that |http_requests_| is populated if an extension subscribes
   // to OnBeforeSendHeaders or OnRequestSent.
   if (request->url().SchemeIs(chrome::kHttpScheme) ||
       request->url().SchemeIs(chrome::kHttpsScheme)) {
     http_requests_[request->identifier()] = request;
   }
 
   int tab_id = -1;
   int window_id = -1;
   ResourceType::Type resource_type = ResourceType::LAST_TYPE;
   ExtractRequestInfo(request, &tab_id, &window_id, &resource_type);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnBeforeRequest, request->url(),
+      GetMatchingListeners(extension_info_map, profile_id,

[Mihai Parparita -not on Chrome, 2011/06/08 01:11:59]

All of the functions in ExtensionWebRequestEventRouter take a profile_id and
then the extension_info_map, but GetMatchingListeners has them reversed. Mind
making it consistent?

+                           keys::kOnBeforeRequest, request->url(),
                            tab_id, window_id, resource_type, &extra_info_spec);
   if (listeners.empty())
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRequest))
     return net::OK;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kMethodKey, request->method());
   dict->SetInteger(keys::kTabIdKey, tab_id);
   dict->SetString(keys::kTypeKey, ResourceTypeToString(resource_type));
   dict->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
   args.Append(dict);
 
-  if (DispatchEvent(profile_id, event_router, request, listeners, args)) {
+  if (DispatchEvent(profile_id, request, listeners, args)) {
     blocked_requests_[request->identifier()].event = kOnBeforeRequest;
     blocked_requests_[request->identifier()].callback = callback;
     blocked_requests_[request->identifier()].new_url = new_url;
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     uint64 request_id,
     net::CompletionCallback* callback,
     net::HttpRequestHeaders* headers) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (profile_id == Profile::kInvalidProfileId)
     return net::OK;
 
   HttpRequestMap::iterator iter = http_requests_.find(request_id);
   if (iter == http_requests_.end())
     return net::OK;
 
   net::URLRequest* request = iter->second;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders))
     return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnBeforeSendHeaders, request,
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnBeforeSendHeaders, request,
                            &extra_info_spec);
   if (listeners.empty())
     return net::OK;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
 
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   // TODO(battre): implement request line.
 
   args.Append(dict);
 
-  if (DispatchEvent(profile_id, event_router, request, listeners, args)) {
+  if (DispatchEvent(profile_id, request, listeners, args)) {
     blocked_requests_[request->identifier()].event = kOnBeforeSendHeaders;
     blocked_requests_[request->identifier()].callback = callback;
     blocked_requests_[request->identifier()].request_headers = headers;
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 void ExtensionWebRequestEventRouter::OnRequestSent(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     uint64 request_id,
     const net::HostPortPair& socket_address,
     const net::HttpRequestHeaders& headers) {
   if (profile_id == Profile::kInvalidProfileId)
     return;
   base::Time time(base::Time::Now());
 
   HttpRequestMap::iterator iter = http_requests_.find(request_id);
   if (iter == http_requests_.end())
     return;
 
   net::URLRequest* request = iter->second;
 
   if (GetAndSetSignaled(request->identifier(), kOnRequestSent))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnRequestSent, request,
-                           &extra_info_spec);
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnRequestSent, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kIpKey, socket_address.host());
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(&headers));
   // TODO(battre): support "request line".
   args.Append(dict);
 
-  DispatchEvent(profile_id, event_router, request, listeners, args);
+  DispatchEvent(profile_id, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
   if (profile_id == Profile::kInvalidProfileId)
     return;
   base::Time time(base::Time::Now());
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRequest);
   ClearSignaled(request->identifier(), kOnBeforeSendHeaders);
   ClearSignaled(request->identifier(), kOnRequestSent);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnBeforeRedirect, request,
-                           &extra_info_spec);
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnBeforeRedirect, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   int http_status_code = request->GetResponseCode();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kRedirectUrlKey, new_location.spec());
   dict->SetInteger(keys::kStatusCodeKey, http_status_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   if (extra_info_spec & ExtraInfoSpec::STATUS_LINE)
     dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   args.Append(dict);
 
-  DispatchEvent(profile_id, event_router, request, listeners, args);
+  DispatchEvent(profile_id, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
   if (profile_id == Profile::kInvalidProfileId)
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnResponseStarted, request,
-                           &extra_info_spec);
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnResponseStarted, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   // UrlRequestFileJobs do not send headers, so we simulate their behavior.
   int response_code = 200;
   if (request->response_headers())
     response_code = request->response_headers()->response_code();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   if (extra_info_spec & ExtraInfoSpec::STATUS_LINE)
     dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   args.Append(dict);
 
-  DispatchEvent(profile_id, event_router, request, listeners, args);
+  DispatchEvent(profile_id, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
   if (profile_id == Profile::kInvalidProfileId)
     return;
 
   DCHECK(request->status().status() == net::URLRequestStatus::SUCCESS);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnCompleted));
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnCompleted, request,
-                           &extra_info_spec);
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnCompleted, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   // UrlRequestFileJobs do not send headers, so we simulate their behavior.
   int response_code = 200;
   if (request->response_headers())
     response_code = request->response_headers()->response_code();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   if (extra_info_spec & ExtraInfoSpec::STATUS_LINE)
     dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   args.Append(dict);
 
-  DispatchEvent(profile_id, event_router, request, listeners, args);
+  DispatchEvent(profile_id, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
+    ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
   if (profile_id == Profile::kInvalidProfileId)
       return;
 
   DCHECK(request->status().status() == net::URLRequestStatus::FAILED);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnErrorOccurred));
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, keys::kOnErrorOccurred, request,
-                           &extra_info_spec);
+      GetMatchingListeners(extension_info_map, profile_id,
+                           keys::kOnErrorOccurred, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kErrorKey,
                   net::ErrorToString(request->status().os_error()));
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   args.Append(dict);
 
-  DispatchEvent(profile_id, event_router, request, listeners, args);
+  DispatchEvent(profile_id, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnURLRequestDestroyed(
     ProfileId profile_id, net::URLRequest* request) {
   blocked_requests_.erase(request->identifier());
   signaled_requests_.erase(request->identifier());
   http_requests_.erase(request->identifier());
 }
 
 void ExtensionWebRequestEventRouter::OnHttpTransactionDestroyed(
     ProfileId profile_id, uint64 request_id) {
   if (blocked_requests_.find(request_id) != blocked_requests_.end() &&
       blocked_requests_[request_id].event == kOnBeforeSendHeaders) {
     // Ensure we don't call into the deleted HttpTransaction.
     blocked_requests_[request_id].callback = NULL;
     blocked_requests_[request_id].request_headers = NULL;
   }
 }
 
 bool ExtensionWebRequestEventRouter::DispatchEvent(
     ProfileId profile_id,
-    ExtensionEventRouterForwarder* event_router,
     net::URLRequest* request,
     const std::vector<const EventListener*>& listeners,
     const ListValue& args) {
   std::string json_args;
 
   // TODO(mpcomplete): Consider consolidating common (extension_id,json_args)
   // pairs into a single message sent to a list of sub_event_names.
   int num_handlers_blocking = 0;
   for (std::vector<const EventListener*>::const_iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     // Filter out the optional keys that this listener didn't request.
     scoped_ptr<ListValue> args_filtered(args.DeepCopy());
     DictionaryValue* dict = NULL;
     CHECK(args_filtered->GetDictionary(0, &dict) && dict);
     if (!((*it)->extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS))
       dict->Remove(keys::kRequestHeadersKey, NULL);
     if (!((*it)->extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS))
       dict->Remove(keys::kResponseHeadersKey, NULL);
     if (!((*it)->extra_info_spec & ExtraInfoSpec::STATUS_LINE))
       dict->Remove(keys::kStatusLineKey, NULL);
 
     base::JSONWriter::Write(args_filtered.get(), false, &json_args);
-    event_router->DispatchEventToExtension(
-        (*it)->extension_id, (*it)->sub_event_name, json_args,
-        profile_id, true, GURL());
+
+    ExtensionEventRouter::DispatchEvent(
+        (*it)->ipc_sender.get(), (*it)->extension_id, (*it)->sub_event_name,
+        json_args, GURL());
     if ((*it)->extra_info_spec & ExtraInfoSpec::BLOCKING) {
       (*it)->blocked_requests.insert(request->identifier());
       ++num_handlers_blocking;
     }
   }
 
   if (num_handlers_blocking > 0) {
     CHECK(blocked_requests_.find(request->identifier()) ==
           blocked_requests_.end());
     blocked_requests_[request->identifier()].num_handlers_blocking =
@@ skipping 26 matching lines @@
 
   DecrementBlockCount(request_id, response);
 }
 
 void ExtensionWebRequestEventRouter::AddEventListener(
     ProfileId profile_id,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
-    int extra_info_spec) {
+    int extra_info_spec,
+    base::WeakPtr<IPC::Message::Sender> ipc_sender) {
   if (!IsWebRequestEvent(event_name))
     return;
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
   listener.filter = filter;
   listener.extra_info_spec = extra_info_spec;
+  listener.ipc_sender = ipc_sender;
 
   CHECK_EQ(listeners_[profile_id][event_name].count(listener), 0u) <<
       "extension=" << extension_id << " event=" << event_name;
   listeners_[profile_id][event_name].insert(listener);
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
     ProfileId profile_id,
     const std::string& extension_id,
     const std::string& sub_event_name) {
@@ skipping 20 matching lines @@
 
   // Unblock any request that this event listener may have been blocking.
   for (std::set<uint64>::iterator it = found->blocked_requests.begin();
        it != found->blocked_requests.end(); ++it) {
     DecrementBlockCount(*it, NULL);
   }
 
   listeners_[profile_id][event_name].erase(listener);
 }
 
-std::vector<const ExtensionWebRequestEventRouter::EventListener*>
-ExtensionWebRequestEventRouter::GetMatchingListeners(
+void ExtensionWebRequestEventRouter::OnOTRProfileCreated(
+    ProfileId original_profile_id, ProfileId otr_profile_id) {
+  cross_profile_map_[original_profile_id] = otr_profile_id;
+  cross_profile_map_[otr_profile_id] = original_profile_id;
+}
+
+void ExtensionWebRequestEventRouter::OnOTRProfileDestroyed(
+    ProfileId original_profile_id, ProfileId otr_profile_id) {
+  cross_profile_map_.erase(otr_profile_id);
+  cross_profile_map_.erase(original_profile_id);
+}
+
+void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
+    ExtensionInfoMap* extension_info_map,
     ProfileId profile_id,
+    bool crosses_incognito,
     const std::string& event_name,
     const GURL& url,
     int tab_id,
     int window_id,
     ResourceType::Type resource_type,
-    int* extra_info_spec) {
-  // TODO(mpcomplete): handle profile_id == invalid (should collect all
-  // listeners).
-  *extra_info_spec = 0;
-
-  std::vector<const EventListener*> matching_listeners;
+    int* extra_info_spec,
+    std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
+        matching_listeners) {
   std::set<EventListener>& listeners = listeners_[profile_id][event_name];
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
+    if (!it->ipc_sender.get()) {
+      // The IPC sender has been deleted. This listener will be removed soon
+      // via a call to RemoveEventListener. For now, just skip it.
+      continue;
+    }
+
     if (!it->filter.urls.is_empty() && !it->filter.urls.MatchesURL(url))
       continue;
     if (it->filter.tab_id != -1 && tab_id != it->filter.tab_id)
       continue;
     if (it->filter.window_id != -1 && window_id != it->filter.window_id)
       continue;
     if (!it->filter.types.empty() &&
         std::find(it->filter.types.begin(), it->filter.types.end(),
                   resource_type) == it->filter.types.end())
       continue;
 
-    matching_listeners.push_back(&(*it));
+    // Check if this event crosses incognito boundaries when it shouldn't.
+    // extension_info_map can be NULL if this is a system-level request.
+    if (extension_info_map) {
+      const Extension* extension =
+          extension_info_map->extensions().GetByID(it->extension_id);
+      if (!extension ||
+          (crosses_incognito &&
+           !extension_info_map->CanCrossIncognito(extension)))
+        continue;
+    }
+
+    matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
+}
+
+std::vector<const ExtensionWebRequestEventRouter::EventListener*>
+ExtensionWebRequestEventRouter::GetMatchingListeners(
+    ExtensionInfoMap* extension_info_map,
+    ProfileId profile_id,
+    const std::string& event_name,
+    const GURL& url,
+    int tab_id,
+    int window_id,
+    ResourceType::Type resource_type,
+    int* extra_info_spec) {
+  // TODO(mpcomplete): handle profile_id == invalid (should collect all
+  // listeners).
+  *extra_info_spec = 0;
+
+  std::vector<const ExtensionWebRequestEventRouter::EventListener*>
+      matching_listeners;
+
+  GetMatchingListenersImpl(
+      extension_info_map, profile_id, false, event_name, url,
+      tab_id, window_id, resource_type, extra_info_spec, &matching_listeners);
+  CrossProfileMap::const_iterator cross_profile_id =
+      cross_profile_map_.find(profile_id);
+  if (cross_profile_id != cross_profile_map_.end()) {
+    GetMatchingListenersImpl(
+        extension_info_map, cross_profile_id->second, true, event_name, url,
+        tab_id, window_id, resource_type, extra_info_spec, &matching_listeners);
+  }
+
   return matching_listeners;
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
+    ExtensionInfoMap* extension_info_map,
     ProfileId profile_id,
     const std::string& event_name,
     net::URLRequest* request,
     int* extra_info_spec) {
   int tab_id = -1;
   int window_id = -1;
   ResourceType::Type resource_type = ResourceType::LAST_TYPE;
   ExtractRequestInfo(request, &tab_id, &window_id, &resource_type);
 
   return GetMatchingListeners(
-      profile_id, event_name, request->url(), tab_id, window_id, resource_type,
-      extra_info_spec);
+      extension_info_map, profile_id, event_name, request->url(),
+      tab_id, window_id, resource_type, extra_info_spec);
 }
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     uint64 request_id,
     EventResponse* response) {
   scoped_ptr<EventResponse> response_scoped(response);
 
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   if (blocked_requests_.find(request_id) == blocked_requests_.end())
@@ skipping 99 matching lines @@
         ExtensionWebRequestEventRouter::ExtraInfoSpec::InitFromValue(
             *value, &extra_info_spec));
   }
 
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(3, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &sub_event_name));
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableFunction(
-          &AddEventListenerOnIOThread,
-          profile()->GetRuntimeId(), extension_id(),
-          event_name, sub_event_name, filter, extra_info_spec));
+  ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
+      profile_id(), extension_id(), event_name, sub_event_name, filter,
+      extra_info_spec, ipc_sender_weak());
 
   return true;
 }
 
 bool WebRequestEventHandled::RunImpl() {
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &sub_event_name));
 
   std::string request_id_str;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &request_id_str));
   // TODO(mpcomplete): string-to-uint64?
   int64 request_id;
   EXTENSION_FUNCTION_VALIDATE(base::StringToInt64(request_id_str, &request_id));
 
   scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response;
   if (HasOptionalArgument(3)) {
     DictionaryValue* value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(3, &value));
 
     if (!value->empty()) {
       base::Time install_time =
-          profile()->GetExtensionService()->extension_prefs()->
-              GetInstallTime(extension_id());
+          extension_info_map()->GetInstallTime(extension_id());
       response.reset(new ExtensionWebRequestEventRouter::EventResponse(
           extension_id(), install_time));
     }
 
     if (value->HasKey("cancel")) {
       // Don't allow cancel mixed with other keys.
       if (value->HasKey("redirectUrl") || value->HasKey("requestHeaders")) {
         error_ = keys::kInvalidBlockingResponse;
         return false;
       }
@@ skipping 29 matching lines @@
         EXTENSION_FUNCTION_VALIDATE(
             header_value->GetString(keys::kHeaderNameKey, &name));
         EXTENSION_FUNCTION_VALIDATE(
             header_value->GetString(keys::kHeaderValueKey, &value));
 
         response->request_headers->SetHeader(name, value);
       }
     }
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableFunction(
-          &EventHandledOnIOThread,
-          profile()->GetRuntimeId(), extension_id(),
-          event_name, sub_event_name, request_id, response.release()));
+  ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
+      profile_id(), extension_id(), event_name, sub_event_name, request_id,
+      response.release());
 
   return true;
 }