Move header-ordering validation from hpack decoder to header validator.

net/spdy/hpack/hpack_decoder.cc

 // Copyright 2014 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/spdy/hpack/hpack_decoder.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
 
 namespace net {
 
 using base::StringPiece;
 using std::string;
 
 namespace {
 
 const char kCookieKey[] = "cookie";
 
 }  // namespace
 
 HpackDecoder::HpackDecoder()
     : max_string_literal_size_(kDefaultMaxStringLiteralSize),
       handler_(nullptr),
       total_header_bytes_(0),
-      regular_header_seen_(false),
       header_block_started_(false),
       total_parsed_bytes_(0) {}
 
 HpackDecoder::~HpackDecoder() {}
 
 bool HpackDecoder::HandleControlFrameHeadersData(const char* headers_data,
                                                  size_t headers_data_length) {
   if (!header_block_started_) {
     decoded_block_.clear();
     if (handler_ != nullptr) {
@@ skipping 29 matching lines @@
   }
   uint32_t parsed_bytes = input_stream.ParsedBytes();
   DCHECK_GE(headers_block_buffer_.size(), parsed_bytes);
   headers_block_buffer_.erase(0, parsed_bytes);
   total_parsed_bytes_ += parsed_bytes;
   header_block_started_ = true;
   return true;
 }
 
 bool HpackDecoder::HandleControlFrameHeadersComplete(size_t* compressed_len) {
-  regular_header_seen_ = false;
-
   if (compressed_len != nullptr) {
     *compressed_len = total_parsed_bytes_;
   }
 
   // Data in headers_block_buffer_ should have been parsed by
   // HandleControlFrameHeadersData and removed.
   if (headers_block_buffer_.size() > 0) {
     return false;
   }
 
   if (handler_ != nullptr) {
     handler_->OnHeaderBlockEnd(total_header_bytes_);
   }
   headers_block_buffer_.clear();
   total_parsed_bytes_ = 0;
   header_block_started_ = false;
   handler_ = nullptr;
   return true;
 }
 
 bool HpackDecoder::HandleHeaderRepresentation(StringPiece name,
                                               StringPiece value) {
   total_header_bytes_ += name.size() + value.size();
 
-  // Fail if pseudo-header follows regular header.
-  if (name.size() > 0) {
-    if (name[0] == kPseudoHeaderPrefix) {
-      if (regular_header_seen_) {
-        return false;
-      }
-    } else {
-      regular_header_seen_ = true;
-    }
-  }
-
   if (handler_ == nullptr) {
     auto it = decoded_block_.find(name);
     if (it == decoded_block_.end()) {
       // This is a new key.
       decoded_block_[name] = value;
     } else {
       // The key already exists, append |value| with appropriate delimiter.
       string new_value = it->second.as_string();
       new_value.append((name == kCookieKey) ? "; " : string(1, '\0'));
       value.AppendToString(&new_value);
@@ skipping 150 matching lines @@
     *output = StringPiece(*buffer);
     return result;
   }
   if (input_stream->MatchPrefixAndConsume(kStringLiteralIdentityEncoded)) {
     return input_stream->DecodeNextIdentityString(output);
   }
   return false;
 }
 
 }  // namespace net