Improve error messaging of webRequest API in case of conflicts

chrome/browser/extensions/api/web_request/web_request_api_unittest.cc

Index: chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
diff --git a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
index 8976a1d76fe5984c7c9268c77869de12e345a34e..e69185ad86afd7ac00a0e3872f00edd34cfc6bad 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
@@ -20,6 +20,7 @@
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
+#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/pref_names.h"
@@ -75,6 +76,19 @@ bool Contains(const Collection& collection, const Key& key) {
       collection.end();
 }
 
+// Returns whether |warnings| contains an extension for |extension_id|.
+bool HasWarning(const std::set<linked_ptr<ExtensionWarning> > warnings,
+                const std::string& extension_id) {
+  for (std::set<linked_ptr<ExtensionWarning> >::const_iterator i =
+           warnings.begin();
+       i != warnings.end();
+       ++i) {
+    if ((*i)->extension_id() == extension_id)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 // A mock event router that responds to events with a pre-arranged queue of
@@ -953,7 +967,7 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
                         ResponseHeader("Key2", "Value2, Bar")));
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
-                        ResponseHeader("Key3", "Value3")));
+                       ResponseHeader("Key3", "Value3")));
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
@@ -1004,7 +1018,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   GURL effective_new_url;
 
   // No redirect
@@ -1012,7 +1027,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
       new EventResponseDelta("extid0", base::Time::FromInternalValue(0)));
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
   EXPECT_TRUE(effective_new_url.is_empty());
 
   // Single redirect.
@@ -1024,9 +1039,10 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_TRUE(conflicting_extensions.empty());
+  EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Ignored redirect (due to precedence).
@@ -1038,10 +1054,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Overriding redirect.
@@ -1051,14 +1068,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   d3->new_url = GURL(new_url_3);
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_3, effective_new_url);
-  EXPECT_EQ(2u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid1"));
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(2u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid1"));
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 
   // Check that identical redirects don't cause a conflict.
@@ -1067,14 +1084,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   d4->new_url = GURL(new_url_3);
   deltas.push_back(d4);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_3, effective_new_url);
-  EXPECT_EQ(2u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid1"));
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(2u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid1"));
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(4u, capturing_net_log.GetSize());
 }
 
@@ -1084,7 +1101,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   GURL effective_new_url;
 
   // Single redirect.
@@ -1094,7 +1112,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to a data:// URL. This shall override
@@ -1107,9 +1126,10 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_TRUE(conflicting_extensions.empty());
+  EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Cancel request by redirecting to the same data:// URL. This shall
@@ -1122,9 +1142,10 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_TRUE(conflicting_extensions.empty());
+  EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Cancel redirect by redirecting to a different data:// URL. This needs
@@ -1137,10 +1158,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid3"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid3"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
@@ -1150,7 +1172,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   GURL effective_new_url;
 
   // Single redirect.
@@ -1160,7 +1183,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to about:blank. This shall override
@@ -1173,9 +1197,10 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &conflicting_extensions, &net_log);
+      deltas, &effective_new_url, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
-  EXPECT_TRUE(conflicting_extensions.empty());
+  EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 }
 
@@ -1185,7 +1210,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   base_headers.AddHeaderFromString("key2: value 2");
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ -1195,13 +1221,13 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   deltas.push_back(d0);
   net::HttpRequestHeaders headers0;
   headers0.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(
-      deltas, &headers0, &conflicting_extensions, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &net_log);
+  warnings = warning_set.Release();
   ASSERT_TRUE(headers0.GetHeader("key1", &header_value));
   EXPECT_EQ("value 1", header_value);
   ASSERT_TRUE(headers0.GetHeader("key2", &header_value));
   EXPECT_EQ("value 2", header_value);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   // Delete, modify and add a header.
@@ -1214,14 +1240,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(
-      deltas, &headers1, &conflicting_extensions, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(headers1.HasHeader("key1"));
   ASSERT_TRUE(headers1.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers1.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Check that conflicts are atomic, i.e. if one header modification
@@ -1233,20 +1259,19 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   d2->modified_request_headers.AddHeaderFromString("key4: value 4");
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   net::HttpRequestHeaders headers2;
   headers2.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(
-      deltas, &headers2, &conflicting_extensions, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(headers2.HasHeader("key1"));
   ASSERT_TRUE(headers2.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers2.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   EXPECT_FALSE(headers2.HasHeader("key4"));
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Check that identical modifications don't conflict and operations
@@ -1258,12 +1283,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   d3->modified_request_headers.AddHeaderFromString("key5: value 5");
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   net::HttpRequestHeaders headers3;
   headers3.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(
-      deltas, &headers3, &conflicting_extensions, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(headers3.HasHeader("key1"));
   ASSERT_TRUE(headers3.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
@@ -1271,8 +1295,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers3.GetHeader("key5", &header_value));
   EXPECT_EQ("value 5", header_value);
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
@@ -1283,7 +1307,8 @@ TEST(ExtensionWebRequestHelpersTest,
       "Cookie: name=value; name2=value2; name3=value3");
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ -1328,12 +1353,12 @@ TEST(ExtensionWebRequestHelpersTest,
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(
-      deltas, &headers1, &conflicting_extensions, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_TRUE(headers1.HasHeader("Cookie"));
   ASSERT_TRUE(headers1.GetHeader("Cookie", &header_value));
   EXPECT_EQ("name=new value; name2=new value; name4=\"value 4\"", header_value);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 }
 
@@ -1341,7 +1366,8 @@ TEST(ExtensionWebRequestHelpersTest,
      TestMergeCookiesInOnHeadersReceivedResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ -1363,10 +1389,10 @@ TEST(ExtensionWebRequestHelpersTest,
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeCookiesInOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers0, &conflicting_extensions,
-        &net_log);
+        deltas, base_headers.get(), &new_headers0, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(new_headers0.get());
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   linked_ptr<ResponseCookieModification> add_cookie =
@@ -1415,7 +1441,8 @@ TEST(ExtensionWebRequestHelpersTest,
               base_headers_string, sizeof(base_headers_string))));
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeCookiesInOnHeadersReceivedResponses(
-      deltas, headers1.get(), &new_headers1, &conflicting_extensions, &net_log);
+      deltas, headers1.get(), &new_headers1, &warning_set, &net_log);
+  warnings = warning_set.Release();
 
   EXPECT_TRUE(new_headers1->HasHeader("Foo"));
   void* iter = NULL;
@@ -1428,14 +1455,15 @@ TEST(ExtensionWebRequestHelpersTest,
   while (new_headers1->EnumerateHeader(&iter, "Set-Cookie", &cookie_string))
     actual_cookies.insert(cookie_string);
   EXPECT_EQ(expected_cookies, actual_cookies);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ -1454,11 +1482,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
-  MergeOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers0, &conflicting_extensions,
-        &net_log);
+  MergeOnHeadersReceivedResponses(deltas, base_headers.get(), &new_headers0,
+                                  &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(new_headers0.get());
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   linked_ptr<EventResponseDelta> d1(
@@ -1468,12 +1496,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   d1->added_response_headers.push_back(ResponseHeader("Key2", "Value3"));
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers1, &conflicting_extensions,
-        &net_log);
+      deltas, base_headers.get(), &new_headers1, &warning_set, &net_log);
+  warnings = warning_set.Release();
   ASSERT_TRUE(new_headers1.get());
   std::multimap<std::string, std::string> expected1;
   expected1.insert(std::pair<std::string, std::string>("Key2", "Value3"));
@@ -1485,7 +1512,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
     actual1.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual1);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Check that we replace response headers only once.
@@ -1497,12 +1524,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   d2->added_response_headers.push_back(ResponseHeader("Key2", "Value4"));
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers2;
   MergeOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers2, &conflicting_extensions,
-        &net_log);
+      deltas, base_headers.get(), &new_headers2, &warning_set, &net_log);
+  warnings = warning_set.Release();
   ASSERT_TRUE(new_headers2.get());
   iter = NULL;
   std::multimap<std::string, std::string> actual2;
@@ -1510,8 +1536,8 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
     actual2.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual2);
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 }
 
@@ -1520,7 +1546,8 @@ TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnHeadersReceivedResponsesDeletion) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ -1542,8 +1569,8 @@ TEST(ExtensionWebRequestHelpersTest,
   deltas.push_back(d1);
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers1, &conflicting_extensions,
-        &net_log);
+      deltas, base_headers.get(), &new_headers1, &warning_set, &net_log);
+  warnings = warning_set.Release();
   ASSERT_TRUE(new_headers1.get());
   std::multimap<std::string, std::string> expected1;
   expected1.insert(std::pair<std::string, std::string>("Key1", "Value1"));
@@ -1557,14 +1584,15 @@ TEST(ExtensionWebRequestHelpersTest,
     actual1.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual1);
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warning_set;
+  std::set<linked_ptr<ExtensionWarning> > warnings;
   EventResponseDeltas deltas;
   string16 username = ASCIIToUTF16("foo");
   string16 password = ASCIIToUTF16("bar");
@@ -1576,10 +1604,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   deltas.push_back(d0);
   net::AuthCredentials auth0;
   bool credentials_set = MergeOnAuthRequiredResponses(
-        deltas, &auth0, &conflicting_extensions, &net_log);
+      deltas, &auth0, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_FALSE(credentials_set);
   EXPECT_TRUE(auth0.Empty());
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   // Check that we can set AuthCredentials.
@@ -1588,16 +1617,16 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   d1->auth_credentials.reset(new net::AuthCredentials(username, password));
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   net::AuthCredentials auth1;
   credentials_set = MergeOnAuthRequiredResponses(
-        deltas, &auth1, &conflicting_extensions, &net_log);
+      deltas, &auth1, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth1.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
-  EXPECT_EQ(0u, conflicting_extensions.size());
+  EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Check that we set AuthCredentials only once.
@@ -1606,17 +1635,17 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   d2->auth_credentials.reset(new net::AuthCredentials(username, password2));
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   net::AuthCredentials auth2;
   credentials_set = MergeOnAuthRequiredResponses(
-        deltas, &auth2, &conflicting_extensions, &net_log);
+      deltas, &auth2, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth2.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Check that we can set identical AuthCredentials twice without causing
@@ -1626,17 +1655,16 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   d3->auth_credentials.reset(new net::AuthCredentials(username, password));
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  conflicting_extensions.clear();
   capturing_net_log.Clear();
   net::AuthCredentials auth3;
   credentials_set = MergeOnAuthRequiredResponses(
-        deltas, &auth3, &conflicting_extensions, &net_log);
+      deltas, &auth3, &warning_set, &net_log);
+  warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
-  EXPECT_EQ(1u, conflicting_extensions.size());
-  EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2"));
+  EXPECT_EQ(1u, warnings.size());
+  EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
-