Extensions: Add metrics for Web Request API actions.

extensions/browser/api/web_request/web_request_api_helpers.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_helpers.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 634 matching lines @@
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
     extensions::WarningSet* conflicting_extensions,
-    const net::NetLogWithSource* net_log) {
+    const net::NetLogWithSource* net_log,
+    bool* request_cookies_modified) {
+  DCHECK(request_cookies_modified);
+  *request_cookies_modified = false;
+
   // Skip all work if there are no registered cookie modifications.
   bool cookie_modifications_exist = false;
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     cookie_modifications_exist |=
         !(*delta)->request_cookie_modifications.empty();
   }
   if (!cookie_modifications_exist)
     return;
 
   // Parse old cookie line.
   std::string cookie_header;
   request_headers->GetHeader(net::HttpRequestHeaders::kCookie, &cookie_header);
   ParsedRequestCookies cookies;
   net::cookie_util::ParseRequestCookieLine(cookie_header, &cookies);
 
   // Modify cookies.
-  bool modified = false;
-  modified |= MergeAddRequestCookieModifications(deltas, &cookies);
-  modified |= MergeEditRequestCookieModifications(deltas, &cookies);
-  modified |= MergeRemoveRequestCookieModifications(deltas, &cookies);
+  *request_cookies_modified |=
+      MergeAddRequestCookieModifications(deltas, &cookies);
+  *request_cookies_modified |=
+      MergeEditRequestCookieModifications(deltas, &cookies);
+  *request_cookies_modified |=
+      MergeRemoveRequestCookieModifications(deltas, &cookies);
 
   // Reassemble and store new cookie line.
-  if (modified) {
+  if (*request_cookies_modified) {
     std::string new_cookie_header =
         net::cookie_util::SerializeRequestCookieLine(cookies);
     request_headers->SetHeader(net::HttpRequestHeaders::kCookie,
                                new_cookie_header);
   }
 }
 
 // Returns the extension ID of the first extension in |deltas| that sets the
 // request header identified by |key| to |value|.
 static std::string FindSetRequestHeader(
@@ skipping 28 matching lines @@
         return (*delta)->extension_id;
     }
   }
   return std::string();
 }
 
 void MergeOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
     extensions::WarningSet* conflicting_extensions,
-    const net::NetLogWithSource* net_log) {
+    const net::NetLogWithSource* net_log,
+    bool* request_headers_modified,
+    bool* request_cookies_modified) {
+  DCHECK(request_headers_modified);
+  DCHECK(request_cookies_modified);
+  *request_headers_modified = false;
+  *request_cookies_modified = false;
+
   EventResponseDeltas::const_iterator delta;
 
   // Here we collect which headers we have removed or set to new values
   // so far due to extensions of higher precedence.
   std::set<std::string> removed_headers;
   std::set<std::string> set_headers;
 
   // We assume here that the deltas are sorted in decreasing extension
   // precedence (i.e. decreasing extension installation time).
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
@@ skipping 76 matching lines @@
         std::vector<std::string>::iterator key;
         for (key = (*delta)->deleted_request_headers.begin();
              key != (*delta)->deleted_request_headers.end();
              ++key) {
           request_headers->RemoveHeader(*key);
           removed_headers.insert(*key);
         }
       }
       net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_MODIFIED_HEADERS,
                         base::Bind(&NetLogModificationCallback, delta->get()));
+      *request_headers_modified = true;
     } else {
       conflicting_extensions->insert(
           extensions::Warning::CreateRequestHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
           net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnBeforeSendHeadersResponses(deltas, request_headers,
-      conflicting_extensions, net_log);
+                                             conflicting_extensions, net_log,
+                                             request_cookies_modified);
 }
 
 // Retrives all cookies from |override_response_headers|.
 static ParsedResponseCookies GetResponseCookies(
     scoped_refptr<net::HttpResponseHeaders> override_response_headers) {
   ParsedResponseCookies result;
 
   size_t iter = 0;
   std::string value;
   while (override_response_headers->EnumerateHeader(&iter, "Set-Cookie",
@@ skipping 177 matching lines @@
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     extensions::WarningSet* conflicting_extensions,
-    const net::NetLogWithSource* net_log) {
+    const net::NetLogWithSource* net_log,
+    bool* response_cookies_modified) {
+  DCHECK(response_cookies_modified);
+  *response_cookies_modified = false;
+
   // Skip all work if there are no registered cookie modifications.
   bool cookie_modifications_exist = false;
   EventResponseDeltas::const_reverse_iterator delta;
   for (delta = deltas.rbegin(); delta != deltas.rend(); ++delta) {
     cookie_modifications_exist |=
         !(*delta)->response_cookie_modifications.empty();
   }
   if (!cookie_modifications_exist)
     return;
 
   // Only create a copy if we really want to modify the response headers.
   if (override_response_headers->get() == NULL) {
     *override_response_headers = new net::HttpResponseHeaders(
         original_response_headers->raw_headers());
   }
 
   ParsedResponseCookies cookies =
       GetResponseCookies(*override_response_headers);
 
-  bool modified = false;
-  modified |= MergeAddResponseCookieModifications(deltas, &cookies);
-  modified |= MergeEditResponseCookieModifications(deltas, &cookies);
-  modified |= MergeRemoveResponseCookieModifications(deltas, &cookies);
+  *response_cookies_modified |=
+      MergeAddResponseCookieModifications(deltas, &cookies);
+  *response_cookies_modified |=
+      MergeEditResponseCookieModifications(deltas, &cookies);
+  *response_cookies_modified |=
+      MergeRemoveResponseCookieModifications(deltas, &cookies);
 
   // Store new value.
-  if (modified)
+  if (*response_cookies_modified)
     StoreResponseCookies(cookies, *override_response_headers);
 }
 
 // Converts the key of the (key, value) pair to lower case.
 static ResponseHeader ToLowerCase(const ResponseHeader& header) {
   return ResponseHeader(base::ToLowerASCII(header.first), header.second);
 }
 
 // Returns the extension ID of the first extension in |deltas| that removes the
 // request header identified by |key|.
 static std::string FindRemoveResponseHeader(
     const EventResponseDeltas& deltas,
     const std::string& key) {
   std::string lower_key = base::ToLowerASCII(key);
   for (const auto& delta : deltas) {
     for (const auto& deleted_hdr : delta->deleted_response_headers) {
       if (base::ToLowerASCII(deleted_hdr.first) == lower_key)
         return delta->extension_id;
     }
   }
   return std::string();
 }
 
 void MergeOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url,
     extensions::WarningSet* conflicting_extensions,
-    const net::NetLogWithSource* net_log) {
+    const net::NetLogWithSource* net_log,
+    bool* response_headers_modified,
+    bool* response_cookies_modified) {
+  DCHECK(response_headers_modified);
+  DCHECK(response_cookies_modified);
+  *response_headers_modified = false;
+  *response_cookies_modified = false;
+
   EventResponseDeltas::const_iterator delta;
 
   // Here we collect which headers we have removed or added so far due to
   // extensions of higher precedence. Header keys are always stored as
   // lower case.
   std::set<ResponseHeader> removed_headers;
   std::set<ResponseHeader> added_headers;
 
   // We assume here that the deltas are sorted in decreasing extension
   // precedence (i.e. decreasing extension installation time).
@@ skipping 45 matching lines @@
              i != (*delta)->added_response_headers.end(); ++i) {
           ResponseHeader lowercase_header(ToLowerCase(*i));
           if (added_headers.find(lowercase_header) != added_headers.end())
             continue;
           added_headers.insert(lowercase_header);
           (*override_response_headers)->AddHeader(i->first + ": " + i->second);
         }
       }
       net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_MODIFIED_HEADERS,
                         CreateNetLogExtensionIdCallback(delta->get()));
+      *response_headers_modified = true;
     } else {
       conflicting_extensions->insert(
           extensions::Warning::CreateResponseHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
           net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
-  MergeCookiesInOnHeadersReceivedResponses(deltas, original_response_headers,
-      override_response_headers, conflicting_extensions, net_log);
+  MergeCookiesInOnHeadersReceivedResponses(
+      deltas, original_response_headers, override_response_headers,
+      conflicting_extensions, net_log, response_cookies_modified);
 
   GURL new_url;
   MergeRedirectUrlOfResponses(
       deltas, &new_url, conflicting_extensions, net_log);
   if (new_url.is_valid()) {
     // Only create a copy if we really want to modify the response headers.
     if (override_response_headers->get() == NULL) {
       *override_response_headers = new net::HttpResponseHeaders(
           original_response_headers->raw_headers());
     }
@@ skipping 93 matching lines @@
   for (size_t i = 0; i < kResourceTypeStringsLength; ++i) {
     if (type_str == kResourceTypeStrings[i]) {
       found = true;
       types->push_back(kResourceTypeValues[i]);
     }
   }
   return found;
 }
 
 }  // namespace extension_web_request_api_helpers