Extensions: Add metrics for Web Request API actions.

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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 67 matching lines @@
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 
 namespace extensions {
 
 namespace declarative_keys = declarative_webrequest_constants;
 namespace web_request = api::web_request;
 
 namespace {
 
+// Describes the action taken by the Web Request API for a given stage of a web
+// request.
+// These values are written to logs.  New enum values can be added, but existing
+// enum values must never be renumbered or deleted and reused.
+enum RequestAction {
+  CANCEL = 0,
+  REDIRECT = 1,
+  MODIFY_REQUEST_HEADERS = 2,
+  MODIFY_REQUEST_COOKIES = 3,
+  MODIFY_RESPONSE_HEADERS = 4,
+  MODIFY_RESPONSE_COOKIES = 5,
+  SET_AUTH_CREDENTIALS = 6,
+  MAX
+};
+
 const char kWebRequestEventPrefix[] = "webRequest.";
+const char kWebRequestActionUMA[] = "Extensions.WebRequestAction";
 
 // 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,
@@ skipping 1678 matching lines @@
 
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&SendOnMessageEventOnUI, browser_context,
                      delta->extension_id, is_web_view_guest,
                      web_view_instance_id, base::Passed(&event_details)));
     }
   }
 }
 
 int ExtensionWebRequestEventRouter::ExecuteDeltas(

[karandeepb, 2017/02/23 21:31:05]

This will also include modifications done via the Declarative WR API. I am
assuming that's ok, since its effect will be minimal.

     void* browser_context,
     uint64_t request_id,
     ExtensionNavigationUIData* navigation_ui_data,
     bool call_callback) {
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   CHECK_EQ(0, blocked_request.num_handlers_blocking);
   helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   request_time_tracker_->IncrementTotalBlockTime(request_id, block_time);
 
   bool credentials_set = false;
 
   deltas.sort(&helpers::InDecreasingExtensionInstallationTimeOrder);
 
   bool canceled = false;
   helpers::MergeCancelOfResponses(blocked_request.response_deltas, &canceled,
                                   blocked_request.net_log);
 
   WarningSet warnings;
   if (blocked_request.event == kOnBeforeRequest) {
     CHECK(!blocked_request.callback.is_null());
     helpers::MergeOnBeforeRequestResponses(
         blocked_request.response_deltas,
         blocked_request.new_url,
         &warnings,
         blocked_request.net_log);
   } else if (blocked_request.event == kOnBeforeSendHeaders) {
     CHECK(!blocked_request.callback.is_null());
+    bool request_headers_modified = false;
+    bool request_cookies_modified = false;
     helpers::MergeOnBeforeSendHeadersResponses(
-        blocked_request.response_deltas,
-        blocked_request.request_headers,
-        &warnings,
-        blocked_request.net_log);
+        blocked_request.response_deltas, blocked_request.request_headers,
+        &warnings, blocked_request.net_log, &request_headers_modified,
+        &request_cookies_modified);
+    if (request_headers_modified)
+      UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA,
+                                RequestAction::MODIFY_REQUEST_HEADERS,
+                                RequestAction::MAX);
+    if (request_cookies_modified)
+      UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA,
+                                RequestAction::MODIFY_REQUEST_COOKIES,
+                                RequestAction::MAX);
   } else if (blocked_request.event == kOnHeadersReceived) {
     CHECK(!blocked_request.callback.is_null());
+    bool response_headers_modified = false;
+    bool response_cookies_modified = false;
     helpers::MergeOnHeadersReceivedResponses(
         blocked_request.response_deltas,
         blocked_request.original_response_headers.get(),
-        blocked_request.override_response_headers,
-        blocked_request.new_url,
-        &warnings,
-        blocked_request.net_log);
+        blocked_request.override_response_headers, blocked_request.new_url,
+        &warnings, blocked_request.net_log, &response_headers_modified,
+        &response_cookies_modified);
+    if (response_headers_modified)
+      UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA,
+                                RequestAction::MODIFY_RESPONSE_HEADERS,
+                                RequestAction::MAX);
+    if (response_cookies_modified)
+      UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA,
+                                RequestAction::MODIFY_RESPONSE_COOKIES,
+                                RequestAction::MAX);
   } else if (blocked_request.event == kOnAuthRequired) {
     CHECK(blocked_request.callback.is_null());
     CHECK(!blocked_request.auth_callback.is_null());
     credentials_set = helpers::MergeOnAuthRequiredResponses(
        blocked_request.response_deltas,
        blocked_request.auth_credentials,
        &warnings,
        blocked_request.net_log);
   } else {
     NOTREACHED();
   }
 
   SendMessages(browser_context, blocked_request, navigation_ui_data);
 
   if (!warnings.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&WarningService::NotifyWarningsOnUI,
                    browser_context, warnings));
   }
 
   if (canceled) {
     request_time_tracker_->SetRequestCanceled(request_id);
-  } else if (blocked_request.new_url &&
-             !blocked_request.new_url->is_empty()) {
+    UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA, RequestAction::CANCEL,
+                              RequestAction::MAX);
+  } else if (blocked_request.new_url && !blocked_request.new_url->is_empty()) {
     request_time_tracker_->SetRequestRedirected(request_id);
+    UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA, RequestAction::REDIRECT,
+                              RequestAction::MAX);
+  } else if (credentials_set) {
+    UMA_HISTOGRAM_ENUMERATION(kWebRequestActionUMA,
+                              RequestAction::SET_AUTH_CREDENTIALS,
+                              RequestAction::MAX);
   }
 
   // This triggers onErrorOccurred if canceled is true.
   int rv = canceled ? net::ERR_BLOCKED_BY_CLIENT : net::OK;
 
   if (!blocked_request.callback.is_null()) {
     net::CompletionCallback callback = blocked_request.callback;
     // Ensure that request is removed before callback because the callback
     // might trigger the next event.
     blocked_requests_.erase(request_id);
@@ skipping 522 matching lines @@
   // Since EventListeners are segmented by browser_context, check that
   // last, as it is exceedingly unlikely to be different.
   return extension_id == that.extension_id &&
          sub_event_name == that.sub_event_name &&
          web_view_instance_id == that.web_view_instance_id &&
          embedder_process_id == that.embedder_process_id &&
          browser_context == that.browser_context;
 }
 
 }  // namespace extensions