Support redirectUrl at onHeadersReceived in WebRequest / DWR 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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 1256 matching lines @@
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(
             base_headers_string, sizeof(base_headers_string))));
 
   ResponseHeaders new_headers;
   new_headers.push_back(ResponseHeader("kEy1", "Value1"));  // Unchanged
   new_headers.push_back(ResponseHeader("Key2", "Value1"));  // Modified
   // Key3 is deleted
   new_headers.push_back(ResponseHeader("Key4", "Value4"));  // Added
+  GURL effective_new_url;
 
-  scoped_ptr<EventResponseDelta> delta(CalculateOnHeadersReceivedDelta(
-      "extid", base::Time::Now(), cancel, base_headers.get(), &new_headers));
+  scoped_ptr<EventResponseDelta> delta(
+      CalculateOnHeadersReceivedDelta("extid",
+                                      base::Time::Now(),
+                                      cancel,
+                                      effective_new_url,
+                                      base_headers.get(),
+                                      &new_headers));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   EXPECT_EQ(2u, delta->added_response_headers.size());
   EXPECT_TRUE(Contains(delta->added_response_headers,
                        ResponseHeader("Key2", "Value1")));
   EXPECT_TRUE(Contains(delta->added_response_headers,
                        ResponseHeader("Key4", "Value4")));
   EXPECT_EQ(2u, delta->deleted_response_headers.size());
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
                         ResponseHeader("Key2", "Value2, Bar")));
@@ skipping 662 matching lines @@
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       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;
-  MergeOnHeadersReceivedResponses(deltas, base_headers.get(), &new_headers0,
-                                  &warning_set, &net_log);
+  GURL allowed_unsafe_redirect_url0;
+  MergeOnHeadersReceivedResponses(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;
-  MergeOnHeadersReceivedResponses(
-      deltas, base_headers.get(), &new_headers1, &warning_set, &net_log);
+  GURL allowed_unsafe_redirect_url1;
+  MergeOnHeadersReceivedResponses(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"));
   void* iter = NULL;
   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;
-  MergeOnHeadersReceivedResponses(
-      deltas, base_headers.get(), &new_headers2, &warning_set, &net_log);
+  GURL allowed_unsafe_redirect_url2;
+  MergeOnHeadersReceivedResponses(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 = NULL;
   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"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
 }
@@ skipping 17 matching lines @@
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       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;
-  MergeOnHeadersReceivedResponses(
-      deltas, base_headers.get(), &new_headers1, &warning_set, &net_log);
+  GURL allowed_unsafe_redirect_url1;
+  MergeOnHeadersReceivedResponses(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"));
   void* iter = NULL;
   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());
 }
 
+// Tests whether onHeadersReceived can initiate a redirect.
+// The URL merge logic is shared with onBeforeRequest, so we only need to test
+// whether the URLs are merged at all.
+TEST(ExtensionWebRequestHelpersTest,
+     TestMergeOnHeadersReceivedResponsesRedirect) {
+  EventResponseDeltas deltas;
+  net::CapturingBoundNetLog capturing_net_log;
+  net::BoundNetLog net_log = capturing_net_log.bound();
+  ExtensionWarningSet warning_set;
+
+  char base_headers_string[] =
+      "HTTP/1.0 200 OK\r\n"
+      "\r\n";
+  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);
+  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);
+
+  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::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
   EventResponseDeltas deltas;
   base::string16 username = base::ASCIIToUTF16("foo");
   base::string16 password = base::ASCIIToUTF16("bar");
   base::string16 password2 = base::ASCIIToUTF16("baz");
 
   // Check that we can handle if not returning credentials.
@@ skipping 60 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