Support WebSocket in WebRequest API.

chrome/browser/extensions/api/web_request/web_request_api_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
@@ skipping 76 matching lines @@
 using helpers::RequestCookieModification;
 using helpers::ResponseCookieModification;
 using helpers::ResponseHeader;
 using helpers::ResponseHeaders;
 using helpers::StringToCharList;
 
 namespace extensions {
 
 namespace {
 
+constexpr const char kExampleUrl[] = "http://example.com";
+
 static void EventHandledOnIOThread(
     void* profile,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64_t request_id,
     ExtensionWebRequestEventRouter::EventResponse* response) {
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile, extension_id, event_name, sub_event_name, request_id,
       response);
@@ skipping 1455 matching lines @@
   EventResponseDeltas deltas;
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   GURL effective_new_url;
 
   // No redirect
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(0)));
   deltas.push_back(d0);
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_TRUE(effective_new_url.is_empty());
 
   // Single redirect.
   GURL new_url_1("http://foo.com");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1000)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Ignored redirect (due to precedence).
   GURL new_url_2("http://bar.com");
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(500)));
   d2->new_url = GURL(new_url_2);
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Overriding redirect.
   GURL new_url_3("http://baz.com");
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(1500)));
   d3->new_url = GURL(new_url_3);
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid1"));
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 
   // Check that identical redirects don't cause a conflict.
   linked_ptr<EventResponseDelta> d4(
       new EventResponseDelta("extid4", base::Time::FromInternalValue(2000)));
   d4->new_url = GURL(new_url_3);
   deltas.push_back(d4);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid1"));
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(4u, capturing_net_log.GetSize());
 }
 
 // This tests that we can redirect to data:// urls, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   EventResponseDeltas deltas;
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   GURL effective_new_url;
 
   // Single redirect.
   GURL new_url_0("http://foo.com");
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2000)));
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to a data:// URL. This shall override
   // the other redirect but not cause any conflict warnings.
   GURL new_url_1("data://foo");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1500)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Cancel request by redirecting to the same data:// URL. This shall
   // not create any conflicts as it is in line with d1.
   GURL new_url_2("data://foo");
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1000)));
   d2->new_url = GURL(new_url_2);
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 
   // Cancel redirect by redirecting to a different data:// URL. This needs
   // to create a conflict.
   GURL new_url_3("data://something_totally_different");
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(500)));
   d3->new_url = GURL(new_url_3);
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid3"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 // This tests that we can redirect to about:blank, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   EventResponseDeltas deltas;
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   GURL effective_new_url;
 
   // Single redirect.
   GURL new_url_0("http://foo.com");
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2000)));
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to about:blank. This shall override
   // the other redirect but not cause any conflict warnings.
   GURL new_url_1("about:blank");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1500)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
-  MergeOnBeforeRequestResponses(
-      deltas, &effective_new_url, &warning_set, &net_log);
+  MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
+                                &warning_set, &net_log);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 }
 
+// This tests that WebSocket requests can not be redirected.
+TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses4) {
+  EventResponseDeltas deltas;
+  net::BoundTestNetLog capturing_net_log;
+  net::NetLogWithSource net_log = capturing_net_log.bound();
+  WarningSet warning_set;
+  GURL effective_new_url;
+
+  // Single redirect.
+  linked_ptr<EventResponseDelta> delta(
+      new EventResponseDelta("extid", base::Time::FromInternalValue(2000)));
+  delta->new_url = GURL("http://foo.com");
+  deltas.push_back(delta);
+  MergeOnBeforeRequestResponses(GURL("ws://example.com"), deltas,
+                                &effective_new_url, &warning_set, &net_log);
+  EXPECT_EQ(GURL::EmptyGURL(), effective_new_url);

[Devlin, 2017/02/21 20:34:11]

nit: just use GURL() instead of EmptyGURL()

[pkalinnikov, 2017/02/21 22:28:54]

Done.

+}
+
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   net::HttpRequestHeaders base_headers;
   base_headers.SetHeader("key1", "value 1");
   base_headers.SetHeader("key2", "value 2");
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
 
@@ skipping 421 matching lines @@
       new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(
             base_headers_string, sizeof(base_headers_string))));
 
   // Check that we can handle if not touching the response headers.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   GURL allowed_unsafe_redirect_url0;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers0,
-                                  &allowed_unsafe_redirect_url0,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers0, &allowed_unsafe_redirect_url0,
+                                  &warning_set, &net_log);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url0.is_empty());
   EXPECT_EQ(0u, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->deleted_response_headers.push_back(ResponseHeader("KEY1", "Value1"));
   d1->deleted_response_headers.push_back(ResponseHeader("KEY2", "Value2, Foo"));
   d1->added_response_headers.push_back(ResponseHeader("Key2", "Value3"));
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   GURL allowed_unsafe_redirect_url1;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers1,
-                                  &allowed_unsafe_redirect_url1,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers1, &allowed_unsafe_redirect_url1,
+                                  &warning_set, &net_log);
   ASSERT_TRUE(new_headers1.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url1.is_empty());
   std::multimap<std::string, std::string> expected1;
   expected1.insert(std::pair<std::string, std::string>("Key2", "Value3"));
   size_t iter = 0;
   std::string name;
   std::string value;
   std::multimap<std::string, std::string> actual1;
   while (new_headers1->EnumerateHeaderLines(&iter, &name, &value)) {
     actual1.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual1);
   EXPECT_EQ(0u, warning_set.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 
   // Check that we replace response headers only once.
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1500)));
   // Note that we use a different capitalization of KeY2. This should not
   // matter.
   d2->deleted_response_headers.push_back(ResponseHeader("KeY2", "Value2, Foo"));
   d2->added_response_headers.push_back(ResponseHeader("Key2", "Value4"));
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers2;
   GURL allowed_unsafe_redirect_url2;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers2,
-                                  &allowed_unsafe_redirect_url2,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers2, &allowed_unsafe_redirect_url2,
+                                  &warning_set, &net_log);
   ASSERT_TRUE(new_headers2.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url2.is_empty());
   iter = 0;
   std::multimap<std::string, std::string> actual2;
   while (new_headers2->EnumerateHeaderLines(&iter, &name, &value)) {
     actual2.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual2);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
@@ skipping 20 matching lines @@
       new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(
             base_headers_string, sizeof(base_headers_string))));
 
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->deleted_response_headers.push_back(ResponseHeader("KEY1", "Value2"));
   deltas.push_back(d1);
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   GURL allowed_unsafe_redirect_url1;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers1,
-                                  &allowed_unsafe_redirect_url1,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers1, &allowed_unsafe_redirect_url1,
+                                  &warning_set, &net_log);
   ASSERT_TRUE(new_headers1.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url1.is_empty());
   std::multimap<std::string, std::string> expected1;
   expected1.insert(std::pair<std::string, std::string>("Key1", "Value1"));
   expected1.insert(std::pair<std::string, std::string>("Key1", "Value3"));
   expected1.insert(std::pair<std::string, std::string>("Key2", "Value4"));
   size_t iter = 0;
   std::string name;
   std::string value;
   std::multimap<std::string, std::string> actual1;
@@ skipping 21 matching lines @@
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(net::HttpUtil::AssembleRawHeaders(
           base_headers_string, sizeof(base_headers_string))));
 
   // No redirect
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(0)));
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   GURL allowed_unsafe_redirect_url0;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers0,
-                                  &allowed_unsafe_redirect_url0,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers0, &allowed_unsafe_redirect_url0,
+                                  &warning_set, &net_log);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url0.is_empty());
   EXPECT_EQ(0u, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 
   // Single redirect.
   GURL new_url_1("http://foo.com");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1000)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   GURL allowed_unsafe_redirect_url1;
-  MergeOnHeadersReceivedResponses(deltas,
-                                  base_headers.get(),
-                                  &new_headers1,
-                                  &allowed_unsafe_redirect_url1,
-                                  &warning_set,
-                                  &net_log);
+  MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
+                                  &new_headers1, &allowed_unsafe_redirect_url1,
+                                  &warning_set, &net_log);
 
   EXPECT_TRUE(new_headers1.get());
   EXPECT_TRUE(new_headers1->HasHeaderValue("Location", new_url_1.spec()));
   EXPECT_EQ(new_url_1, allowed_unsafe_redirect_url1);
   EXPECT_TRUE(warning_set.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   net::BoundTestNetLog capturing_net_log;
@@ skipping 68 matching lines @@
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 }  // namespace extensions