Improve error messaging of webRequest API in case of conflicts

chrome/browser/extensions/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 "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
+#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_log.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 
+// TODO(battre): move all static functions into an anonymous namespace at the
+// top of this file.
+
 using base::Time;
+using extensions::ExtensionWarning;
 
 namespace extension_web_request_api_helpers {
 
 namespace {
 
 // A ParsedRequestCookie consists of the key and value of the cookie.
 typedef std::pair<base::StringPiece, base::StringPiece> ParsedRequestCookie;
 typedef std::vector<ParsedRequestCookie> ParsedRequestCookies;
 typedef std::vector<linked_ptr<net::ParsedCookie> > ParsedResponseCookies;
 
@@ skipping 286 matching lines @@
 // Helper function for MergeOnBeforeRequestResponses() 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 MergeOnBeforeRequestResponsesHelper(
     const EventResponseDeltas& deltas,
     GURL* new_url,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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 &&
         !(*delta)->new_url.SchemeIs(chrome::kDataScheme) &&
         (*delta)->new_url.spec() != "about:blank") {
       continue;
     }
 
     if (!redirected || *new_url == (*delta)->new_url) {
       *new_url = (*delta)->new_url;
+      winning_extension_id = (*delta)->extension_id;
       redirected = true;
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_REDIRECTED_REQUEST,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
-      conflicting_extensions->insert((*delta)->extension_id);
+      conflicting_extensions->insert(
+          ExtensionWarning::CreateRedirectConflictWarning(
+              (*delta)->extension_id,
+              winning_extension_id,
+              (*delta)->new_url,
+              *new_url));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
   return redirected;
 }
 
 void MergeOnBeforeRequestResponses(
     const EventResponseDeltas& deltas,
     GURL* new_url,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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 (MergeOnBeforeRequestResponsesHelper(
           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;
   }
@@ skipping 177 matching lines @@
         }
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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 11 matching lines @@
   modified |= MergeRemoveRequestCookieModifications(deltas, &cookies);
 
   // Reassemble and store new cookie line.
   if (modified) {
     std::string new_cookie_header = 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(
+    const EventResponseDeltas& deltas,
+    const std::string& key,
+    const std::string& value) {
+  EventResponseDeltas::const_iterator delta;
+  for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
+    net::HttpRequestHeaders::Iterator modification(
+        (*delta)->modified_request_headers);
+    while (modification.GetNext()) {
+      if (key == modification.name() && value == modification.value())
+        return (*delta)->extension_id;
+    }
+  }
+  return "";
+}
+
+// Returns the extension ID of the first extension in |deltas| that removes the
+// request header identified by |key|.
+static std::string FindRemoveRequestHeader(
+    const EventResponseDeltas& deltas,
+    const std::string& key) {
+  EventResponseDeltas::const_iterator delta;
+  for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
+    std::vector<std::string>::iterator i;
+    for (i = (*delta)->deleted_request_headers.begin();
+         i != (*delta)->deleted_request_headers.end();
+         ++i) {
+      if (*i == key)
+        return (*delta)->extension_id;
+    }
+  }
+  return "";
+}
+
 void MergeOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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) {
     if ((*delta)->modified_request_headers.IsEmpty() &&
         (*delta)->deleted_request_headers.empty()) {
       continue;
     }
 
     // Check whether any modification affects a request header that
     // has been modified differently before. As deltas is sorted by decreasing
     // extension installation order, this takes care of precedence.
     bool extension_conflicts = false;
+    std::string winning_extension_id;
+    std::string conflicting_header;
     {
       net::HttpRequestHeaders::Iterator modification(
           (*delta)->modified_request_headers);
       while (modification.GetNext() && !extension_conflicts) {
         // This modification sets |key| to |value|.
         const std::string& key = modification.name();
         const std::string& value = modification.value();
 
         // We must not delete anything that has been modified before.
-        if (removed_headers.find(key) != removed_headers.end())
+        if (removed_headers.find(key) != removed_headers.end() &&
+            !extension_conflicts) {
+          winning_extension_id = FindRemoveRequestHeader(deltas, key);
+          conflicting_header = key;
           extension_conflicts = true;
+        }
 
         // We must not modify anything that has been set to a *different*
         // value before.
-        if (set_headers.find(key) != set_headers.end()) {
+        if (set_headers.find(key) != set_headers.end() &&
+            !extension_conflicts) {
           std::string current_value;
           if (!request_headers->GetHeader(key, &current_value) ||
               current_value != value) {
+            winning_extension_id =
+                FindSetRequestHeader(deltas, key, current_value);
+            conflicting_header = key;
             extension_conflicts = true;
           }
         }
       }
     }
 
     // Check whether any deletion affects a request header that has been
     // modified before.
     {
       std::vector<std::string>::iterator key;
       for (key = (*delta)->deleted_request_headers.begin();
            key != (*delta)->deleted_request_headers.end() &&
                !extension_conflicts;
            ++key) {
-        if (set_headers.find(*key) != set_headers.end())
+        if (set_headers.find(*key) != set_headers.end()) {
+          std::string current_value;
+          request_headers->GetHeader(*key, &current_value);
+          winning_extension_id =
+              FindSetRequestHeader(deltas, *key, current_value);
+          conflicting_header = *key;
           extension_conflicts = true;
+        }
       }
     }
 
     // Now execute the modifications if there were no conflicts.
     if (!extension_conflicts) {
       // Copy all modifications into the original headers.
       request_headers->MergeFrom((*delta)->modified_request_headers);
       {
         // Record which keys were changed.
         net::HttpRequestHeaders::Iterator modification(
             (*delta)->modified_request_headers);
         while (modification.GetNext())
           set_headers.insert(modification.name());
       }
 
       // Perform all deletions and record which keys were deleted.
       {
         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::NetLog::TYPE_CHROME_EXTENSION_MODIFIED_HEADERS,
           base::Bind(&NetLogModificationCallback, delta->get()));
     } else {
-      conflicting_extensions->insert((*delta)->extension_id);
+      conflicting_extensions->insert(
+          ExtensionWarning::CreateRequestHeaderConflictWarning(
+              (*delta)->extension_id, winning_extension_id,
+              conflicting_header));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnBeforeSendHeadersResponses(deltas, request_headers,
       conflicting_extensions, net_log);
 }
 
@@ skipping 186 matching lines @@
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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 17 matching lines @@
     StoreResponseCookies(cookies, *override_response_headers);
 }
 
 // Converts the key of the (key, value) pair to lower case.
 static ResponseHeader ToLowerCase(const ResponseHeader& header) {
   std::string lower_key(header.first);
   StringToLowerASCII(&lower_key);
   return ResponseHeader(lower_key, 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 = StringToLowerASCII(key);
+  EventResponseDeltas::const_iterator delta;
+  for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
+    ResponseHeaders::const_iterator i;
+    for (i = (*delta)->deleted_response_headers.begin();
+         i != (*delta)->deleted_response_headers.end(); ++i) {
+      if (StringToLowerASCII(i->first) == lower_key)
+        return (*delta)->extension_id;
+    }
+  }
+  return "";
+}
+
 void MergeOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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).
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     if ((*delta)->added_response_headers.empty() &&
         (*delta)->deleted_response_headers.empty()) {
       continue;
     }
 
     // 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());
     }
 
     // We consider modifications as pairs of (delete, add) operations.
     // If a header is deleted twice by different extensions we assume that the
     // intention was to modify it to different values and consider this a
     // conflict. As deltas is sorted by decreasing extension installation order,
     // this takes care of precedence.
     bool extension_conflicts = false;
+    std::string conflicting_header;
+    std::string winning_extension_id;
     ResponseHeaders::const_iterator i;
     for (i = (*delta)->deleted_response_headers.begin();
          i != (*delta)->deleted_response_headers.end(); ++i) {
       if (removed_headers.find(ToLowerCase(*i)) != removed_headers.end()) {
+        winning_extension_id = FindRemoveResponseHeader(deltas, i->first);
+        conflicting_header = i->first;
         extension_conflicts = true;
         break;
       }
     }
 
     // Now execute the modifications if there were no conflicts.
     if (!extension_conflicts) {
       // Delete headers
       {
         for (i = (*delta)->deleted_response_headers.begin();
@@ skipping 11 matching lines @@
           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::NetLog::TYPE_CHROME_EXTENSION_MODIFIED_HEADERS,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
-      conflicting_extensions->insert((*delta)->extension_id);
+      conflicting_extensions->insert(
+          ExtensionWarning::CreateResponseHeaderConflictWarning(
+              (*delta)->extension_id, winning_extension_id,
+              conflicting_header));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnHeadersReceivedResponses(deltas, original_response_headers,
       override_response_headers, conflicting_extensions, net_log);
 }
 
 bool MergeOnAuthRequiredResponses(
     const EventResponseDeltas& deltas,
     net::AuthCredentials* auth_credentials,
-    std::set<std::string>* conflicting_extensions,
+    extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* 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 =
         auth_credentials->username() !=
             (*delta)->auth_credentials->username() ||
         auth_credentials->password() != (*delta)->auth_credentials->password();
     if (credentials_set && different) {
-      conflicting_extensions->insert((*delta)->extension_id);
+      conflicting_extensions->insert(
+          ExtensionWarning::CreateCredentialsConflictWarning(
+              (*delta)->extension_id, winning_extension_id));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_PROVIDE_AUTH_CREDENTIALS,
           CreateNetLogExtensionIdCallback(delta->get()));
       *auth_credentials = *(*delta)->auth_credentials;
       credentials_set = true;
+      winning_extension_id = (*delta)->extension_id;
     }
   }
   return credentials_set;
 }
 
 
 #define ARRAYEND(array) (array + arraysize(array))
 
 bool IsRelevantResourceType(ResourceType::Type type) {
   ResourceType::Type* iter =
@@ skipping 23 matching lines @@
 void ClearCacheOnNavigation() {
   if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     ClearCacheOnNavigationOnUI();
   } else {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      base::Bind(&ClearCacheOnNavigationOnUI));
   }
 }
 
 }  // namespace extension_web_request_api_helpers