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/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.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/extensions_api_client.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/extension_messages.h"
 #include "extensions/common/extension_set.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 char* GetRequestStageAsString(
     ExtensionWebRequestEventRouter::EventTypes type) {
   switch (type) {
     case ExtensionWebRequestEventRouter::kInvalidEvent:
       return "Invalid";
     case ExtensionWebRequestEventRouter::kOnBeforeRequest:
       return keys::kOnBeforeRequest;
     case ExtensionWebRequestEventRouter::kOnBeforeSendHeaders:
       return keys::kOnBeforeSendHeaders;
     case ExtensionWebRequestEventRouter::kOnSendHeaders:
@@ skipping 65 matching lines @@
 bool GetWebViewInfo(
     net::URLRequest* request,
     extensions::WebViewRendererState::WebViewInfo* web_view_info) {
   int render_process_host_id = -1;
   int routing_id = -1;
   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::ToHeaderDictionary(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::ToHeaderDictionary(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,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context?

[Xi Han, 2014/09/18 16:24:00]

Done.

   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*>(profile_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,

[Fady Samuel, 2014/09/12 21:55:40]

nit: Rename to browser_context?

[Xi Han, 2014/09/18 16:24:02]

Done.

     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*>(profile_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 246 matching lines @@
 // 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,

[Fady Samuel, 2014/09/12 21:55:40]

nit rename profile to browser_context.

[Xi Han, 2014/09/18 16:24:01]

Done.

     const RulesRegistryService::WebViewKey& webview_key,
     scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
   RulesRegistryKey key(profile, webview_key);
   if (rules_registry.get())
     rules_registries_[key] = rules_registry;
   else
     rules_registries_.erase(key);
 }
 
+void ExtensionWebRequestEventRouter::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,

[Fady Samuel, 2014/09/12 21:55:40]

Can we get rid of tab_id and window_id in extensions?

+    int* render_process_host_id,
+    int* routing_id,
+    ResourceType* resource_type) const {
+  if (!request->GetUserData(NULL))
+    return;
+
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+  if(web_request_event_router_delegate_) {
+    web_request_event_router_delegate_->ExtractRequestInfoDetails(
+        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;
+}
+
+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 tab_id = -1;
+  int window_id = -1;

[Fady Samuel, 2014/09/12 21:55:40]

The concepts of tab_id and window_id should not exist in the extensions module.
Can we remove these here?

+  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);
+}
+
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:40]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:24:00]

Done.

     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 ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   if (IsPageLoad(request))
@@ skipping 45 matching lines @@
     // 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(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:24:00]

Done.

     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 ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
@@ skipping 36 matching lines @@
     // 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(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 void ExtensionWebRequestEventRouter::OnSendHeaders(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:40]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:24:01]

Done.

     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 ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnSendHeaders))
     return;
@@ skipping 12 matching lines @@
   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);
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:23:59]

Done.

     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 ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
@@ skipping 50 matching lines @@
     // to modify the request and we can respond synchronously.
     return ExecuteDeltas(profile, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ExtensionWebRequestEventRouter::OnAuthRequired(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to 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
   // system context. Skip in that case. Also skip sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
@@ skipping 32 matching lines @@
     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,

[Fady Samuel, 2014/09/12 21:55:38]

nit: Rename to browser_context

[Xi Han, 2014/09/18 16:23:59]

Done.

     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 ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
@@ skipping 27 matching lines @@
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:23:59]

Done.

     InfoMap* extension_info_map,
     net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
@@ skipping 23 matching lines @@
   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);
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(void* profile,

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:23:58]

Done.

                                                  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 ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
     return;
@@ skipping 32 matching lines @@
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context.

[Xi Han, 2014/09/18 16:24:00]

Done.

     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 ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
@@ skipping 27 matching lines @@
   }
   dict->SetBoolean(keys::kFromCache, request->was_cached());
   dict->SetString(keys::kErrorKey,
                   net::ErrorToString(request->status().error()));
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnURLRequestDestroyed(
     void* profile, net::URLRequest* request) {

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename to browser_context.

[Xi Han, 2014/09/18 16:24:01]

Done.

   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,

[Fady Samuel, 2014/09/12 21:55:40]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:24:00]

Done.

     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());
@@ skipping 35 matching lines @@
         num_handlers_blocking;
     blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
 
     return true;
   }
 
   return false;
 }
 
 void ExtensionWebRequestEventRouter::OnEventHandled(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context

[Xi Han, 2014/09/18 16:23:59]

Done.

     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())
     found->blocked_requests.erase(request_id);
 
   DecrementBlockCount(profile, extension_id, event_name, request_id, response);
 }
 
 bool ExtensionWebRequestEventRouter::AddEventListener(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename to browser_context.

[Xi Han, 2014/09/18 16:24:01]

Done.

     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))
@@ skipping 15 matching lines @@
 
   if (listeners_[profile][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);
   return true;
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:39]

nit: Rename to browser_context.

[Xi Han, 2014/09/18 16:23:59]

Done.

     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;
 
@@ skipping 13 matching lines @@
        it != found->blocked_requests.end(); ++it) {
     DecrementBlockCount(profile, extension_id, event_name, *it, NULL);
   }
 
   listeners_[profile][event_name].erase(listener);
 
   helpers::ClearCacheOnNavigation();
 }
 
 void ExtensionWebRequestEventRouter::RemoveWebViewEventListeners(
     void* profile,

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename to browser_context.

[Xi Han, 2014/09/18 16:24:01]

Done.

     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) {
     std::vector<EventListener> listeners_to_delete;
     std::set<EventListener>& listeners = event_iter->second;
@@ skipping 11 matching lines @@
           FROM_HERE,
           base::Bind(&RemoveEventListenerOnUI,
                      profile,
                      listener.sub_event_name,
                      embedder_process_id,
                      extension_id));
     }
   }
 }
 
 void ExtensionWebRequestEventRouter::OnOTRProfileCreated(

[Fady Samuel, 2014/09/12 21:55:39]

nit: replace instances of "Profile" with "BrowserContext".

[Xi Han, 2014/09/18 16:24:01]

Done.

     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::OnOTRProfileDestroyed(

[Fady Samuel, 2014/09/12 21:55:38]

nit: Replace instances of "Profile" with "BrowserContext".

[Xi Han, 2014/09/18 16:23:59]

Done.

     void* original_profile, void* otr_profile) {
   cross_profile_map_.erase(otr_profile);
   cross_profile_map_.erase(original_profile);
 }
 
 void ExtensionWebRequestEventRouter::AddCallbackForPageLoad(
     const base::Closure& callback) {
   callbacks_for_page_load_.push_back(callback);
 }
 
@@ skipping 19 matching lines @@
 
 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 {

[Fady Samuel, 2014/09/12 21:55:38]

nit: rename "Profile" to "BrowserContext".

[Xi Han, 2014/09/18 16:24:01]

Done.

   CrossProfileMap::const_iterator cross_profile =
       cross_profile_map_.find(profile);
   if (cross_profile == cross_profile_map_.end())
     return NULL;
   return cross_profile->second.second;
 }
 
 bool ExtensionWebRequestEventRouter::IsIncognitoProfile(void* profile) const {

[Fady Samuel, 2014/09/12 21:55:39]

nit: profile to browser_context

[Xi Han, 2014/09/18 16:23:59]

Done.

   CrossProfileMap::const_iterator cross_profile =
       cross_profile_map_.find(profile);
   if (cross_profile == cross_profile_map_.end())
     return false;
   return cross_profile->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,

[Fady Samuel, 2014/09/12 21:55:40]

nit: rename profile to browser_context.

[Xi Han, 2014/09/18 16:24:01]

Done.

     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,
@@ skipping 59 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,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename profile to browser_context.

[Xi Han, 2014/09/18 16:24:00]

Done.

     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).
   *extra_info_spec = 0;
 
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
@@ skipping 72 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,

[Fady Samuel, 2014/09/12 21:55:39]

nit: rename to browser_context.

[Xi Han, 2014/09/18 16:24:00]

Done.

     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(
+          profile,
+          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);
@@ skipping 651 matching lines @@
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
 void SendExtensionWebRequestStatusToHost(content::RenderProcessHost* host) {
-  Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
-  if (!profile)
+  content::BrowserContext* browser_context = host->GetBrowserContext();
+  if (!browser_context)
     return;
 
   bool webrequest_used = false;
   const extensions::ExtensionSet& extensions =
-      extensions::ExtensionRegistry::Get(profile)->enabled_extensions();
+      extensions::ExtensionRegistry::Get(browser_context)->enabled_extensions();
   extensions::RuntimeData* runtime_data =
-      extensions::ExtensionSystem::Get(profile)->runtime_data();
+      extensions::ExtensionSystem::Get(browser_context)->runtime_data();
   for (extensions::ExtensionSet::const_iterator it = extensions.begin();
        !webrequest_used && it != extensions.end();
        ++it) {
     webrequest_used |= runtime_data->HasUsedWebRequest(it->get());
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(webrequest_used));
 }