Delete QUIC/SPDY utility methods for parsing headers/trailers.

net/quic/core/spdy_utils.cc

 // Copyright (c) 2013 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/quic/core/spdy_utils.h"
 
 #include <memory>
 #include <vector>
 
 #include "net/quic/platform/api/quic_logging.h"
@@ skipping 14 matching lines @@
 string SpdyUtils::SerializeUncompressedHeaders(const SpdyHeaderBlock& headers) {
   size_t length = SpdyFramer::GetSerializedLength(&headers);
   SpdyFrameBuilder builder(length);
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
   framer.SerializeHeaderBlockWithoutCompression(&builder, headers);
   SpdySerializedFrame block(builder.take());
   return string(block.data(), length);
 }
 
 // static
-bool SpdyUtils::ParseHeaders(const char* data,
-                             uint32_t data_len,
-                             int64_t* content_length,
-                             SpdyHeaderBlock* headers) {
-  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
-  if (!framer.ParseHeaderBlockInBuffer(data, data_len, headers) ||
-      headers->empty()) {
-    return false;  // Headers were invalid.
-  }
-
-  if (!QuicContainsKey(*headers, "content-length")) {
-    return true;
-  }
-
-  return ExtractContentLengthFromHeaders(content_length, headers);
-}
-
-// static
 bool SpdyUtils::ExtractContentLengthFromHeaders(int64_t* content_length,
                                                 SpdyHeaderBlock* headers) {
   auto it = headers->find("content-length");
   if (it == headers->end()) {
     return false;
   } else {
     // Check whether multiple values are consistent.
     QuicStringPiece content_length_header = it->second;
     std::vector<QuicStringPiece> values =
         QuicTextUtils::Split(content_length_header, '\0');
@@ skipping 13 matching lines @@
             << "Parsed content length " << new_value << " is "
             << "inconsistent with previously detected content length "
             << *content_length;
         return false;
       }
     }
     return true;
   }
 }
 
-// static
-bool SpdyUtils::ParseTrailers(const char* data,
-                              uint32_t data_len,
-                              size_t* final_byte_offset,
-                              SpdyHeaderBlock* trailers) {
-  SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
-  if (!framer.ParseHeaderBlockInBuffer(data, data_len, trailers) ||
-      trailers->empty()) {
-    QUIC_DVLOG(1) << "Request Trailers are invalid.";
-    return false;  // Trailers were invalid.
-  }
-
-  // Pull out the final offset pseudo header which indicates the number of
-  // response body bytes expected.
-  auto it = trailers->find(kFinalOffsetHeaderKey);
-  if (it == trailers->end() ||
-      !QuicTextUtils::StringToSizeT(it->second, final_byte_offset)) {
-    QUIC_DLOG(ERROR) << "Required key '" << kFinalOffsetHeaderKey
-                     << "' not present";
-    return false;
-  }
-  // The final offset header is no longer needed.
-  trailers->erase(it->first);
-
-  // Trailers must not have empty keys, and must not contain pseudo headers.
-  for (const auto& trailer : *trailers) {
-    QuicStringPiece key = trailer.first;
-    QuicStringPiece value = trailer.second;
-    if (QuicTextUtils::StartsWith(key, ":")) {
-      QUIC_DVLOG(1) << "Trailers must not contain pseudo-header: '" << key
-                    << "','" << value << "'.";
-      return false;
-    }
-
-    // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
-  }
-
-  QUIC_DVLOG(1) << "Successfully parsed Trailers: " << trailers->DebugString();
-  return true;
-}
-
 bool SpdyUtils::CopyAndValidateHeaders(const QuicHeaderList& header_list,
                                        int64_t* content_length,
                                        SpdyHeaderBlock* headers) {
   for (const auto& p : header_list) {
     const string& name = p.first;
     if (name.empty()) {
       QUIC_DLOG(ERROR) << "Header name must not be empty.";
       return false;
     }
 
@@ skipping 116 matching lines @@
     (*headers)[":authority"] = url.substr(start);
     (*headers)[":path"] = "/";
     return true;
   }
   (*headers)[":authority"] = url.substr(start, pos - start);
   (*headers)[":path"] = url.substr(pos);
   return true;
 }
 
 }  // namespace net