net: rename BoundNetLog to NetLogWithSource

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 418 matching lines @@
     const base::Time& extension_install_time,
     bool cancel,
     std::unique_ptr<net::AuthCredentials>* auth_credentials) {
   EventResponseDelta* result =
       new EventResponseDelta(extension_id, extension_install_time);
   result->cancel = cancel;
   result->auth_credentials.swap(*auth_credentials);
   return result;
 }
 
-void MergeCancelOfResponses(
-    const EventResponseDeltas& deltas,
-    bool* canceled,
-    const net::BoundNetLog* net_log) {
+void MergeCancelOfResponses(const EventResponseDeltas& deltas,
+                            bool* canceled,
+                            const net::NetLogWithSource* net_log) {
   for (EventResponseDeltas::const_iterator i = deltas.begin();
        i != deltas.end(); ++i) {
     if ((*i)->cancel) {
       *canceled = true;
       net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_ABORTED_REQUEST,
                         CreateNetLogExtensionIdCallback(i->get()));
       break;
     }
   }
 }
 
 // Helper function for MergeRedirectUrlOfResponses() that allows ignoring
 // all redirects but those to data:// urls and about:blank. This is important
 // to treat these URLs as "cancel urls", i.e. URLs that extensions redirect
 // to if they want to express that they want to cancel a request. This reduces
 // the number of conflicts that we need to flag, as canceling is considered
 // a higher precedence operation that redirects.
 // Returns whether a redirect occurred.
 static bool MergeRedirectUrlOfResponsesHelper(
     const EventResponseDeltas& deltas,
     GURL* new_url,
     extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log,
+    const net::NetLogWithSource* net_log,
     bool consider_only_cancel_scheme_urls) {
   bool redirected = false;
 
   // Extension that determines the |new_url|.
   std::string winning_extension_id;
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     if ((*delta)->new_url.is_empty())
       continue;
     if (consider_only_cancel_scheme_urls &&
@@ skipping 17 matching lines @@
               (*delta)->new_url,
               *new_url));
       net_log->AddEvent(
           net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
   return redirected;
 }
 
-void MergeRedirectUrlOfResponses(
-    const EventResponseDeltas& deltas,
-    GURL* new_url,
-    extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log) {
-
+void MergeRedirectUrlOfResponses(const EventResponseDeltas& deltas,
+                                 GURL* new_url,
+                                 extensions::WarningSet* conflicting_extensions,
+                                 const net::NetLogWithSource* net_log) {
   // First handle only redirects to data:// URLs and about:blank. These are a
   // special case as they represent a way of cancelling a request.
   if (MergeRedirectUrlOfResponsesHelper(
           deltas, new_url, conflicting_extensions, net_log, true)) {
     // If any extension cancelled a request by redirecting to a data:// URL or
     // about:blank, we don't consider the other redirects.
     return;
   }
 
   // Handle all other redirects.
   MergeRedirectUrlOfResponsesHelper(
       deltas, new_url, conflicting_extensions, net_log, false);
 }
 
 void MergeOnBeforeRequestResponses(
     const EventResponseDeltas& deltas,
     GURL* new_url,
     extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   MergeRedirectUrlOfResponses(deltas, new_url, conflicting_extensions, net_log);
 }
 
 static bool DoesRequestCookieMatchFilter(
     const ParsedRequestCookie& cookie,
     RequestCookie* filter) {
   if (!filter) return true;
   if (filter->name.get() && cookie.first != *filter->name) return false;
   if (filter->value.get() && cookie.second != *filter->value) return false;
   return true;
@@ skipping 105 matching lines @@
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
     extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   // 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;
 
@@ skipping 52 matching lines @@
         return (*delta)->extension_id;
     }
   }
   return std::string();
 }
 
 void MergeOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
     extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   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 286 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::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   // 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;
 
@@ skipping 35 matching lines @@
   }
   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::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   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 81 matching lines @@
     // Explicitly mark the URL as safe for redirection, to prevent the request
     // from being blocked because of net::ERR_UNSAFE_REDIRECT.
     *allowed_unsafe_redirect_url = new_url;
   }
 }
 
 bool MergeOnAuthRequiredResponses(
     const EventResponseDeltas& deltas,
     net::AuthCredentials* auth_credentials,
     extensions::WarningSet* conflicting_extensions,
-    const net::BoundNetLog* net_log) {
+    const net::NetLogWithSource* net_log) {
   CHECK(auth_credentials);
   bool credentials_set = false;
   std::string winning_extension_id;
 
   for (EventResponseDeltas::const_iterator delta = deltas.begin();
        delta != deltas.end();
        ++delta) {
     if (!(*delta)->auth_credentials.get())
       continue;
     bool different =
@@ skipping 113 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