Add extension event histogram values for messaging, webRequest, and webview.

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"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
+#include "base/macros.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 "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/activity_log/web_request_constants.h"
 #include "extensions/browser/api/declarative/rules_registry_service.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/upload_data_presenter.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_event_router_delegate.h"
 #include "extensions/browser/api/web_request/web_request_time_tracker.h"
 #include "extensions/browser/event_router.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/guest_view_events.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/io_thread_extension_message_filter.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/browser/warning_service.h"
 #include "extensions/browser/warning_set.h"
 #include "extensions/common/api/web_request.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/event_filtering_info.h"
@@ skipping 38 matching lines @@
   web_request::OnBeforeRequest::kEventName,
   keys::kOnBeforeSendHeadersEvent,
   keys::kOnCompletedEvent,
   web_request::OnErrorOccurred::kEventName,
   keys::kOnSendHeadersEvent,
   keys::kOnAuthRequiredEvent,
   keys::kOnResponseStartedEvent,
   keys::kOnHeadersReceivedEvent,
 };
 
-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;
     case ExtensionWebRequestEventRouter::kOnSendHeaders:
@@ skipping 20 matching lines @@
 }
 
 bool IsWebRequestEvent(const std::string& event_name) {
   std::string web_request_event_name(event_name);
   if (base::StartsWith(web_request_event_name,
                        webview::kWebViewEventPrefix,
                        base::CompareCase::SENSITIVE)) {
     web_request_event_name.replace(
         0, strlen(webview::kWebViewEventPrefix), kWebRequestEventPrefix);
   }
-  return std::find(
-      kWebRequestEvents,
-      kWebRequestEvents + kWebRequestEventsLength,
-      web_request_event_name) != (kWebRequestEvents + kWebRequestEventsLength);
+  auto web_request_events_end =
+      kWebRequestEvents + arraysize(kWebRequestEvents);
+  return std::find(kWebRequestEvents, web_request_events_end,
+                   web_request_event_name) != web_request_events_end;
 }
 
 // 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 210 matching lines @@
     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);
 }
 
+events::HistogramValue GetEventHistogramValue(const std::string& event_name) {
+  // Event names will either be webRequest events, or guest view (probably web
+  // view) events that map to webRequest events. Check webRequest first.
+  static struct ValueAndName {
+    events::HistogramValue histogram_value;
+    const char* event_name;
+  } values_and_names[] = {
+      {events::WEB_REQUEST_ON_BEFORE_REDIRECT, keys::kOnBeforeRedirectEvent},
+      {events::WEB_REQUEST_ON_BEFORE_REQUEST,
+       web_request::OnBeforeRequest::kEventName},
+      {events::WEB_REQUEST_ON_BEFORE_SEND_HEADERS,
+       keys::kOnBeforeSendHeadersEvent},
+      {events::WEB_REQUEST_ON_COMPLETED, keys::kOnCompletedEvent},
+      {events::WEB_REQUEST_ON_ERROR_OCCURRED,
+       web_request::OnErrorOccurred::kEventName},
+      {events::WEB_REQUEST_ON_SEND_HEADERS, keys::kOnSendHeadersEvent},
+      {events::WEB_REQUEST_ON_AUTH_REQUIRED, keys::kOnAuthRequiredEvent},
+      {events::WEB_REQUEST_ON_RESPONSE_STARTED, keys::kOnResponseStartedEvent},
+      {events::WEB_REQUEST_ON_HEADERS_RECEIVED, keys::kOnHeadersReceivedEvent}};
+  COMPILE_ASSERT(arraysize(kWebRequestEvents) == arraysize(values_and_names),
+                 "kWebRequestEvents and values_and_names must be the same");
+  for (const ValueAndName& value_and_name : values_and_names) {
+    if (value_and_name.event_name == event_name)
+      return value_and_name.histogram_value;
+  }
+
+  // If there is no webRequest event, it might be a guest view webRequest event.
+  events::HistogramValue guest_view_histogram_value =
+      guest_view_events::GetEventHistogramValue(event_name);
+  if (guest_view_histogram_value != events::UNKNOWN)
+    return guest_view_histogram_value;
+
+  // There is no histogram value for this event name. It should be added to
+  // either the mapping here, or in guest_view_events.
+  NOTREACHED() << "Event " << event_name << " must have a histogram value";
+  return events::UNKNOWN;
+};
+
 }  // namespace
 
 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);
 
@@ skipping 37 matching lines @@
 
 // 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;
+  events::HistogramValue histogram_value;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
   int embedder_process_id;
   int web_view_instance_id;
   base::WeakPtr<IPC::Sender> ipc_sender;
   mutable std::set<uint64> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
     if (extension_id != that.extension_id)
       return extension_id < that.extension_id;
 
     if (sub_event_name != that.sub_event_name)
       return sub_event_name < that.sub_event_name;
 
     if (embedder_process_id != that.embedder_process_id)
       return embedder_process_id < that.embedder_process_id;
 
     if (web_view_instance_id != that.web_view_instance_id)
       return web_view_instance_id < that.web_view_instance_id;
 
     return false;
   }
 
-  EventListener() :
-      extra_info_spec(0),
-      embedder_process_id(0),
-      web_view_instance_id(0) {}
+  EventListener()
+      : histogram_value(events::UNKNOWN),
+        extra_info_spec(0),
+        embedder_process_id(0),
+        web_view_instance_id(0) {}
 };
 
 // Contains info about requests that are blocked waiting for a response from
 // an extension.
 struct ExtensionWebRequestEventRouter::BlockedRequest {
   // The request that is being blocked.
   net::URLRequest* request;
 
   // Whether the request originates from an incognito tab.
   bool is_incognito;
@@ skipping 707 matching lines @@
 }
 
 bool ExtensionWebRequestEventRouter::DispatchEvent(
     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) {
+  for (const EventListener* listener : listeners) {
     // 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))
+    if (!(listener->extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS))
       dict->Remove(keys::kRequestHeadersKey, NULL);
-    if (!((*it)->extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS))
+    if (!(listener->extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS))
       dict->Remove(keys::kResponseHeadersKey, NULL);
 
-    EventRouter::DispatchEvent(
-        (*it)->ipc_sender.get(), browser_context, (*it)->extension_id,
-        (*it)->sub_event_name, args_filtered.Pass(),
+    EventRouter::DispatchEventToSender(
+        listener->ipc_sender.get(), browser_context, GURL(),
+        listener->extension_id, listener->histogram_value,
+        listener->sub_event_name, args_filtered.Pass(),
         EventRouter::USER_GESTURE_UNKNOWN, EventFilteringInfo());
-    if ((*it)->extra_info_spec &
+    if (listener->extra_info_spec &
         (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) {
-      (*it)->blocked_requests.insert(request->identifier());
+      listener->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));
+        std::string delegate_info = l10n_util::GetStringFUTF8(
+            IDS_LOAD_STATE_PARAMETER_EXTENSION,
+            base::UTF8ToUTF16(listener->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;
@@ skipping 28 matching lines @@
     found->blocked_requests.erase(request_id);
 
   DecrementBlockCount(
       browser_context, extension_id, event_name, request_id, response);
 }
 
 bool ExtensionWebRequestEventRouter::AddEventListener(
     void* browser_context,
     const std::string& extension_id,
     const std::string& extension_name,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
     int extra_info_spec,
     int embedder_process_id,
     int web_view_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.histogram_value = histogram_value;
   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.web_view_instance_id = web_view_instance_id;
   if (listener.web_view_instance_id) {
     content::RecordAction(
         base::UserMetricsAction("WebView.WebRequest.AddListener"));
   }
@@ skipping 939 matching lines @@
             ->GetEffectiveHostPermissions()
             .is_empty()) {
       error_ = keys::kHostPermissionsRequired;
       return false;
     }
   }
 
   bool success =
       ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
           profile_id(), extension_id_safe(), extension_name,
-          event_name, sub_event_name, filter, extra_info_spec,
-          embedder_process_id, web_view_instance_id, ipc_sender_weak());
+          GetEventHistogramValue(event_name), event_name, sub_event_name,
+          filter, extra_info_spec, embedder_process_id, web_view_instance_id,
+          ipc_sender_weak());
   EXTENSION_FUNCTION_VALIDATE(success);
 
   helpers::ClearCacheOnNavigation();
 
   if (!extension_id_safe().empty()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&helpers::NotifyWebRequestAPIUsed,
                                        profile_id(), extension_id_safe()));
   }
 
@@ skipping 194 matching lines @@
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
 }  // namespace extensions