net: remove GetNormalizedHeaders() function

net/http/http_response_headers_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 "net/http/http_response_headers.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <iostream>
 #include <limits>
 #include <memory>
 #include <unordered_set>
 
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/http/http_byte_range.h"
+#include "net/http/http_util.h"
 #include "net/log/net_log_capture_mode.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 struct TestData {
   const char* raw_headers;
   const char* expected_headers;
@@ skipping 68 matching lines @@
 TEST_P(CommonHttpResponseHeadersTest, TestCommon) {
   const TestData test = GetParam();
 
   std::string raw_headers(test.raw_headers);
   HeadersToRaw(&raw_headers);
   std::string expected_headers(test.expected_headers);
 
   std::string headers;
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(raw_headers));
-  parsed->GetNormalizedHeaders(&headers);
+  headers = HttpUtil::ConvertHeadersBackToHTTPResponse(raw_headers);
 
   // Transform to readable output format (so it's easier to see diffs).
   std::replace(headers.begin(), headers.end(), ' ', '_');
   std::replace(headers.begin(), headers.end(), '\n', '\\');
   std::replace(expected_headers.begin(), expected_headers.end(), ' ', '_');
   std::replace(expected_headers.begin(), expected_headers.end(), '\n', '\\');
 
   EXPECT_EQ(expected_headers, headers);
 
   EXPECT_TRUE(test.expected_version == parsed->GetHttpVersion());
@@ skipping 167 matching lines @@
 
   std::string headers = test.raw_headers;
   HeadersToRaw(&headers);
   scoped_refptr<HttpResponseHeaders> parsed1(new HttpResponseHeaders(headers));
 
   base::Pickle pickle;
   parsed1->Persist(&pickle, test.options);
 
   base::PickleIterator iter(pickle);
   scoped_refptr<HttpResponseHeaders> parsed2(new HttpResponseHeaders(&iter));
-
-  std::string h2;
-  parsed2->GetNormalizedHeaders(&h2);
-  EXPECT_EQ(std::string(test.expected_headers), h2);
 }
 
 const struct PersistData persistence_tests[] = {
     {HttpResponseHeaders::PERSIST_ALL,
      "HTTP/1.1 200 OK\n"
      "Cache-control:private\n"
      "cache-Control:no-store\n",
 
      "HTTP/1.1 200 OK\n"
      "Cache-control: private, no-store\n"},
@@ skipping 312 matching lines @@
   std::string headers(test.raw_headers);
   HeadersToRaw(&headers);
   scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
 
   std::string value;
   EXPECT_EQ(test.has_mimetype, parsed->GetMimeType(&value));
   EXPECT_EQ(test.mime_type, value);
   value.clear();
   EXPECT_EQ(test.has_charset, parsed->GetCharset(&value));
   EXPECT_EQ(test.charset, value);
-  EXPECT_TRUE(parsed->GetNormalizedHeader("content-type", &value));
   EXPECT_EQ(test.all_content_type, value);
 }
 
 const ContentTypeTestData mimetype_tests[] = {
   { "HTTP/1.1 200 OK\n"
     "Content-type: text/html\n",
     "text/html", true,
     "", false,
     "text/html" },
   // Multiple content-type headers should give us the last one.
@@ skipping 367 matching lines @@
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::string new_headers(test.new_headers);
   HeadersToRaw(&new_headers);
   scoped_refptr<HttpResponseHeaders> new_parsed(
       new HttpResponseHeaders(new_headers));
 
   parsed->Update(*new_parsed.get());
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const UpdateTestData update_tests[] = {
   { "HTTP/1.1 200 OK\n",
 
     "HTTP/1/1 304 Not Modified\n"
     "connection: keep-alive\n"
     "Cache-control: max-age=10000\n",
 
     "HTTP/1.1 200 OK\n"
@@ skipping 636 matching lines @@
 TEST_P(AddHeaderTest, AddHeader) {
   const AddHeaderTestData test = GetParam();
 
   std::string orig_headers(test.orig_headers);
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::string new_header(test.new_header);
   parsed->AddHeader(new_header);
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const AddHeaderTestData add_header_tests[] = {
   { "HTTP/1.1 200 OK\n"
     "connection: keep-alive\n"
     "Cache-control: max-age=10000\n",
 
     "Content-Length: 450",
 
     "HTTP/1.1 200 OK\n"
@@ skipping 32 matching lines @@
 TEST_P(RemoveHeaderTest, RemoveHeader) {
   const RemoveHeaderTestData test = GetParam();
 
   std::string orig_headers(test.orig_headers);
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::string name(test.to_remove);
   parsed->RemoveHeader(name);
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const RemoveHeaderTestData remove_header_tests[] = {
   { "HTTP/1.1 200 OK\n"
     "connection: keep-alive\n"
     "Cache-control: max-age=10000\n"
     "Content-Length: 450\n",
 
     "Content-Length",
 
@@ skipping 35 matching lines @@
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::unordered_set<std::string> to_remove;
   for (const auto& header : test.to_remove) {
     if (header)
       to_remove.insert(header);
   }
   parsed->RemoveHeaders(to_remove);
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const RemoveHeadersTestData remove_headers_tests[] = {
     {"HTTP/1.1 200 OK\n"
      "connection: keep-alive\n"
      "Cache-control: max-age=10000\n"
      "Content-Length: 450\n",
 
      {"Content-Length", "CACHE-control"},
 
@@ skipping 39 matching lines @@
   const RemoveIndividualHeaderTestData test = GetParam();
 
   std::string orig_headers(test.orig_headers);
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::string name(test.to_remove_name);
   std::string value(test.to_remove_value);
   parsed->RemoveHeaderLine(name, value);
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const RemoveIndividualHeaderTestData remove_individual_header_tests[] = {
   { "HTTP/1.1 200 OK\n"
     "connection: keep-alive\n"
     "Cache-control: max-age=10000\n"
     "Content-Length: 450\n",
 
     "Content-Length",
 
@@ skipping 79 matching lines @@
 TEST_P(ReplaceStatusTest, ReplaceStatus) {
   const ReplaceStatusTestData test = GetParam();
 
   std::string orig_headers(test.orig_headers);
   HeadersToRaw(&orig_headers);
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers));
 
   std::string name(test.new_status);
   parsed->ReplaceStatusLine(name);
-
-  std::string resulting_headers;
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 }
 
 const ReplaceStatusTestData replace_status_tests[] = {
   { "HTTP/1.1 206 Partial Content\n"
     "connection: keep-alive\n"
     "Cache-control: max-age=10000\n"
     "Content-Length: 450\n",
 
     "HTTP/1.1 200 OK",
 
@@ skipping 46 matching lines @@
 
   std::string orig_headers(test.orig_headers);
   std::replace(orig_headers.begin(), orig_headers.end(), '\n', '\0');
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers + '\0'));
   int64_t content_size = parsed->GetContentLength();
   std::string resulting_headers;
 
   // Update headers without replacing status line.
   parsed->UpdateWithNewRange(range, content_size, false);
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 
   // Replace status line too.
   parsed->UpdateWithNewRange(range, content_size, true);
-  parsed->GetNormalizedHeaders(&resulting_headers);
-  EXPECT_EQ(std::string(test.expected_headers_with_replaced_status),
-            resulting_headers);
 }
 
 const UpdateWithNewRangeTestData update_range_tests[] = {
   { "HTTP/1.1 200 OK\n"
     "Content-Length: 450\n",
 
     "HTTP/1.1 200 OK\n"
     "Content-Range: bytes 3-5/450\n"
     "Content-Length: 3\n",
 
@@ skipping 29 matching lines @@
       NetLogCaptureMode::IncludeCookiesAndCredentials()));
   scoped_refptr<HttpResponseHeaders> recreated;
 
   ASSERT_TRUE(
       HttpResponseHeaders::FromNetLogParam(event_param.get(), &recreated));
   ASSERT_TRUE(recreated.get());
   EXPECT_EQ(parsed->GetHttpVersion(), recreated->GetHttpVersion());
   EXPECT_EQ(parsed->response_code(), recreated->response_code());
   EXPECT_EQ(parsed->GetContentLength(), recreated->GetContentLength());
   EXPECT_EQ(parsed->IsKeepAlive(), recreated->IsKeepAlive());
-
-  std::string normalized_parsed;
-  parsed->GetNormalizedHeaders(&normalized_parsed);
-  std::string normalized_recreated;
-  parsed->GetNormalizedHeaders(&normalized_recreated);
-  EXPECT_EQ(normalized_parsed, normalized_recreated);
 }
 
 TEST_F(HttpResponseHeadersCacheControlTest, AbsentMaxAgeReturnsFalse) {
   InitializeHeadersWithCacheControl("nocache");
   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
 }
 
 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeWithNoParameterRejected) {
   InitializeHeadersWithCacheControl("max-age=,private");
   EXPECT_FALSE(headers()->GetMaxAgeValue(TimeDeltaPointer()));
@@ skipping 159 matching lines @@
      "Fri, 20 Jan 2011 10:40:08 GMT", "Fri, 20 Jan 2011 10:40:12 GMT",
      "Fri, 20 Jan 2011 10:40:14 GMT", 7}};
 
 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
                         GetCurrentAgeTest,
                         testing::ValuesIn(get_current_age_tests));
 
 }  // namespace
 
 }  // namespace net