Remove some dead code for operating on headers-as-a-string.

net/http/http_util_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 <algorithm>
 #include <limits>
 
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 102 matching lines @@
     { "foo: 1\r\nbar: 2", "foo", true },
     { "fOO: 1\r\nbar: 2", "foo", true },
     { "g: 0\r\nfoo: 1\r\nbar: 2", "foo", true },
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     bool result = HttpUtil::HasHeader(tests[i].headers, tests[i].name);
     EXPECT_EQ(tests[i].expected_result, result);
   }
 }
 
-TEST(HttpUtilTest, StripHeaders) {
-  static const char* const headers =
-      "Origin: origin\r\n"
-      "Content-Type: text/plain\r\n"
-      "Cookies: foo1\r\n"
-      "Custom: baz\r\n"
-      "COOKIES: foo2\r\n"
-      "Server: Apache\r\n"
-      "OrIGin: origin2\r\n";
-
-  static const char* const header_names[] = {
-    "origin", "content-type", "cookies"
-  };
-
-  static const char* const expected_stripped_headers =
-      "Custom: baz\r\n"
-      "Server: Apache\r\n";
-
-  EXPECT_EQ(expected_stripped_headers,
-            HttpUtil::StripHeaders(headers, header_names,
-                                   arraysize(header_names)));
-}
-
 TEST(HttpUtilTest, HeadersIterator) {
   std::string headers = "foo: 1\t\r\nbar: hello world\r\nbaz: 3 \r\n";
 
   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 
   ASSERT_TRUE(it.GetNext());
   EXPECT_EQ(std::string("foo"), it.name());
   EXPECT_EQ(std::string("1"), it.values());
 
   ASSERT_TRUE(it.GetNext());
@@ skipping 681 matching lines @@
     std::string boundary;
     HttpUtil::ParseContentType(tests[i].content_type, &mime_type, &charset,
                                &had_charset, &boundary);
     EXPECT_EQ(tests[i].expected_mime_type, mime_type) << "i=" << i;
     EXPECT_EQ(tests[i].expected_charset, charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_had_charset, had_charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_boundary, boundary) << "i=" << i;
   }
 }
 
-TEST(HttpUtilTest, ParseRanges) {
-  const struct {
-    const char* const headers;
-    bool expected_return_value;
-    size_t expected_ranges_size;
-    const struct {
-      int64_t expected_first_byte_position;
-      int64_t expected_last_byte_position;
-      int64_t expected_suffix_length;
-    } expected_ranges[10];
-  } tests[] = {
-    { "Range: bytes=0-10",
-      true,
-      1,
-      { {0, 10, -1}, }
-    },
-    { "Range: bytes=10-0",
-      false,
-      0,
-      {}
-    },
-    { "Range: BytES=0-10",
-      true,
-      1,
-      { {0, 10, -1}, }
-    },
-    { "Range: megabytes=0-10",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes0-10",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=0-0,0-10,10-20,100-200,100-,-200",
-      true,
-      6,
-      { {0, 0, -1},
-        {0, 10, -1},
-        {10, 20, -1},
-        {100, 200, -1},
-        {100, -1, -1},
-        {-1, -1, 200},
-      }
-    },
-    { "Range: bytes=0-10\r\n"
-      "Range: bytes=0-10,10-20,100-200,100-,-200",
-      true,
-      1,
-      { {0, 10, -1}
-      }
-    },
-    { "Range: bytes=",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=-",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=0-10-",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=-0-10",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes =0-10\r\n",
-      true,
-      1,
-      { {0, 10, -1}
-      }
-    },
-    { "Range: bytes=  0-10      \r\n",
-      true,
-      1,
-      { {0, 10, -1}
-      }
-    },
-    { "Range: bytes  =   0  -   10      \r\n",
-      true,
-      1,
-      { {0, 10, -1}
-      }
-    },
-    { "Range: bytes=   0-1   0\r\n",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=   0-     -10\r\n",
-      false,
-      0,
-      {}
-    },
-    { "Range: bytes=   0  -  1   ,   10 -20,   100- 200 ,  100-,  -200 \r\n",
-      true,
-      5,
-      { {0, 1, -1},
-        {10, 20, -1},
-        {100, 200, -1},
-        {100, -1, -1},
-        {-1, -1, 200},
-      }
-    },
-  };
-
-  for (size_t i = 0; i < arraysize(tests); ++i) {
-    std::vector<HttpByteRange> ranges;
-    bool return_value = HttpUtil::ParseRanges(std::string(tests[i].headers),
-                                              &ranges);
-    EXPECT_EQ(tests[i].expected_return_value, return_value);
-    if (return_value) {
-      EXPECT_EQ(tests[i].expected_ranges_size, ranges.size());
-      for (size_t j = 0; j < ranges.size(); ++j) {
-        EXPECT_EQ(tests[i].expected_ranges[j].expected_first_byte_position,
-                  ranges[j].first_byte_position());
-        EXPECT_EQ(tests[i].expected_ranges[j].expected_last_byte_position,
-                  ranges[j].last_byte_position());
-        EXPECT_EQ(tests[i].expected_ranges[j].expected_suffix_length,
-                  ranges[j].suffix_length());
-      }
-    }
-  }
-}
-
 TEST(HttpUtilTest, ParseContentRangeHeader) {
   const struct {
     const char* const content_range_header_spec;
     bool expected_return_value;
     int64_t expected_first_byte_position;
     int64_t expected_last_byte_position;
     int64_t expected_instance_length;
   } tests[] = {
       {"", false, -1, -1, -1},
       {"megabytes 0-10/50", false, -1, -1, -1},
@@ skipping 503 matching lines @@
   EXPECT_FALSE(HttpUtil::IsLWS('a'));
   EXPECT_FALSE(HttpUtil::IsLWS('.'));
   EXPECT_FALSE(HttpUtil::IsLWS('\n'));
   EXPECT_FALSE(HttpUtil::IsLWS('\r'));
 
   EXPECT_TRUE(HttpUtil::IsLWS('\t'));
   EXPECT_TRUE(HttpUtil::IsLWS(' '));
 }
 
 }  // namespace net