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

net/http/http_util.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_UTIL_H_
 #define NET_HTTP_HTTP_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 28 matching lines @@
   // output values are only modified if the content_type_str contains a mime
   // type and charset value, respectively.  The boundary output value is
   // optional and will be assigned the (quoted) value of the boundary
   // paramter, if any.
   static void ParseContentType(const std::string& content_type_str,
                                std::string* mime_type,
                                std::string* charset,
                                bool* had_charset,
                                std::string* boundary);
 
-  // Scans the headers and look for the first "Range" header in |headers|,
-  // if "Range" exists and the first one of it is well formatted then returns
-  // true, |ranges| will contain a list of valid ranges. If return
-  // value is false then values in |ranges| should not be used. The format of
-  // "Range" header is defined in RFC 7233 Section 2.1.
+  // Parses the value of a "Range" header as defined in RFC 7233 Secion 2.1.

[eroman, 2016/12/29 01:15:28]

typo: Section

[mmenke, 2016/12/29 02:14:28]

Done.

   // https://tools.ietf.org/html/rfc7233#section-2.1
-  static bool ParseRanges(const std::string& headers,
-                          std::vector<HttpByteRange>* ranges);
-
-  // Same thing as ParseRanges except the Range header is known and its value
-  // is directly passed in, rather than requiring searching through a string.
+  // Returns false on failure.
   static bool ParseRangeHeader(const std::string& range_specifier,
                                std::vector<HttpByteRange>* ranges);
 
   // Extracts the values in a Content-Range header and returns true if they are
   // valid for a 206 response; otherwise returns false.
   // The following values will be outputted:
   // |*first_byte_position| = inclusive position of the first byte of the range
   // |*last_byte_position| = inclusive position of the last byte of the range
   // |*instance_length| = size in bytes of the object requested
   // If any of the above values is unknown, its value will be -1.
@@ skipping 23 matching lines @@
   // named |name|.
   static bool IsSafeHeader(const std::string& name);
 
   // Returns true if |name| is a valid HTTP header name.
   static bool IsValidHeaderName(const base::StringPiece& name);
 
   // Returns false if |value| contains NUL or CRLF. This method does not perform
   // a fully RFC-2616-compliant header value validation.
   static bool IsValidHeaderValue(const base::StringPiece& value);
 
-  // Strips all header lines from |headers| whose name matches
-  // |headers_to_remove|. |headers_to_remove| is a list of null-terminated
-  // lower-case header names, with array length |headers_to_remove_len|.
-  // Returns the stripped header lines list, separated by "\r\n".
-  static std::string StripHeaders(const std::string& headers,
-                                  const char* const headers_to_remove[],
-                                  size_t headers_to_remove_len);
-
   // Multiple occurances of some headers cannot be coalesced into a comma-
   // separated list since their values are (or contain) unquoted HTTP-date
   // values, which may contain a comma (see RFC 2616 section 3.3.1).
   static bool IsNonCoalescingHeader(std::string::const_iterator name_begin,
                                     std::string::const_iterator name_end);
   static bool IsNonCoalescingHeader(const std::string& name) {
     return IsNonCoalescingHeader(name.begin(), name.end());
   }
 
   // Return true if the character is HTTP "linear white space" (SP | HT).
@@ skipping 333 matching lines @@
     // True if quotes values are required to be properly quoted; false if
     // mismatched quotes and other problems with quoted values should be more
     // or less gracefully treated as valid.
     bool strict_quotes_;
   };
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_UTIL_H_