Fix removal of headers

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 <queue>
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 910 matching lines @@
   ASSERT_TRUE(
       delta_modified2->modified_request_headers.GetHeader("key2", &value));
   EXPECT_EQ("value3", value);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
   const bool cancel = true;
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
-      "Key2: Value2\r\n"
+      "Key2: Value2, Bar\r\n"
       "Key3: Value3\r\n"
       "\r\n";
   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
 
   scoped_ptr<EventResponseDelta> delta(
       CalculateOnHeadersReceivedDelta("extid", base::Time::Now(), cancel,
           base_headers, &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")));
+                        ResponseHeader("Key2", "Value2, Bar")));
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
                         ResponseHeader("Key3", "Value3")));
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
   const bool cancel = true;
 
   string16 username = ASCIIToUTF16("foo");
   string16 password = ASCIIToUTF16("bar");
   scoped_ptr<net::AuthCredentials> credentials(
@@ skipping 314 matching lines @@
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   std::set<std::string> conflicting_extensions;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
-      "Key2: Value2\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);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeOnHeadersReceivedResponses(
         deltas, base_headers.get(), &new_headers0, &conflicting_extensions,
         &net_log);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_EQ(0u, conflicting_extensions.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"));
+  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);
   conflicting_extensions.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeOnHeadersReceivedResponses(
         deltas, base_headers.get(), &new_headers1, &conflicting_extensions,
         &net_log);
   ASSERT_TRUE(new_headers1.get());
   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, conflicting_extensions.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"));
+  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);
   conflicting_extensions.clear();
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers2;
   MergeOnHeadersReceivedResponses(
         deltas, base_headers.get(), &new_headers2, &conflicting_extensions,
         &net_log);
   ASSERT_TRUE(new_headers2.get());
@@ skipping 171 matching lines @@
   // Check that requests are rejected if their first party url is sensitive.
   ASSERT_GE(arraysize(non_sensitive_urls), 1u);
   GURL non_sensitive_url(non_sensitive_urls[0]);
   for (size_t i = 0; i < arraysize(sensitive_urls); ++i) {
     TestURLRequest request(non_sensitive_url, NULL, &context);
     GURL sensitive_url(sensitive_urls[i]);
     request.set_first_party_for_cookies(sensitive_url);
     EXPECT_TRUE(helpers::HideRequest(&request)) << sensitive_urls[i];
   }
 }