Introduce WebRequestEventRouterDelegate.

chrome/browser/extensions/api/web_request/web_request_api.cc

 // Copyright (c) 2012 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/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/chrome_content_browser_client.h"
-#include "chrome/browser/extensions/activity_log/activity_action_constants.h"
-#include "chrome/browser/extensions/activity_log/activity_actions.h"
-#include "chrome/browser/extensions/activity_log/activity_log.h"
-#include "chrome/browser/extensions/activity_log/web_request_constants.h"
 #include "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
-#include "chrome/browser/extensions/extension_renderer_state.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/web_request.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/url_constants.h"
-#include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/user_metrics.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h"
+#include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/web_request/web_request_api_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/browser/api/web_request/web_request_api_utils.h"
+#include "extensions/browser/api/web_request/web_request_api_utils.h"
+#include "extensions/browser/api/web_request/web_request_event_router_delegate.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_message_filter.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/web_view/web_view_constants.h"
 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/browser/warning_service.h"
 #include "extensions/browser/warning_set.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/event_filtering_info.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/url_pattern.h"
+#include "extensions/strings/grit/extensions_strings.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using base::DictionaryValue;
@@ skipping 10 matching lines @@
 using extensions::RulesRegistryService;
 using extensions::Warning;
 using extensions::WarningService;
 using extensions::WarningSet;
 
 namespace helpers = extension_web_request_api_helpers;
 namespace utils = extension_web_request_api_utils;
 namespace keys = extension_web_request_api_constants;
 namespace web_request = extensions::api::web_request;
 namespace declarative_keys = extensions::declarative_webrequest_constants;
-namespace activitylog = activity_log_web_request_constants;
 
 namespace {
 
 const char kWebRequestEventPrefix[] = "webRequest.";
 
 // List of all the webRequest events.
 const char* const kWebRequestEvents[] = {
   keys::kOnBeforeRedirectEvent,
   web_request::OnBeforeRequest::kEventName,
   keys::kOnBeforeSendHeadersEvent,
   keys::kOnCompletedEvent,
   web_request::OnErrorOccurred::kEventName,
   keys::kOnSendHeadersEvent,
   keys::kOnAuthRequiredEvent,
   keys::kOnResponseStartedEvent,
   keys::kOnHeadersReceivedEvent,
 };
 
-#define ARRAYEND(array) (array + arraysize(array))
+const size_t kWebRequestEventsLength = arraysize(kWebRequestEvents);
 
 const char* GetRequestStageAsString(
     ExtensionWebRequestEventRouter::EventTypes type) {
   switch (type) {
     case ExtensionWebRequestEventRouter::kInvalidEvent:
       return "Invalid";
     case ExtensionWebRequestEventRouter::kOnBeforeRequest:
       return keys::kOnBeforeRequest;
     case ExtensionWebRequestEventRouter::kOnBeforeSendHeaders:
       return keys::kOnBeforeSendHeaders;
@@ skipping 20 matching lines @@
   return is_main_frame ? 0 : frame_id;
 }
 
 bool IsWebRequestEvent(const std::string& event_name) {
   std::string web_request_event_name(event_name);
   if (StartsWithASCII(
           web_request_event_name, webview::kWebViewEventPrefix, true)) {
     web_request_event_name.replace(
         0, strlen(webview::kWebViewEventPrefix), kWebRequestEventPrefix);
   }
-  return std::find(kWebRequestEvents, ARRAYEND(kWebRequestEvents),
-                   web_request_event_name) != ARRAYEND(kWebRequestEvents);
+  return std::find(
+      kWebRequestEvents,
+      kWebRequestEvents + kWebRequestEventsLength,
+      web_request_event_name) != (kWebRequestEvents + kWebRequestEventsLength);
 }
 
 // Returns whether |request| has been triggered by an extension in
 // |extension_info_map|.
 bool IsRequestFromExtension(const net::URLRequest* request,
                             const InfoMap* extension_info_map) {
   // |extension_info_map| is NULL for system-level requests.
   if (!extension_info_map)
     return false;
 
@@ skipping 29 matching lines @@
   ExtractRequestRoutingInfo(request, &render_process_host_id, &routing_id);
   return extensions::WebViewRendererState::GetInstance()->
       GetInfo(render_process_host_id, routing_id, web_view_info);
 }
 
 void ExtractRequestInfoDetails(net::URLRequest* request,
                                bool* is_main_frame,
                                int* frame_id,
                                bool* parent_is_main_frame,
                                int* parent_frame_id,
-                               int* tab_id,
-                               int* window_id,
                                int* render_process_host_id,
                                int* routing_id,
                                ResourceType* resource_type) {
   if (!request->GetUserData(NULL))
     return;
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  ExtensionRendererState::GetInstance()->GetTabAndWindowId(
-      info, tab_id, window_id);
   *frame_id = info->GetRenderFrameID();
   *is_main_frame = info->IsMainFrame();
   *parent_frame_id = info->GetParentRenderFrameID();
   *parent_is_main_frame = info->ParentIsMainFrame();
   *render_process_host_id = info->GetChildID();
   *routing_id = info->GetRouteID();
 
   // Restrict the resource type to the values we care about.
   if (utils::IsRelevantResourceType(info->GetResourceType()))
     *resource_type = info->GetResourceType();
   else
     *resource_type = content::RESOURCE_TYPE_LAST_TYPE;
 }
 
-// Extracts from |request| information for the keys requestId, url, method,
-// frameId, tabId, type, and timeStamp and writes these into |out| to be passed
-// on to extensions.
-void ExtractRequestInfo(net::URLRequest* request, base::DictionaryValue* out) {
-  bool is_main_frame = false;
-  int frame_id = -1;
-  bool parent_is_main_frame = false;
-  int parent_frame_id = -1;
-  int frame_id_for_extension = -1;
-  int parent_frame_id_for_extension = -1;
-  int tab_id = -1;
-  int window_id = -1;
-  int render_process_host_id = -1;
-  int routing_id = -1;
-  ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
-  ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
-                            &parent_is_main_frame, &parent_frame_id, &tab_id,
-                            &window_id, &render_process_host_id, &routing_id,
-                            &resource_type);
-  frame_id_for_extension = GetFrameId(is_main_frame, frame_id);
-  parent_frame_id_for_extension = GetFrameId(parent_is_main_frame,
-                                             parent_frame_id);
-
-  out->SetString(keys::kRequestIdKey,
-                 base::Uint64ToString(request->identifier()));
-  out->SetString(keys::kUrlKey, request->url().spec());
-  out->SetString(keys::kMethodKey, request->method());
-  out->SetInteger(keys::kFrameIdKey, frame_id_for_extension);
-  out->SetInteger(keys::kParentFrameIdKey, parent_frame_id_for_extension);
-  out->SetInteger(keys::kTabIdKey, tab_id);
-  out->SetString(keys::kTypeKey, utils::ResourceTypeToString(resource_type));
-  out->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
-}
-
 // Extracts the body from |request| and writes the data into |out|.
 void ExtractRequestInfoBody(const net::URLRequest* request,
                             base::DictionaryValue* out) {
   const net::UploadDataStream* upload_data = request->get_upload();
   if (!upload_data ||
       (request->method() != "POST" && request->method() != "PUT"))
     return;  // Need to exit without "out->Set(keys::kRequestBodyKey, ...);" .
 
   base::DictionaryValue* requestBody = new base::DictionaryValue();
   out->Set(keys::kRequestBodyKey, requestBody);
@@ skipping 49 matching lines @@
     if (!header_value->HasKey(keys::kHeaderBinaryValueKey)) {
       *value = "";
     } else if (!header_value->GetList(keys::kHeaderBinaryValueKey, &list) ||
                !helpers::CharListToString(list, value)) {
       return false;
     }
   }
   return true;
 }
 
-// Converts the |name|, |value| pair of a http header to a HttpHeaders
-// dictionary. Ownership is passed to the caller.
-base::DictionaryValue* ToHeaderDictionary(const std::string& name,
-                                          const std::string& value) {
-  base::DictionaryValue* header = new base::DictionaryValue();
-  header->SetString(keys::kHeaderNameKey, name);
-  if (base::IsStringUTF8(value)) {
-    header->SetString(keys::kHeaderValueKey, value);
-  } else {
-    header->Set(keys::kHeaderBinaryValueKey,
-                helpers::StringToCharList(value));
-  }
-  return header;
-}
-
 // Creates a list of HttpHeaders (see the extension API JSON). If |headers| is
 // NULL, the list is empty. Ownership is passed to the caller.
 base::ListValue* GetResponseHeadersList(
     const net::HttpResponseHeaders* headers) {
   base::ListValue* headers_value = new base::ListValue();
   if (headers) {
     void* iter = NULL;
     std::string name;
     std::string value;
     while (headers->EnumerateHeaderLines(&iter, &name, &value))
-      headers_value->Append(ToHeaderDictionary(name, value));
+      headers_value->Append(helpers::CreateHeaderDictionary(name, value));
   }
   return headers_value;
 }
 
 base::ListValue* GetRequestHeadersList(const net::HttpRequestHeaders& headers) {
   base::ListValue* headers_value = new base::ListValue();
   for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext(); )
-    headers_value->Append(ToHeaderDictionary(it.name(), it.value()));
+    headers_value->Append(
+        helpers::CreateHeaderDictionary(it.name(), it.value()));
   return headers_value;
 }
 
 // Creates a base::StringValue with the status line of |headers|. If |headers|
 // is NULL, an empty string is returned.  Ownership is passed to the caller.
 base::StringValue* GetStatusLine(net::HttpResponseHeaders* headers) {
   return new base::StringValue(
       headers ? headers->GetStatusLine() : std::string());
 }
 
 void RemoveEventListenerOnUI(
-  void* profile_id,
+  void* browser_context_id,
   const std::string& event_name,
   int process_id,
   const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  Profile* profile = reinterpret_cast<Profile*>(profile_id);
-  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+  content::BrowserContext* browser_context =
+      reinterpret_cast<content::BrowserContext*>(browser_context_id);
+  if (!extensions::ExtensionsBrowserClient::Get()->IsValidContext(
+      browser_context))
     return;
 
-  extensions::EventRouter* event_router = extensions::EventRouter::Get(profile);
+  extensions::EventRouter* event_router =
+      extensions::EventRouter::Get(browser_context);
   if (!event_router)
     return;
 
   content::RenderProcessHost* process =
       content::RenderProcessHost::FromID(process_id);
   if (!process)
     return;
 
   event_router->RemoveEventListener(event_name, process, extension_id);
 }
 
 // Sends an event to subscribers of chrome.declarativeWebRequest.onMessage or
 // to subscribers of webview.onMessage if the action is being operated upon
 // a <webview> guest renderer.
 // |extension_id| identifies the extension that sends and receives the event.
 // |is_web_view_guest| indicates whether the action is for a <webview>.
 // |web_view_info| is a struct containing information about the <webview>
 // embedder.
 // |event_argument| is passed to the event listener.
 void SendOnMessageEventOnUI(
-    void* profile_id,
+    void* browser_context_id,
     const std::string& extension_id,
     bool is_web_view_guest,
     const extensions::WebViewRendererState::WebViewInfo& web_view_info,
     scoped_ptr<base::DictionaryValue> event_argument) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  Profile* profile = reinterpret_cast<Profile*>(profile_id);
-  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+  content::BrowserContext* browser_context =
+      reinterpret_cast<content::BrowserContext*>(browser_context_id);
+  if (!extensions::ExtensionsBrowserClient::Get()->IsValidContext(
+      browser_context))
     return;
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue);
   event_args->Append(event_argument.release());
 
-  extensions::EventRouter* event_router = extensions::EventRouter::Get(profile);
+  extensions::EventRouter* event_router =
+      extensions::EventRouter::Get(browser_context);
 
   extensions::EventFilteringInfo event_filtering_info;
 
   std::string event_name;
   // The instance ID uniquely identifies a <webview> instance within an embedder
   // process. We use a filter here so that only event listeners for a particular
   // <webview> will fire.
   if (is_web_view_guest) {
     event_filtering_info.SetInstanceID(web_view_info.instance_id);
     event_name = webview::kEventMessage;
   } else {
     event_name = declarative_keys::kOnMessage;
   }
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       event_name,
-      event_args.Pass(), profile, GURL(),
+      event_args.Pass(), browser_context, GURL(),
       extensions::EventRouter::USER_GESTURE_UNKNOWN,
       event_filtering_info));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void RemoveEventListenerOnIOThread(
     content::BrowserContext* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
@@ skipping 227 matching lines @@
 ExtensionWebRequestEventRouter::EventResponse::EventResponse(
     const std::string& extension_id, const base::Time& extension_install_time)
     : extension_id(extension_id),
       extension_install_time(extension_install_time),
       cancel(false) {
 }
 
 ExtensionWebRequestEventRouter::EventResponse::~EventResponse() {
 }
 
-
 ExtensionWebRequestEventRouter::RequestFilter::RequestFilter()
     : tab_id(-1), window_id(-1) {
 }
 
 ExtensionWebRequestEventRouter::RequestFilter::~RequestFilter() {
 }
 
 //
 // ExtensionWebRequestEventRouter
 //
 
 // static
 ExtensionWebRequestEventRouter* ExtensionWebRequestEventRouter::GetInstance() {
   return Singleton<ExtensionWebRequestEventRouter>::get();
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
+  web_request_event_router_delegate_.reset(
+      extensions::ExtensionsAPIClient::Get()->
+          CreateWebRequestEventRouterDelegate());
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
-    void* profile,
+    void* browser_context,
     const extensions::RulesRegistry::WebViewKey& webview_key,
     scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
-  RulesRegistryKey key(profile, webview_key);
+  RulesRegistryKey key(browser_context, webview_key);
   if (rules_registry.get())
     rules_registries_[key] = rules_registry;
   else
     rules_registries_.erase(key);
 }
 
+void ExtensionWebRequestEventRouter::ExtractRequestInfo(
+    net::URLRequest* request, base::DictionaryValue* out) {
+  bool is_main_frame = false;
+  int frame_id = -1;
+  bool parent_is_main_frame = false;
+  int parent_frame_id = -1;
+  int frame_id_for_extension = -1;
+  int parent_frame_id_for_extension = -1;
+  int render_process_host_id = -1;
+  int routing_id = -1;
+  ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
+  ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
+                            &parent_is_main_frame, &parent_frame_id,
+                            &render_process_host_id, &routing_id,
+                            &resource_type);
+  frame_id_for_extension = GetFrameId(is_main_frame, frame_id);
+  parent_frame_id_for_extension = GetFrameId(parent_is_main_frame,
+                                             parent_frame_id);
+
+  out->SetString(keys::kRequestIdKey,
+                 base::Uint64ToString(request->identifier()));
+  out->SetString(keys::kUrlKey, request->url().spec());
+  out->SetString(keys::kMethodKey, request->method());
+  out->SetInteger(keys::kFrameIdKey, frame_id_for_extension);
+  out->SetInteger(keys::kParentFrameIdKey, parent_frame_id_for_extension);
+  out->SetString(keys::kTypeKey, utils::ResourceTypeToString(resource_type));
+  out->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
+  if (web_request_event_router_delegate_) {
+    web_request_event_router_delegate_->ExtractExtraRequestDetails(
+        request, out);
+  }
+}
+
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   if (IsPageLoad(request))
     NotifyPageLoad();
 
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
                                              request->url(),
-                                             profile);
+                                             browser_context);
 
   // Whether to initialized blocked_requests_.
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(profile, extension_info_map,
+      ProcessDeclarativeRules(browser_context, extension_info_map,
                               web_request::OnBeforeRequest::kEventName, request,
                               extensions::ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            web_request::OnBeforeRequest::kEventName, request,
                            &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeRequest)) {
     base::ListValue args;
     base::DictionaryValue* dict = new base::DictionaryValue();
     ExtractRequestInfo(request, dict);
     if (extra_info_spec & ExtraInfoSpec::REQUEST_BODY)
       ExtractRequestInfoBody(request, dict);
     args.Append(dict);
 
     initialize_blocked_requests |=
-        DispatchEvent(profile, request, listeners, args);
+        DispatchEvent(browser_context, request, listeners, args);
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
   blocked_requests_[request->identifier()].event = kOnBeforeRequest;
   blocked_requests_[request->identifier()].is_incognito |=
-      IsIncognitoProfile(profile);
+      IsIncognitoBrowserContext(browser_context);
   blocked_requests_[request->identifier()].request = request;
   blocked_requests_[request->identifier()].callback = callback;
   blocked_requests_[request->identifier()].new_url = new_url;
   blocked_requests_[request->identifier()].net_log = &request->net_log();
 
   if (blocked_requests_[request->identifier()].num_handlers_blocking == 0) {
     // If there are no blocking handlers, only the declarative rules tried
     // to modify the request and we can respond synchronously.
-    return ExecuteDeltas(profile, request->identifier(),
+    return ExecuteDeltas(browser_context, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(profile, extension_info_map,
+      ProcessDeclarativeRules(browser_context, extension_info_map,
                               keys::kOnBeforeSendHeadersEvent, request,
                               extensions::ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnBeforeSendHeadersEvent, request,
                            &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders)) {
     base::ListValue args;
     base::DictionaryValue* dict = new base::DictionaryValue();
     ExtractRequestInfo(request, dict);
     if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
       dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(*headers));
     args.Append(dict);
 
     initialize_blocked_requests |=
-        DispatchEvent(profile, request, listeners, args);
+        DispatchEvent(browser_context, request, listeners, args);
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
   blocked_requests_[request->identifier()].event = kOnBeforeSendHeaders;
   blocked_requests_[request->identifier()].is_incognito |=
-      IsIncognitoProfile(profile);
+      IsIncognitoBrowserContext(browser_context);
   blocked_requests_[request->identifier()].request = request;
   blocked_requests_[request->identifier()].callback = callback;
   blocked_requests_[request->identifier()].request_headers = headers;
   blocked_requests_[request->identifier()].net_log = &request->net_log();
 
   if (blocked_requests_[request->identifier()].num_handlers_blocking == 0) {
     // If there are no blocking handlers, only the declarative rules tried
     // to modify the request and we can respond synchronously.
-    return ExecuteDeltas(profile, request->identifier(),
+    return ExecuteDeltas(browser_context, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 void ExtensionWebRequestEventRouter::OnSendHeaders(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnSendHeaders))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnSendHeadersEvent, request,
                            &extra_info_spec);
   if (listeners.empty())
     return;
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  DispatchEvent(browser_context, request, listeners, args);
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(profile, extension_info_map,
+      ProcessDeclarativeRules(browser_context, extension_info_map,
                               keys::kOnHeadersReceivedEvent, request,
                               extensions::ON_HEADERS_RECEIVED,
                               original_response_headers);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnHeadersReceivedEvent, request,
                            &extra_info_spec);
 
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnHeadersReceived)) {
     base::ListValue args;
     base::DictionaryValue* dict = new base::DictionaryValue();
     ExtractRequestInfo(request, dict);
     dict->SetString(keys::kStatusLineKey,
         original_response_headers->GetStatusLine());
     if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
       dict->Set(keys::kResponseHeadersKey,
           GetResponseHeadersList(original_response_headers));
     }
     args.Append(dict);
 
     initialize_blocked_requests |=
-        DispatchEvent(profile, request, listeners, args);
+        DispatchEvent(browser_context, request, listeners, args);
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
   blocked_requests_[request->identifier()].event = kOnHeadersReceived;
   blocked_requests_[request->identifier()].is_incognito |=
-      IsIncognitoProfile(profile);
+      IsIncognitoBrowserContext(browser_context);
   blocked_requests_[request->identifier()].request = request;
   blocked_requests_[request->identifier()].callback = callback;
   blocked_requests_[request->identifier()].net_log = &request->net_log();
   blocked_requests_[request->identifier()].override_response_headers =
       override_response_headers;
   blocked_requests_[request->identifier()].original_response_headers =
       original_response_headers;
   blocked_requests_[request->identifier()].new_url =
       allowed_unsafe_redirect_url;
 
   if (blocked_requests_[request->identifier()].num_handlers_blocking == 0) {
     // If there are no blocking handlers, only the declarative rules tried
     // to modify the request and we can respond synchronously.
-    return ExecuteDeltas(profile, request->identifier(),
+    return ExecuteDeltas(browser_context, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ExtensionWebRequestEventRouter::OnAuthRequired(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const net::NetworkDelegate::AuthCallback& callback,
     net::AuthCredentials* credentials) {
-  // No profile means that this is for authentication challenges in the
+  // No browser_context means that this is for authentication challenges in the
   // system context. Skip in that case. Also skip sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnAuthRequiredEvent, request,
                            &extra_info_spec);
   if (listeners.empty())
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   dict->SetBoolean(keys::kIsProxyKey, auth_info.is_proxy);
   if (!auth_info.scheme.empty())
     dict->SetString(keys::kSchemeKey, auth_info.scheme);
   if (!auth_info.realm.empty())
     dict->SetString(keys::kRealmKey, auth_info.realm);
   base::DictionaryValue* challenger = new base::DictionaryValue();
   challenger->SetString(keys::kHostKey, auth_info.challenger.host());
   challenger->SetInteger(keys::kPortKey, auth_info.challenger.port());
   dict->Set(keys::kChallengerKey, challenger);
   dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
-  if (DispatchEvent(profile, request, listeners, args)) {
+  if (DispatchEvent(browser_context, request, listeners, args)) {
     blocked_requests_[request->identifier()].event = kOnAuthRequired;
     blocked_requests_[request->identifier()].is_incognito |=
-        IsIncognitoProfile(profile);
+        IsIncognitoBrowserContext(browser_context);
     blocked_requests_[request->identifier()].request = request;
     blocked_requests_[request->identifier()].auth_callback = callback;
     blocked_requests_[request->identifier()].auth_credentials = credentials;
     blocked_requests_[request->identifier()].net_log = &request->net_log();
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING;
   }
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRequest);
   ClearSignaled(request->identifier(), kOnBeforeSendHeaders);
   ClearSignaled(request->identifier(), kOnSendHeaders);
   ClearSignaled(request->identifier(), kOnHeadersReceived);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnBeforeRedirectEvent, request,
                            &extra_info_spec);
   if (listeners.empty())
     return;
 
   int http_status_code = request->GetResponseCode();
 
   std::string response_ip = request->GetSocketAddress().host();
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   dict->SetString(keys::kRedirectUrlKey, new_location.spec());
   dict->SetInteger(keys::kStatusCodeKey, http_status_code);
   if (!response_ip.empty())
     dict->SetString(keys::kIpKey, response_ip);
   dict->SetBoolean(keys::kFromCache, request->was_cached());
   dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  DispatchEvent(browser_context, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile ||
+  if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnResponseStartedEvent, 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();
 
   std::string response_ip = request->GetSocketAddress().host();
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   if (!response_ip.empty())
     dict->SetString(keys::kIpKey, response_ip);
   dict->SetBoolean(keys::kFromCache, request->was_cached());
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  DispatchEvent(browser_context, request, listeners, args);
 }
 
-void ExtensionWebRequestEventRouter::OnCompleted(void* profile,
+void ExtensionWebRequestEventRouter::OnCompleted(void* browser_context,
                                                  InfoMap* extension_info_map,
                                                  net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
   // However, if the request first became sensitive after redirecting we have
   // already signaled it and thus we have to signal the end of it. This is
   // risk-free because the handler cannot modify the request now.
-  if (!profile ||
+  if (!browser_context ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::SUCCESS);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnCompleted));
 
   ClearPendingCallbacks(request);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnCompletedEvent, 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();
 
   std::string response_ip = request->GetSocketAddress().host();
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   if (!response_ip.empty())
     dict->SetString(keys::kIpKey, response_ip);
   dict->SetBoolean(keys::kFromCache, request->was_cached());
   dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  DispatchEvent(browser_context, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     net::URLRequest* request,
     bool started) {
   // We hide events from the system context as well as sensitive requests.
   // However, if the request first became sensitive after redirecting we have
   // already signaled it and thus we have to signal the end of it. This is
   // risk-free because the handler cannot modify the request now.
-  if (!profile ||
+  if (!browser_context ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::FAILED ||
          request->status().status() == net::URLRequestStatus::CANCELED);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnErrorOccurred));
 
   ClearPendingCallbacks(request);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile, extension_info_map,
+      GetMatchingListeners(browser_context, extension_info_map,
                            web_request::OnErrorOccurred::kEventName, request,
                            &extra_info_spec);
   if (listeners.empty())
     return;
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   ExtractRequestInfo(request, dict);
   if (started) {
     std::string response_ip = request->GetSocketAddress().host();
     if (!response_ip.empty())
       dict->SetString(keys::kIpKey, response_ip);
   }
   dict->SetBoolean(keys::kFromCache, request->was_cached());
   dict->SetString(keys::kErrorKey,
                   net::ErrorToString(request->status().error()));
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  DispatchEvent(browser_context, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnURLRequestDestroyed(
-    void* profile, net::URLRequest* request) {
+    void* browser_context, net::URLRequest* request) {
   ClearPendingCallbacks(request);
 
   signaled_requests_.erase(request->identifier());
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 }
 
 void ExtensionWebRequestEventRouter::ClearPendingCallbacks(
     net::URLRequest* request) {
   blocked_requests_.erase(request->identifier());
 }
 
 bool ExtensionWebRequestEventRouter::DispatchEvent(
-    void* profile_id,
+    void* browser_context,
     net::URLRequest* request,
     const std::vector<const EventListener*>& listeners,
     const base::ListValue& 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<base::ListValue> args_filtered(args.DeepCopy());
     base::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);
 
     extensions::EventRouter::DispatchEvent(
-        (*it)->ipc_sender.get(), profile_id,
+        (*it)->ipc_sender.get(), browser_context,
         (*it)->extension_id, (*it)->sub_event_name,
         args_filtered.Pass(),
         extensions::EventRouter::USER_GESTURE_UNKNOWN,
         extensions::EventFilteringInfo());
     if ((*it)->extra_info_spec &
         (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) {
       (*it)->blocked_requests.insert(request->identifier());
       // If this is the first delegate blocking the request, go ahead and log
       // it.
       if (num_handlers_blocking == 0) {
         std::string delegate_info =
             l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
                                       base::UTF8ToUTF16((*it)->extension_name));
         // LobAndReport allows extensions that block requests to be displayed in
         // the load status bar.
         request->LogAndReportBlockedBy(delegate_info.c_str());
       }
       ++num_handlers_blocking;
     }
   }
 
   if (num_handlers_blocking > 0) {
     blocked_requests_[request->identifier()].request = request;
     blocked_requests_[request->identifier()].is_incognito |=
-        IsIncognitoProfile(profile_id);
+        IsIncognitoBrowserContext(browser_context);
     blocked_requests_[request->identifier()].num_handlers_blocking +=
         num_handlers_blocking;
     blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
 
     return true;
   }
 
   return false;
 }
 
 void ExtensionWebRequestEventRouter::OnEventHandled(
-    void* profile,
+    void* browser_context,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     EventResponse* response) {
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
 
   // The listener may have been removed (e.g. due to the process going away)
   // before we got here.
   std::set<EventListener>::iterator found =
-      listeners_[profile][event_name].find(listener);
-  if (found != listeners_[profile][event_name].end())
+      listeners_[browser_context][event_name].find(listener);
+  if (found != listeners_[browser_context][event_name].end())
     found->blocked_requests.erase(request_id);
 
-  DecrementBlockCount(profile, extension_id, event_name, request_id, response);
+  DecrementBlockCount(
+      browser_context, extension_id, event_name, request_id, response);
 }
 
 bool ExtensionWebRequestEventRouter::AddEventListener(
-    void* profile,
+    void* browser_context,
     const std::string& extension_id,
     const std::string& extension_name,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
     int extra_info_spec,
     int embedder_process_id,
     int webview_instance_id,
     base::WeakPtr<IPC::Sender> ipc_sender) {
   if (!IsWebRequestEvent(event_name))
     return false;
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.extension_name = extension_name;
   listener.sub_event_name = sub_event_name;
   listener.filter = filter;
   listener.extra_info_spec = extra_info_spec;
   listener.ipc_sender = ipc_sender;
   listener.embedder_process_id = embedder_process_id;
   listener.webview_instance_id = webview_instance_id;
   if (listener.webview_instance_id) {
     content::RecordAction(
         base::UserMetricsAction("WebView.WebRequest.AddListener"));
   }
 
-  if (listeners_[profile][event_name].count(listener) != 0u) {
+  if (listeners_[browser_context][event_name].count(listener) != 0u) {
     // This is likely an abuse of the API by a malicious extension.
     return false;
   }
-  listeners_[profile][event_name].insert(listener);
+  listeners_[browser_context][event_name].insert(listener);
   return true;
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
-    void* profile,
+    void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   std::string event_name =
       extensions::EventRouter::GetBaseEventName(sub_event_name);
   DCHECK(IsWebRequestEvent(event_name));
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
 
   // It's possible for AddEventListener to fail asynchronously. In that case,
   // the renderer believes the listener exists, while the browser does not.
   // Ignore a RemoveEventListener in that case.
   std::set<EventListener>::iterator found =
-      listeners_[profile][event_name].find(listener);
-  if (found == listeners_[profile][event_name].end())
+      listeners_[browser_context][event_name].find(listener);
+  if (found == listeners_[browser_context][event_name].end())
     return;
 
-  CHECK_EQ(listeners_[profile][event_name].count(listener), 1u) <<
+  CHECK_EQ(listeners_[browser_context][event_name].count(listener), 1u) <<
       "extension=" << extension_id << " event=" << event_name;
 
   // 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(profile, extension_id, event_name, *it, NULL);
+    DecrementBlockCount(browser_context, extension_id, event_name, *it, NULL);
   }
 
-  listeners_[profile][event_name].erase(listener);
+  listeners_[browser_context][event_name].erase(listener);
 
   helpers::ClearCacheOnNavigation();
 }
 
 void ExtensionWebRequestEventRouter::RemoveWebViewEventListeners(
-    void* profile,
+    void* browser_context,
     const std::string& extension_id,
     int embedder_process_id,
     int webview_instance_id) {
   // Iterate over all listeners of all WebRequest events to delete
   // any listeners that belong to the provided <webview>.
-  ListenerMapForProfile& map_for_profile = listeners_[profile];
-  for (ListenerMapForProfile::iterator event_iter = map_for_profile.begin();
-       event_iter != map_for_profile.end(); ++event_iter) {
+  ListenerMapForBrowserContext& map_for_browser_context =
+      listeners_[browser_context];
+  for (ListenerMapForBrowserContext::iterator event_iter =
+       map_for_browser_context.begin();
+       event_iter != map_for_browser_context.end(); ++event_iter) {
     std::vector<EventListener> listeners_to_delete;
     std::set<EventListener>& listeners = event_iter->second;
     for (std::set<EventListener>::iterator listener_iter = listeners.begin();
          listener_iter != listeners.end(); ++listener_iter) {
       const EventListener& listener = *listener_iter;
       if (listener.embedder_process_id == embedder_process_id &&
           listener.webview_instance_id == webview_instance_id)
         listeners_to_delete.push_back(listener);
     }
     for (size_t i = 0; i < listeners_to_delete.size(); ++i) {
       EventListener& listener = listeners_to_delete[i];
       content::BrowserThread::PostTask(
           content::BrowserThread::UI,
           FROM_HERE,
           base::Bind(&RemoveEventListenerOnUI,
-                     profile,
+                     browser_context,
                      listener.sub_event_name,
                      embedder_process_id,
                      extension_id));
     }
   }
 }
 
-void ExtensionWebRequestEventRouter::OnOTRProfileCreated(
-    void* original_profile, void* otr_profile) {
-  cross_profile_map_[original_profile] = std::make_pair(false, otr_profile);
-  cross_profile_map_[otr_profile] = std::make_pair(true, original_profile);
+void ExtensionWebRequestEventRouter::OnOTRBrowserContextCreated(
+    void* original_browser_context, void* otr_browser_context) {
+  cross_browser_context_map_[original_browser_context] =
+      std::make_pair(false, otr_browser_context);
+  cross_browser_context_map_[otr_browser_context] =
+      std::make_pair(true, original_browser_context);
 }
 
-void ExtensionWebRequestEventRouter::OnOTRProfileDestroyed(
-    void* original_profile, void* otr_profile) {
-  cross_profile_map_.erase(otr_profile);
-  cross_profile_map_.erase(original_profile);
+void ExtensionWebRequestEventRouter::OnOTRBrowserContextDestroyed(
+    void* original_browser_context, void* otr_browser_context) {
+  cross_browser_context_map_.erase(otr_browser_context);
+  cross_browser_context_map_.erase(original_browser_context);
 }
 
 void ExtensionWebRequestEventRouter::AddCallbackForPageLoad(
     const base::Closure& callback) {
   callbacks_for_page_load_.push_back(callback);
 }
 
 bool ExtensionWebRequestEventRouter::IsPageLoad(
     net::URLRequest* request) const {
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
   int parent_frame_id = -1;
-  int tab_id = -1;
-  int window_id = -1;
   int render_process_host_id = -1;
   int routing_id = -1;
   ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
 
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id,
-                            &tab_id, &window_id, &render_process_host_id,
+                            &render_process_host_id,
                             &routing_id, &resource_type);
 
   return resource_type == content::RESOURCE_TYPE_MAIN_FRAME;
 }
 
 void ExtensionWebRequestEventRouter::NotifyPageLoad() {
   for (CallbacksForPageLoad::const_iterator i =
            callbacks_for_page_load_.begin();
        i != callbacks_for_page_load_.end(); ++i) {
     i->Run();
   }
   callbacks_for_page_load_.clear();
 }
 
-void* ExtensionWebRequestEventRouter::GetCrossProfile(void* profile) const {
-  CrossProfileMap::const_iterator cross_profile =
-      cross_profile_map_.find(profile);
-  if (cross_profile == cross_profile_map_.end())
+void* ExtensionWebRequestEventRouter::GetCrossBrowserContext(
+    void* browser_context) const {
+  CrossBrowserContextMap::const_iterator cross_browser_context =
+      cross_browser_context_map_.find(browser_context);
+  if (cross_browser_context == cross_browser_context_map_.end())
     return NULL;
-  return cross_profile->second.second;
+  return cross_browser_context->second.second;
 }
 
-bool ExtensionWebRequestEventRouter::IsIncognitoProfile(void* profile) const {
-  CrossProfileMap::const_iterator cross_profile =
-      cross_profile_map_.find(profile);
-  if (cross_profile == cross_profile_map_.end())
+bool ExtensionWebRequestEventRouter::IsIncognitoBrowserContext(
+    void* browser_context) const {
+  CrossBrowserContextMap::const_iterator cross_browser_context =
+      cross_browser_context_map_.find(browser_context);
+  if (cross_browser_context == cross_browser_context_map_.end())
     return false;
-  return cross_profile->second.first;
+  return cross_browser_context->second.first;
 }
 
 bool ExtensionWebRequestEventRouter::WasSignaled(
     const net::URLRequest& request) const {
   SignaledRequestMap::const_iterator flag =
       signaled_requests_.find(request.identifier());
   return (flag != signaled_requests_.end()) && (flag->second != 0);
 }
 
 void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
-    void* profile,
+    void* browser_context,
+    net::URLRequest* request,
     InfoMap* extension_info_map,
     bool crosses_incognito,
     const std::string& event_name,
     const GURL& url,
-    int tab_id,
-    int window_id,
     int render_process_host_id,
     int routing_id,
     ResourceType resource_type,
     bool is_async_request,
     bool is_request_from_extension,
     int* extra_info_spec,
     std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
         matching_listeners) {
   std::string web_request_event_name(event_name);
   extensions::WebViewRendererState::WebViewInfo web_view_info;
   bool is_web_view_guest = extensions::WebViewRendererState::GetInstance()->
       GetInfo(render_process_host_id, routing_id, &web_view_info);
   if (is_web_view_guest) {
     web_request_event_name.replace(
         0, sizeof(kWebRequestEventPrefix) - 1, webview::kWebViewEventPrefix);
   }
 
   std::set<EventListener>& listeners =
-      listeners_[profile][web_request_event_name];
+      listeners_[browser_context][web_request_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 (is_web_view_guest &&
         (it->embedder_process_id != web_view_info.embedder_process_id ||
          it->webview_instance_id != web_view_info.instance_id))
       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)
+    if (web_request_event_router_delegate_ &&
+        web_request_event_router_delegate_->OnGetMatchingListenersImplCheck(
+            it->filter.tab_id, it->filter.window_id, request))
       continue;
     if (!it->filter.types.empty() &&
         std::find(it->filter.types.begin(), it->filter.types.end(),
                   resource_type) == it->filter.types.end())
       continue;
 
     if (!is_web_view_guest && !WebRequestPermissions::CanExtensionAccessURL(
             extension_info_map, it->extension_id, url, crosses_incognito,
             WebRequestPermissions::REQUIRE_HOST_PERMISSION))
       continue;
@@ skipping 16 matching lines @@
     if (blocking_listener && synchronous_xhr_from_extension)
       continue;
 
     matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     int* extra_info_spec) {
-  // TODO(mpcomplete): handle profile == NULL (should collect all listeners).
+  // TODO(mpcomplete): handle browser_context == NULL (should collect all
+  // listeners).
   *extra_info_spec = 0;
 
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
   int parent_frame_id = -1;
-  int tab_id = -1;
-  int window_id = -1;
   int render_process_host_id = -1;
   int routing_id = -1;
   ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
   const GURL& url = request->url();
 
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id,
-                            &tab_id, &window_id, &render_process_host_id,
+                            &render_process_host_id,
                             &routing_id, &resource_type);
 
   std::vector<const ExtensionWebRequestEventRouter::EventListener*>
       matching_listeners;
 
   bool is_request_from_extension =
       IsRequestFromExtension(request, extension_info_map);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   // We are conservative here and assume requests are asynchronous in case
   // we don't have an info object. We don't want to risk a deadlock.
   bool is_async_request = !info || info->IsAsync();
 
   GetMatchingListenersImpl(
-      profile, extension_info_map, false, event_name, url,
-      tab_id, window_id, render_process_host_id, routing_id, resource_type,
+      browser_context, request, extension_info_map, false, event_name,
+      url, render_process_host_id, routing_id, resource_type,
       is_async_request, is_request_from_extension, extra_info_spec,
       &matching_listeners);
-  void* cross_profile = GetCrossProfile(profile);
-  if (cross_profile) {
+  void* cross_browser_context = GetCrossBrowserContext(browser_context);
+  if (cross_browser_context) {
     GetMatchingListenersImpl(
-        cross_profile, extension_info_map, true, event_name, url, tab_id,
-        window_id, render_process_host_id, routing_id, resource_type,
+        cross_browser_context, request, extension_info_map, true, event_name,
+        url, render_process_host_id, routing_id, resource_type,
         is_async_request, is_request_from_extension, extra_info_spec,
         &matching_listeners);
   }
 
   return matching_listeners;
 }
 
 namespace {
 
 helpers::EventResponseDelta* CalculateDelta(
@@ skipping 28 matching lines @@
       return helpers::CalculateOnAuthRequiredDelta(
           response->extension_id, response->extension_install_time,
           response->cancel, &response->auth_credentials);
     default:
       NOTREACHED();
       break;
   }
   return NULL;
 }
 
-base::Value* SerializeResponseHeaders(const helpers::ResponseHeaders& headers) {
-  scoped_ptr<base::ListValue> serialized_headers(new base::ListValue());
-  for (helpers::ResponseHeaders::const_iterator i = headers.begin();
-       i != headers.end(); ++i) {
-    serialized_headers->Append(ToHeaderDictionary(i->first, i->second));
-  }
-  return serialized_headers.release();
-}
-
-// Convert a RequestCookieModifications/ResponseCookieModifications object to a
-// base::ListValue which summarizes the changes made.  This is templated since
-// the two types (request/response) are different but contain essentially the
-// same fields.
-template<typename CookieType>
-base::ListValue* SummarizeCookieModifications(
-    const std::vector<linked_ptr<CookieType> >& modifications) {
-  scoped_ptr<base::ListValue> cookie_modifications(new base::ListValue());
-  for (typename std::vector<linked_ptr<CookieType> >::const_iterator i =
-           modifications.begin();
-       i != modifications.end(); ++i) {
-    scoped_ptr<base::DictionaryValue> summary(new base::DictionaryValue());
-    const CookieType& mod = *i->get();
-    switch (mod.type) {
-      case helpers::ADD:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationAdd);
-        break;
-      case helpers::EDIT:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationEdit);
-        break;
-      case helpers::REMOVE:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationRemove);
-        break;
-    }
-    if (mod.filter) {
-      if (mod.filter->name)
-        summary->SetString(activitylog::kCookieFilterNameKey,
-                           *mod.modification->name);
-      if (mod.filter->domain)
-        summary->SetString(activitylog::kCookieFilterDomainKey,
-                           *mod.modification->name);
-    }
-    if (mod.modification) {
-      if (mod.modification->name)
-        summary->SetString(activitylog::kCookieModDomainKey,
-                           *mod.modification->name);
-      if (mod.modification->domain)
-        summary->SetString(activitylog::kCookieModDomainKey,
-                           *mod.modification->name);
-    }
-    cookie_modifications->Append(summary.release());
-  }
-  return cookie_modifications.release();
-}
-
-// Converts an EventResponseDelta object to a dictionary value suitable for the
-// activity log.
-scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
-    const std::string& event_name,
-    const helpers::EventResponseDelta& delta) {
-  scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue());
-  if (delta.cancel) {
-    details->SetBoolean(activitylog::kCancelKey, true);
-  }
-  if (!delta.new_url.is_empty()) {
-      details->SetString(activitylog::kNewUrlKey, delta.new_url.spec());
-  }
-
-  scoped_ptr<base::ListValue> modified_headers(new base::ListValue());
-  net::HttpRequestHeaders::Iterator iter(delta.modified_request_headers);
-  while (iter.GetNext()) {
-    modified_headers->Append(ToHeaderDictionary(iter.name(), iter.value()));
-  }
-  if (!modified_headers->empty()) {
-    details->Set(activitylog::kModifiedRequestHeadersKey,
-                 modified_headers.release());
-  }
-
-  scoped_ptr<base::ListValue> deleted_headers(new base::ListValue());
-  deleted_headers->AppendStrings(delta.deleted_request_headers);
-  if (!deleted_headers->empty()) {
-    details->Set(activitylog::kDeletedRequestHeadersKey,
-                 deleted_headers.release());
-  }
-
-  if (!delta.added_response_headers.empty()) {
-    details->Set(activitylog::kAddedRequestHeadersKey,
-                 SerializeResponseHeaders(delta.added_response_headers));
-  }
-  if (!delta.deleted_response_headers.empty()) {
-    details->Set(activitylog::kDeletedResponseHeadersKey,
-                 SerializeResponseHeaders(delta.deleted_response_headers));
-  }
-  if (delta.auth_credentials) {
-    details->SetString(activitylog::kAuthCredentialsKey,
-                       base::UTF16ToUTF8(
-                           delta.auth_credentials->username()) + ":*");
-  }
-
-  if (!delta.response_cookie_modifications.empty()) {
-    details->Set(
-        activitylog::kResponseCookieModificationsKey,
-        SummarizeCookieModifications(delta.response_cookie_modifications));
-  }
-
-  return details.Pass();
-}
-
-void LogExtensionActivity(void* profile_id,
-                          bool is_incognito,
-                          const std::string& extension_id,
-                          const GURL& url,
-                          const std::string& api_call,
-                          scoped_ptr<base::DictionaryValue> details) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI,
-                            FROM_HERE,
-                            base::Bind(&LogExtensionActivity,
-                                       profile_id,
-                                       is_incognito,
-                                       extension_id,
-                                       url,
-                                       api_call,
-                                       base::Passed(&details)));
-  } else {
-    Profile* profile = static_cast<Profile*>(profile_id);
-    if (!g_browser_process->profile_manager()->IsValidProfile(profile))
-      return;
-    scoped_refptr<extensions::Action> action =
-        new extensions::Action(extension_id,
-                               base::Time::Now(),
-                               extensions::Action::ACTION_WEB_REQUEST,
-                               api_call);
-    action->set_page_url(url);
-    action->set_page_incognito(is_incognito);
-    action->mutable_other()->Set(activity_log_constants::kActionWebRequest,
-                                 details.release());
-    extensions::ActivityLog::GetInstance(profile)->LogAction(action);
-  }
-}
-
 }  // namespace
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
-    void* profile,
+    void* browser_context,
     const std::string& extension_id,
     const std::string& event_name,
     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())
     return;
 
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   int num_handlers_blocking = --blocked_request.num_handlers_blocking;
   CHECK_GE(num_handlers_blocking, 0);
 
   if (response) {
     helpers::EventResponseDelta* delta =
         CalculateDelta(&blocked_request, response);
 
-    LogExtensionActivity(profile,
-                         blocked_request.is_incognito,
-                         extension_id,
-                         blocked_request.request->url(),
-                         event_name,
-                         SummarizeResponseDelta(event_name, *delta));
+    if (web_request_event_router_delegate_) {
+      web_request_event_router_delegate_->LogExtensionActivity(
+          browser_context,
+          blocked_request.is_incognito,
+          extension_id,
+          blocked_request.request->url(),
+          event_name,
+          *delta);
+    }
 
     blocked_request.response_deltas.push_back(
         linked_ptr<helpers::EventResponseDelta>(delta));
   }
 
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   if (!extension_id.empty()) {
     request_time_tracker_->IncrementExtensionBlockTime(
         extension_id, request_id, block_time);
   } else {
     // |extension_id| is empty for requests blocked on startup waiting for the
     // declarative rules to be read from disk.
     UMA_HISTOGRAM_TIMES("Extensions.NetworkDelayStartup", block_time);
   }
 
   if (num_handlers_blocking == 0) {
     blocked_request.request->LogUnblocked();
-    ExecuteDeltas(profile, request_id, true);
+    ExecuteDeltas(browser_context, request_id, true);
   } else {
     // Update the URLRequest to make sure it's tagged with an extension that's
     // still blocking it.  This may end up being the same extension as before.
-    std::set<EventListener>& listeners = listeners_[profile][event_name];
+    std::set<EventListener>& listeners =
+        listeners_[browser_context][event_name];
 
     for (std::set<EventListener>::iterator it = listeners.begin();
          it != listeners.end(); ++it) {
       if (it->blocked_requests.count(request_id) == 0)
         continue;
       std::string delegate_info =
           l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
                                     base::UTF8ToUTF16(it->extension_name));
       blocked_request.request->LogAndReportBlockedBy(delegate_info.c_str());
       break;
     }
   }
 }
 
 void ExtensionWebRequestEventRouter::SendMessages(
-    void* profile,
+    void* browser_context,
     const BlockedRequest& blocked_request) {
   const helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   for (helpers::EventResponseDeltas::const_iterator delta = deltas.begin();
        delta != deltas.end(); ++delta) {
     const std::set<std::string>& messages = (*delta)->messages_to_extension;
     for (std::set<std::string>::const_iterator message = messages.begin();
          message != messages.end(); ++message) {
       scoped_ptr<base::DictionaryValue> argument(new base::DictionaryValue);
       ExtractRequestInfo(blocked_request.request, argument.get());
       extensions::WebViewRendererState::WebViewInfo web_view_info;
       bool is_web_view_guest = GetWebViewInfo(blocked_request.request,
                                               &web_view_info);
       argument->SetString(keys::kMessageKey, *message);
       argument->SetString(keys::kStageKey,
                           GetRequestStageAsString(blocked_request.event));
 
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&SendOnMessageEventOnUI,
-                     profile,
+                     browser_context,
                      (*delta)->extension_id,
                      is_web_view_guest,
                      web_view_info,
                      base::Passed(&argument)));
     }
   }
 }
 
 int ExtensionWebRequestEventRouter::ExecuteDeltas(
-    void* profile,
+    void* browser_context,
     uint64 request_id,
     bool call_callback) {
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   CHECK(blocked_request.num_handlers_blocking == 0);
   helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   request_time_tracker_->IncrementTotalBlockTime(request_id, block_time);
 
   bool credentials_set = false;
@@ skipping 35 matching lines @@
     CHECK(!blocked_request.auth_callback.is_null());
     credentials_set = helpers::MergeOnAuthRequiredResponses(
        blocked_request.response_deltas,
        blocked_request.auth_credentials,
        &warnings,
        blocked_request.net_log);
   } else {
     NOTREACHED();
   }
 
-  SendMessages(profile, blocked_request);
+  SendMessages(browser_context, blocked_request);
 
   if (!warnings.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&WarningService::NotifyWarningsOnUI, profile, warnings));
+        base::Bind(&WarningService::NotifyWarningsOnUI,
+                   browser_context, warnings));
   }
 
   if (canceled) {
     request_time_tracker_->SetRequestCanceled(request_id);
   } else if (blocked_request.new_url &&
              !blocked_request.new_url->is_empty()) {
     request_time_tracker_->SetRequestRedirected(request_id);
   }
 
   // This triggers onErrorOccurred if canceled is true.
@@ skipping 18 matching lines @@
     blocked_requests_.erase(request_id);
     if (call_callback)
       callback.Run(response);
   } else {
     blocked_requests_.erase(request_id);
   }
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
-    void* profile,
+    void* browser_context,
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     extensions::RequestStage request_stage,
     const net::HttpResponseHeaders* original_response_headers) {
   extensions::WebViewRendererState::WebViewInfo web_view_info;
   bool is_web_view_guest = GetWebViewInfo(request, &web_view_info);
 
   extensions::RulesRegistry::WebViewKey webview_key(
       is_web_view_guest ? web_view_info.embedder_process_id : 0,
       is_web_view_guest ? web_view_info.instance_id : 0);
-  RulesRegistryKey rules_key(profile, webview_key);
+  RulesRegistryKey rules_key(browser_context, webview_key);
   // If this check fails, check that the active stages are up-to-date in
   // extensions/browser/api/declarative_webrequest/request_stage.h .
   DCHECK(request_stage & extensions::kActiveStages);
 
-  // Rules of the current |profile| may apply but we need to check also whether
-  // there are applicable rules from extensions whose background page
+  // Rules of the current |browser_context| may apply but we need to check also
+  // whether there are applicable rules from extensions whose background page
   // spans from regular to incognito mode.
 
   // First parameter identifies the registry, the second indicates whether the
-  // registry belongs to the cross profile.
+  // registry belongs to the cross browser_context.
   typedef std::pair<extensions::WebRequestRulesRegistry*, bool>
       RelevantRegistry;
   typedef std::vector<RelevantRegistry> RelevantRegistries;
   RelevantRegistries relevant_registries;
 
   if (rules_registries_.find(rules_key) != rules_registries_.end()) {
     relevant_registries.push_back(
         std::make_pair(rules_registries_[rules_key].get(), false));
   }
 
-  void* cross_profile = GetCrossProfile(profile);
-  RulesRegistryKey cross_profile_rules_key(cross_profile, webview_key);
-  if (cross_profile &&
-      rules_registries_.find(cross_profile_rules_key) !=
+  void* cross_browser_context = GetCrossBrowserContext(browser_context);
+  RulesRegistryKey cross_browser_context_rules_key(
+      cross_browser_context, webview_key);
+  if (cross_browser_context &&
+      rules_registries_.find(cross_browser_context_rules_key) !=
           rules_registries_.end()) {
     relevant_registries.push_back(
-        std::make_pair(rules_registries_[cross_profile_rules_key].get(), true));
+        std::make_pair(
+            rules_registries_[cross_browser_context_rules_key].get(), true));
   }
 
   // The following block is experimentally enabled and its impact on load time
   // logged with UMA Extensions.NetworkDelayRegistryLoad. crbug.com/175961
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
     extensions::WebRequestRulesRegistry* rules_registry = i->first;
     if (!rules_registry->ready().is_signaled()) {
       // The rules registry is still loading. Block this request until it
       // finishes.
       rules_registry->ready().Post(
           FROM_HERE,
           base::Bind(&ExtensionWebRequestEventRouter::OnRulesRegistryReady,
                      AsWeakPtr(),
-                     profile,
+                     browser_context,
                      event_name,
                      request->identifier(),
                      request_stage));
       blocked_requests_[request->identifier()].num_handlers_blocking++;
       blocked_requests_[request->identifier()].request = request;
       blocked_requests_[request->identifier()].is_incognito |=
-          IsIncognitoProfile(profile);
+          IsIncognitoBrowserContext(browser_context);
       blocked_requests_[request->identifier()].blocking_time =
           base::Time::Now();
       blocked_requests_[request->identifier()].original_response_headers =
           original_response_headers;
       blocked_requests_[request->identifier()].extension_info_map =
           extension_info_map;
       return true;
     }
   }
 
@@ skipping 20 matching lines @@
   }
 
   base::TimeDelta elapsed_time = start - base::Time::Now();
   UMA_HISTOGRAM_TIMES("Extensions.DeclarativeWebRequestNetworkDelay",
                       elapsed_time);
 
   return deltas_created;
 }
 
 void ExtensionWebRequestEventRouter::OnRulesRegistryReady(
-    void* profile,
+    void* browser_context,
     const std::string& event_name,
     uint64 request_id,
     extensions::RequestStage request_stage) {
   // 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())
     return;
 
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   UMA_HISTOGRAM_TIMES("Extensions.NetworkDelayRegistryLoad", block_time);
 
-  ProcessDeclarativeRules(profile,
+  ProcessDeclarativeRules(browser_context,
                           blocked_request.extension_info_map,
                           event_name,
                           blocked_request.request,
                           request_stage,
                           blocked_request.original_response_headers.get());
   // Reset to NULL so that nobody relies on this being set.
   blocked_request.extension_info_map = NULL;
-  DecrementBlockCount(profile, std::string(), event_name, request_id, NULL);
+  DecrementBlockCount(
+      browser_context, std::string(), event_name, request_id, NULL);
 }
 
 bool ExtensionWebRequestEventRouter::GetAndSetSignaled(uint64 request_id,
                                                        EventTypes event_type) {
   SignaledRequestMap::iterator iter = signaled_requests_.find(request_id);
   if (iter == signaled_requests_.end()) {
     signaled_requests_[request_id] = event_type;
     return false;
   }
   bool was_signaled_before = (iter->second & event_type) != 0;
@@ skipping 354 matching lines @@
       base::Bind(&WarningService::NotifyWarningsOnUI, profile_id(), warnings));
 
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }