Final batch adding real histogram values for extension events.

extensions/browser/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 "extensions/browser/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 51 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using content::ResourceType;
-using extensions::ErrorUtils;
-using extensions::Extension;
-using extensions::InfoMap;
-using extensions::Feature;
-using extensions::RulesRegistryService;
-using extensions::Warning;
-using extensions::WarningService;
-using extensions::WarningSet;
 
-namespace activitylog = activity_log_web_request_constants;
+namespace activity_log = activity_log_web_request_constants;
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
-namespace web_request = extensions::core_api::web_request;
-namespace declarative_keys = extensions::declarative_webrequest_constants;
+
+namespace extensions {
+
+namespace declarative_keys = declarative_webrequest_constants;
+namespace web_request = core_api::web_request;
 
 namespace {
 
 const char kWebRequestEventPrefix[] = "webRequest.";
 
 // List of all the webRequest events.
 const char* const kWebRequestEvents[] = {
   keys::kOnBeforeRedirectEvent,
   web_request::OnBeforeRequest::kEventName,
   keys::kOnBeforeSendHeadersEvent,
@@ skipping 78 matching lines @@
     return;
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   *render_process_host_id = info->GetChildID();
   *routing_id = info->GetRouteID();
 }
 
 // Given a |request|, this function determines whether it originated from
 // a <webview> guest process or not. If it is from a <webview> guest process,
 // then |web_view_info| is returned with information about the instance ID
 // that uniquely identifies the <webview> and its embedder.
-bool GetWebViewInfo(
-    net::URLRequest* request,
-    extensions::WebViewRendererState::WebViewInfo* web_view_info) {
+bool GetWebViewInfo(net::URLRequest* request,
+                    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);
+  return 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* render_process_host_id,
                                int* routing_id,
                                ResourceType* resource_type) {
@@ skipping 20 matching lines @@
                             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* request_body = new base::DictionaryValue();
   out->Set(keys::kRequestBodyKey, request_body);
 
   // Get the data presenters, ordered by how specific they are.
-  extensions::ParsedDataPresenter parsed_data_presenter(*request);
-  extensions::RawDataPresenter raw_data_presenter;
-  extensions::UploadDataPresenter* const presenters[] = {
-    &parsed_data_presenter,    // 1: any parseable forms? (Specific to forms.)
-    &raw_data_presenter        // 2: any data at all? (Non-specific.)
+  ParsedDataPresenter parsed_data_presenter(*request);
+  RawDataPresenter raw_data_presenter;
+  UploadDataPresenter* const presenters[] = {
+      &parsed_data_presenter,  // 1: any parseable forms? (Specific to forms.)
+      &raw_data_presenter      // 2: any data at all? (Non-specific.)
   };
   // Keys for the results of the corresponding presenters.
   static const char* const kKeys[] = {
     keys::kRequestBodyFormDataKey,
     keys::kRequestBodyRawKey
   };
 
   const ScopedVector<net::UploadElementReader>* readers =
       upload_data->GetElementReaders();
   bool some_succeeded = false;
@@ skipping 76 matching lines @@
 // 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* browser_context_id,
     const std::string& extension_id,
     bool is_web_view_guest,
-    const extensions::WebViewRendererState::WebViewInfo& web_view_info,
+    const WebViewRendererState::WebViewInfo& web_view_info,
     scoped_ptr<base::DictionaryValue> event_argument) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::BrowserContext* browser_context =
       reinterpret_cast<content::BrowserContext*>(browser_context_id);
-  if (!extensions::ExtensionsBrowserClient::Get()->IsValidContext(
-      browser_context))
+  if (!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(browser_context);
+  EventRouter* event_router = EventRouter::Get(browser_context);
 
-  extensions::EventFilteringInfo event_filtering_info;
+  EventFilteringInfo event_filtering_info;
 
+  events::HistogramValue histogram_value = events::UNKNOWN;
   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);
+    histogram_value = events::WEB_VIEW_INTERNAL_ON_MESSAGE;
     event_name = webview::kEventMessage;
   } else {
+    histogram_value = events::DECLARATIVE_WEB_REQUEST_ON_MESSAGE;
     event_name = declarative_keys::kOnMessage;
   }
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      extensions::events::UNKNOWN, event_name, event_args.Pass(),
-      browser_context, GURL(), extensions::EventRouter::USER_GESTURE_UNKNOWN,
-      event_filtering_info));
+  scoped_ptr<Event> event(new Event(
+      histogram_value, event_name, event_args.Pass(), browser_context, GURL(),
+      EventRouter::USER_GESTURE_UNKNOWN, event_filtering_info));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void RemoveEventListenerOnIOThread(
     void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name,
     int embedder_process_id,
     int web_view_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       browser_context, extension_id, sub_event_name,
       embedder_process_id, web_view_instance_id);
 }
 
 }  // namespace
 
-namespace extensions {
-
 WebRequestAPI::WebRequestAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   for (size_t i = 0; i < arraysize(kWebRequestEvents); ++i) {
     // Observe the webRequest event.
     std::string event_name = kWebRequestEvents[i];
     event_router->RegisterObserver(this, event_name);
 
     // Also observe the corresponding webview event.
     event_name.replace(
@@ skipping 26 matching lines @@
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&RemoveEventListenerOnIOThread,
                                      details.browser_context,
                                      details.extension_id,
                                      details.event_name,
                                      0 /* embedder_process_id */,
                                      0 /* web_view_instance_id */));
 }
 
-}  // namespace extensions
-
 // Represents a single unique listener to an event, along with whatever filter
 // parameters and extra_info_spec were specified at the time the listener was
 // added.
 // NOTE(benjhayden) New APIs should not use this sub_event_name trick! It does
 // not play well with event pages. See downloads.onDeterminingFilename and
 // ExtensionDownloadsEventRouter for an alternative approach.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
   std::string extension_name;
   std::string sub_event_name;
@@ skipping 198 matching lines @@
 //
 
 // 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());
+      ExtensionsAPIClient::Get()->CreateWebRequestEventRouterDelegate());
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
     void* browser_context,
     int rules_registry_id,
-    scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
+    scoped_refptr<WebRequestRulesRegistry> rules_registry) {
   RulesRegistryKey key(browser_context, rules_registry_id);
   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;
@@ skipping 45 matching lines @@
                                              base::Time::Now(),
                                              request->url(),
                                              browser_context);
 
   // Whether to initialized blocked_requests_.
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
       ProcessDeclarativeRules(browser_context, extension_info_map,
                               web_request::OnBeforeRequest::kEventName, request,
-                              extensions::ON_BEFORE_REQUEST, NULL);
+                              ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       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();
@@ skipping 33 matching lines @@
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
-  initialize_blocked_requests |=
-      ProcessDeclarativeRules(browser_context, extension_info_map,
-                              keys::kOnBeforeSendHeadersEvent, request,
-                              extensions::ON_BEFORE_SEND_HEADERS, NULL);
+  initialize_blocked_requests |= ProcessDeclarativeRules(
+      browser_context, extension_info_map, keys::kOnBeforeSendHeadersEvent,
+      request, ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       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();
@@ skipping 68 matching lines @@
     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 (!browser_context ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
-  initialize_blocked_requests |=
-      ProcessDeclarativeRules(browser_context, extension_info_map,
-                              keys::kOnHeadersReceivedEvent, request,
-                              extensions::ON_HEADERS_RECEIVED,
-                              original_response_headers);
+  initialize_blocked_requests |= ProcessDeclarativeRules(
+      browser_context, extension_info_map, keys::kOnHeadersReceivedEvent,
+      request, ON_HEADERS_RECEIVED, original_response_headers);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnHeadersReceivedEvent, request,
                            &extra_info_spec);
 
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnHeadersReceived)) {
     base::ListValue args;
@@ skipping 315 matching lines @@
        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(), browser_context,
-        (*it)->extension_id, (*it)->sub_event_name,
-        args_filtered.Pass(),
-        extensions::EventRouter::USER_GESTURE_UNKNOWN,
-        extensions::EventFilteringInfo());
+    EventRouter::DispatchEvent(
+        (*it)->ipc_sender.get(), browser_context, (*it)->extension_id,
+        (*it)->sub_event_name, args_filtered.Pass(),
+        EventRouter::USER_GESTURE_UNKNOWN, 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
@@ skipping 75 matching lines @@
   listeners_[browser_context][event_name].insert(listener);
   return true;
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
     void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name,
     int embedder_process_id,
     int web_view_instance_id) {
-  std::string event_name =
-      extensions::EventRouter::GetBaseEventName(sub_event_name);
+  std::string event_name = EventRouter::GetBaseEventName(sub_event_name);
   DCHECK(IsWebRequestEvent(event_name));
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
   listener.embedder_process_id = embedder_process_id;
   listener.web_view_instance_id = web_view_instance_id;
 
   std::set<EventListener>& event_listeners =
       listeners_[browser_context][event_name];
@@ skipping 131 matching lines @@
     const GURL& url,
     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);
+  WebViewRendererState::WebViewInfo web_view_info;
+  bool is_web_view_guest = 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_[browser_context][web_request_event_name];
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     if (!it->ipc_sender.get()) {
@@ skipping 158 matching lines @@
 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);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationAdd);
         break;
       case helpers::EDIT:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationEdit);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationEdit);
         break;
       case helpers::REMOVE:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationRemove);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationRemove);
         break;
     }
     if (mod.filter) {
       if (mod.filter->name)
-        summary->SetString(activitylog::kCookieFilterNameKey,
+        summary->SetString(activity_log::kCookieFilterNameKey,
                            *mod.modification->name);
       if (mod.filter->domain)
-        summary->SetString(activitylog::kCookieFilterDomainKey,
+        summary->SetString(activity_log::kCookieFilterDomainKey,
                            *mod.modification->name);
     }
     if (mod.modification) {
       if (mod.modification->name)
-        summary->SetString(activitylog::kCookieModDomainKey,
+        summary->SetString(activity_log::kCookieModDomainKey,
                            *mod.modification->name);
       if (mod.modification->domain)
-        summary->SetString(activitylog::kCookieModDomainKey,
+        summary->SetString(activity_log::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);
+    details->SetBoolean(activity_log::kCancelKey, true);
   }
   if (!delta.new_url.is_empty()) {
-      details->SetString(activitylog::kNewUrlKey, delta.new_url.spec());
+    details->SetString(activity_log::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(
         helpers::CreateHeaderDictionary(iter.name(), iter.value()));
   }
   if (!modified_headers->empty()) {
-    details->Set(activitylog::kModifiedRequestHeadersKey,
+    details->Set(activity_log::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,
+    details->Set(activity_log::kDeletedRequestHeadersKey,
                  deleted_headers.release());
   }
 
   if (!delta.added_response_headers.empty()) {
-    details->Set(activitylog::kAddedRequestHeadersKey,
+    details->Set(activity_log::kAddedRequestHeadersKey,
                  SerializeResponseHeaders(delta.added_response_headers));
   }
   if (!delta.deleted_response_headers.empty()) {
-    details->Set(activitylog::kDeletedResponseHeadersKey,
+    details->Set(activity_log::kDeletedResponseHeadersKey,
                  SerializeResponseHeaders(delta.deleted_response_headers));
   }
   if (delta.auth_credentials) {
-    details->SetString(activitylog::kAuthCredentialsKey,
-                       base::UTF16ToUTF8(
-                           delta.auth_credentials->username()) + ":*");
+    details->SetString(
+        activity_log::kAuthCredentialsKey,
+        base::UTF16ToUTF8(delta.auth_credentials->username()) + ":*");
   }
 
   if (!delta.response_cookie_modifications.empty()) {
     details->Set(
-        activitylog::kResponseCookieModificationsKey,
+        activity_log::kResponseCookieModificationsKey,
         SummarizeCookieModifications(delta.response_cookie_modifications));
   }
 
   return details.Pass();
 }
 
 }  // namespace
 
 void ExtensionWebRequestEventRouter::LogExtensionActivity(
     void* browser_context_id,
@@ skipping 92 matching lines @@
     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;
+      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,
@@ skipping 106 matching lines @@
     blocked_requests_.erase(request_id);
   }
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     void* browser_context,
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
-    extensions::RequestStage request_stage,
+    RequestStage request_stage,
     const net::HttpResponseHeaders* original_response_headers) {
-  extensions::WebViewRendererState::WebViewInfo web_view_info;
+  WebViewRendererState::WebViewInfo web_view_info;
   bool is_web_view_guest = GetWebViewInfo(request, &web_view_info);
   int rules_registry_id = is_web_view_guest
                               ? web_view_info.rules_registry_id
                               : RulesRegistryService::kDefaultRulesRegistryID;
 
   RulesRegistryKey rules_key(browser_context, rules_registry_id);
   // 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);
+  DCHECK(request_stage & kActiveStages);
 
   // 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 browser_context.
-  typedef std::pair<extensions::WebRequestRulesRegistry*, bool>
-      RelevantRegistry;
+  typedef std::pair<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_browser_context = GetCrossBrowserContext(browser_context);
   RulesRegistryKey cross_browser_context_rules_key(cross_browser_context,
                                                    rules_registry_id);
   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_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;
+    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(),
                      browser_context,
                      event_name,
                      request->identifier(),
@@ skipping 10 matching lines @@
           extension_info_map;
       return true;
     }
   }
 
   base::Time start = base::Time::Now();
 
   bool deltas_created = false;
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
-    extensions::WebRequestRulesRegistry* rules_registry =
-        i->first;
-    helpers::EventResponseDeltas result =
-        rules_registry->CreateDeltas(
-            extension_info_map,
-            extensions::WebRequestData(
-                request, request_stage, original_response_headers),
-            i->second);
+    WebRequestRulesRegistry* rules_registry = i->first;
+    helpers::EventResponseDeltas result = rules_registry->CreateDeltas(
+        extension_info_map,
+        WebRequestData(request, request_stage, original_response_headers),
+        i->second);
 
     if (!result.empty()) {
       helpers::EventResponseDeltas& deltas =
           blocked_requests_[request->identifier()].response_deltas;
       deltas.insert(deltas.end(), result.begin(), result.end());
       deltas_created = true;
     }
   }
 
   base::TimeDelta elapsed_time = start - base::Time::Now();
   UMA_HISTOGRAM_TIMES("Extensions.DeclarativeWebRequestNetworkDelay",
                       elapsed_time);
 
   return deltas_created;
 }
 
 void ExtensionWebRequestEventRouter::OnRulesRegistryReady(
     void* browser_context,
     const std::string& event_name,
     uint64 request_id,
-    extensions::RequestStage request_stage) {
+    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);
 
@@ skipping 35 matching lines @@
 // of WebKit at the time of the next page load (top level navigation event).
 // This quota heuristic is intended to limit the number of times the cache is
 // cleared by an extension.
 //
 // As we want to account for the number of times the cache is really cleared
 // (opposed to the number of times webRequest.handlerBehaviorChanged() is
 // called), we cannot decide whether a call of
 // webRequest.handlerBehaviorChanged() should trigger a quota violation at the
 // time it is called. Instead we only decrement the bucket counter at the time
 // when the cache is cleared (when page loads happen).
-class ClearCacheQuotaHeuristic : public extensions::QuotaLimitHeuristic {
+class ClearCacheQuotaHeuristic : public QuotaLimitHeuristic {
  public:
   ClearCacheQuotaHeuristic(const Config& config, BucketMapper* map)
       : QuotaLimitHeuristic(
             config,
             map,
             "MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES"),
         callback_registered_(false),
         weak_ptr_factory_(this) {}
   ~ClearCacheQuotaHeuristic() override {}
   bool Apply(Bucket* bucket, const base::TimeTicks& event_time) override;
@@ skipping 65 matching lines @@
 
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(3, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &sub_event_name));
 
   int web_view_instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(5, &web_view_instance_id));
 
-  base::WeakPtr<extensions::IOThreadExtensionMessageFilter> ipc_sender =
-      ipc_sender_weak();
+  base::WeakPtr<IOThreadExtensionMessageFilter> ipc_sender = ipc_sender_weak();
   int embedder_process_id =
       ipc_sender.get() && web_view_instance_id > 0 ?
           ipc_sender->render_process_id() : 0;
 
   const Extension* extension =
       extension_info_map()->extensions().GetByID(extension_id_safe());
   std::string extension_name =
       extension ? extension->name() : extension_id_safe();
 
   if (!web_view_instance_id) {
     // We check automatically whether the extension has the 'webRequest'
     // permission. For blocking calls we require the additional permission
     // 'webRequestBlocking'.
     if ((extra_info_spec &
          (ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING |
           ExtensionWebRequestEventRouter::ExtraInfoSpec::ASYNC_BLOCKING)) &&
         !extension->permissions_data()->HasAPIPermission(
-            extensions::APIPermission::kWebRequestBlocking)) {
+            APIPermission::kWebRequestBlocking)) {
       error_ = keys::kBlockingPermissionRequired;
       return false;
     }
 
     // We allow to subscribe to patterns that are broader than the host
     // permissions. E.g., we could subscribe to http://www.example.com/*
     // while having host permissions for http://www.example.com/foo/* and
     // http://www.example.com/bar/*.
     // For this reason we do only a coarse check here to warn the extension
     // developer if he does something obviously wrong.
@@ skipping 184 matching lines @@
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id(), extension_id_safe(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }
 
 void WebRequestHandlerBehaviorChangedFunction::GetQuotaLimitHeuristics(
-    extensions::QuotaLimitHeuristics* heuristics) const {
-  extensions::QuotaLimitHeuristic::Config config = {
+    QuotaLimitHeuristics* heuristics) const {
+  QuotaLimitHeuristic::Config config = {
       // See web_request.json for current value.
       web_request::MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES,
       base::TimeDelta::FromMinutes(10)};
-  extensions::QuotaLimitHeuristic::BucketMapper* bucket_mapper =
-      new extensions::QuotaLimitHeuristic::SingletonBucketMapper();
+  QuotaLimitHeuristic::BucketMapper* bucket_mapper =
+      new QuotaLimitHeuristic::SingletonBucketMapper();
   ClearCacheQuotaHeuristic* heuristic =
       new ClearCacheQuotaHeuristic(config, bucket_mapper);
   heuristics->push_back(heuristic);
 }
 
 void WebRequestHandlerBehaviorChangedFunction::OnQuotaExceeded(
     const std::string& violation_error) {
   // Post warning message.
   WarningSet warnings;
   warnings.insert(
       Warning::CreateRepeatedCacheFlushesWarning(extension_id_safe()));
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WarningService::NotifyWarningsOnUI, profile_id(), warnings));
 
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
+
+}  // namespace extensions