Extensions: Add metrics for Web Request API actions.

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 1738 matching lines @@
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
 
   // Check that we can handle not changing the headers.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2500)));
   deltas.push_back(d0);
+  bool request_headers_modified0;
+  bool request_cookies_modified0;
   net::HttpRequestHeaders headers0;
   headers0.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &net_log,
+                                    &request_headers_modified0,
+                                    &request_cookies_modified0);
   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, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_FALSE(request_headers_modified0);
+  EXPECT_FALSE(request_cookies_modified0);
 
   // Delete, modify and add a header.
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->deleted_request_headers.push_back("key1");
   d1->modified_request_headers.SetHeader("key2", "value 3");
   d1->modified_request_headers.SetHeader("key3", "value 3");
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
+  bool request_headers_modified1;
+  bool request_cookies_modified1;
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log,
+                                    &request_headers_modified1,
+                                    &request_cookies_modified1);
   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, warning_set.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_TRUE(request_headers_modified1);
+  EXPECT_FALSE(request_cookies_modified1);
 
   // Check that conflicts are atomic, i.e. if one header modification
   // collides all other conflicts of the same extension are declined as well.
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1500)));
   // This one conflicts:
   d2->modified_request_headers.SetHeader("key3", "value 0");
   d2->modified_request_headers.SetHeader("key4", "value 4");
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
+  bool request_headers_modified2;
+  bool request_cookies_modified2;
   net::HttpRequestHeaders headers2;
   headers2.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &net_log,
+                                    &request_headers_modified2,
+                                    &request_cookies_modified2);
   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, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_TRUE(request_headers_modified2);
+  EXPECT_FALSE(request_cookies_modified2);
 
   // Check that identical modifications don't conflict and operations
   // can be merged.
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(1000)));
   d3->deleted_request_headers.push_back("key1");
   d3->modified_request_headers.SetHeader("key2", "value 3");
   d3->modified_request_headers.SetHeader("key5", "value 5");
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
   capturing_net_log.Clear();
+  bool request_headers_modified3;
+  bool request_cookies_modified3;
   net::HttpRequestHeaders headers3;
   headers3.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &net_log,
+                                    &request_headers_modified3,
+                                    &request_cookies_modified3);
   EXPECT_FALSE(headers3.HasHeader("key1"));
   ASSERT_TRUE(headers3.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers3.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers3.GetHeader("key5", &header_value));
   EXPECT_EQ("value 5", header_value);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
+  EXPECT_TRUE(request_headers_modified3);
+  EXPECT_FALSE(request_cookies_modified3);
 }
 
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnBeforeSendHeadersResponses_Cookies) {
   net::HttpRequestHeaders base_headers;
   base_headers.AddHeaderFromString(
       "Cookie: name=value; name2=value2; name3=\"value3\"");
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
@@ skipping 32 matching lines @@
       add_cookie, add_cookie_2, edit_cookie, remove_cookie
   };
 
   for (size_t i = 0; i < arraysize(operations); ++i) {
     linked_ptr<EventResponseDelta> delta(
         new EventResponseDelta("extid0", base::Time::FromInternalValue(i * 5)));
     delta->request_cookie_modifications.push_back(operations[i]);
     deltas.push_back(delta);
   }
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
+  bool request_headers_modified1;
+  bool request_cookies_modified1;
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
   warning_set.clear();
-  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log,
+                                    &request_headers_modified1,
+                                    &request_cookies_modified1);
   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, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_FALSE(request_headers_modified1);
+  EXPECT_TRUE(request_cookies_modified1);
 }
 
 namespace {
 
 std::string GetCookieExpirationDate(int delta_secs) {
   const char* const kWeekDays[] = {
     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
   };
   const char* const kMonthNames[] = {
     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
@@ skipping 45 matching lines @@
       "\r\n";
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(
           net::HttpUtil::AssembleRawHeaders(
               base_headers_string.c_str(), base_headers_string.size())));
 
   // 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);
+  bool response_cookies_modified0;
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeCookiesInOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers0, &warning_set, &net_log);
+      deltas, base_headers.get(), &new_headers0, &warning_set, &net_log,
+      &response_cookies_modified0);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_EQ(0u, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_FALSE(response_cookies_modified0);
 
   linked_ptr<ResponseCookieModification> add_cookie =
       make_linked_ptr(new ResponseCookieModification);
   add_cookie->type = helpers::ADD;
   add_cookie->modification.reset(new helpers::ResponseCookie);
   add_cookie->modification->name.reset(new std::string("name4"));
   add_cookie->modification->value.reset(new std::string("\"value4\""));
 
   linked_ptr<ResponseCookieModification> edit_cookie =
       make_linked_ptr(new ResponseCookieModification);
@@ skipping 138 matching lines @@
       remove_cookie_3, remove_cookie_4
   };
 
   for (size_t i = 0; i < arraysize(operations); ++i) {
     linked_ptr<EventResponseDelta> delta(
         new EventResponseDelta("extid0", base::Time::FromInternalValue(i * 5)));
     delta->response_cookie_modifications.push_back(operations[i]);
     deltas.push_back(delta);
   }
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
+  bool response_cookies_modified1;
   scoped_refptr<net::HttpResponseHeaders> headers1(
       new net::HttpResponseHeaders(
           net::HttpUtil::AssembleRawHeaders(
               base_headers_string.c_str(), base_headers_string.size())));
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   warning_set.clear();
   MergeCookiesInOnHeadersReceivedResponses(
-      deltas, headers1.get(), &new_headers1, &warning_set, &net_log);
+      deltas, headers1.get(), &new_headers1, &warning_set, &net_log,
+      &response_cookies_modified1);
 
   EXPECT_TRUE(new_headers1->HasHeader("Foo"));
   size_t iter = 0;
   std::string cookie_string;
   std::set<std::string> expected_cookies;
   expected_cookies.insert("name=value; domain=google.com; secure");
   expected_cookies.insert("name2=value2; secure");
   expected_cookies.insert("name4=\"value4\"; secure");
   expected_cookies.insert(
       "lBound1=greater_1; expires=" + cookie_expiration + "; secure");
   expected_cookies.insert("lBound2=greater_2; max-age=1200; secure");
   expected_cookies.insert("lBound3=equal_2; max-age=2000; secure");
   expected_cookies.insert(
       "uBound1=smaller_1; expires=" + cookie_expiration + "; secure");
   expected_cookies.insert("uBound2=smaller_2; max-age=1200; secure");
   expected_cookies.insert("uBound3=equal_4; max-age=2000; secure");
   expected_cookies.insert("uBound4=value11; max-age=2500; secure");
   expected_cookies.insert(
       "uBound5=value12; max-age=600; expires=" + cookie_expiration+ "; secure");
   std::set<std::string> actual_cookies;
   while (new_headers1->EnumerateHeader(&iter, "Set-Cookie", &cookie_string))
     actual_cookies.insert(cookie_string);
   EXPECT_EQ(expected_cookies, actual_cookies);
   EXPECT_EQ(0u, warning_set.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_TRUE(response_cookies_modified1);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
       "Key2: Value2, Foo\r\n"
       "\r\n";
   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);
+  bool response_headers_modified0;
+  bool response_cookies_modified0;
   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(deltas, base_headers.get(), &new_headers0,
+                                  &allowed_unsafe_redirect_url0, &warning_set,
+                                  &net_log, &response_headers_modified0,
+                                  &response_cookies_modified0);
   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());
+  EXPECT_FALSE(response_headers_modified0);
+  EXPECT_FALSE(response_cookies_modified0);
 
   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();
+  bool response_headers_modified1;
+  bool response_cookies_modified1;
   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(deltas, base_headers.get(), &new_headers1,
+                                  &allowed_unsafe_redirect_url1, &warning_set,
+                                  &net_log, &response_headers_modified1,
+                                  &response_cookies_modified1);
   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());
+  EXPECT_TRUE(response_headers_modified1);
+  EXPECT_FALSE(response_cookies_modified1);
 
   // 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();
+  bool response_headers_modified2;
+  bool response_cookies_modified2;
   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(deltas, base_headers.get(), &new_headers2,
+                                  &allowed_unsafe_redirect_url2, &warning_set,
+                                  &net_log, &response_headers_modified2,
+                                  &response_cookies_modified2);
   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"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_TRUE(response_headers_modified2);
+  EXPECT_FALSE(response_cookies_modified2);
 }
 
 // Check that we do not delete too much
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnHeadersReceivedResponsesDeletion) {
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
       "Key1: Value2\r\n"
       "Key1: Value3\r\n"
       "Key2: Value4\r\n"
       "\r\n";
   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);
+  bool response_headers_modified1;
+  bool response_cookies_modified1;
   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(deltas, base_headers.get(), &new_headers1,
+                                  &allowed_unsafe_redirect_url1, &warning_set,
+                                  &net_log, &response_headers_modified1,
+                                  &response_cookies_modified1);
   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;
   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());
+  EXPECT_TRUE(response_headers_modified1);
+  EXPECT_FALSE(response_cookies_modified1);
 }
 
 // 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::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet 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);
+  bool response_headers_modified0;
+  bool response_cookies_modified0;
   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(deltas, base_headers.get(), &new_headers0,
+                                  &allowed_unsafe_redirect_url0, &warning_set,
+                                  &net_log, &response_headers_modified0,
+                                  &response_cookies_modified0);
   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());
+  EXPECT_FALSE(response_headers_modified0);
+  EXPECT_FALSE(response_cookies_modified0);
 
   // 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();
+  bool response_headers_modified1;
+  bool response_cookies_modified1;
   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(deltas, base_headers.get(), &new_headers1,
+                                  &allowed_unsafe_redirect_url1, &warning_set,
+                                  &net_log, &response_headers_modified1,
+                                  &response_cookies_modified1);
   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());
+  EXPECT_FALSE(response_headers_modified1);
+  EXPECT_FALSE(response_cookies_modified1);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   net::BoundTestNetLog capturing_net_log;
   net::NetLogWithSource net_log = capturing_net_log.bound();
   WarningSet warning_set;
   EventResponseDeltas deltas;
   base::string16 username = base::ASCIIToUTF16("foo");
   base::string16 password = base::ASCIIToUTF16("bar");
   base::string16 password2 = base::ASCIIToUTF16("baz");
@@ skipping 62 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