Update from https://crrev.com/312600

net/spdy/spdy_headers_block_parser.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/spdy_headers_block_parser.h"
 
 #include "base/sys_byteorder.h"
 
 namespace net {
+namespace {
+
+// 0 is invalid according to both the SPDY 3.1 and HTTP/2 specifications.
+const SpdyStreamId kInvalidStreamId = 0;
+
+}  // anonymous namespace
 
 const size_t SpdyHeadersBlockParser::kMaximumFieldLength = 16 * 1024;
 
 SpdyHeadersBlockParser::SpdyHeadersBlockParser(
     SpdyMajorVersion spdy_version,
     SpdyHeadersHandlerInterface* handler)
     : state_(READING_HEADER_BLOCK_LEN),
       length_field_size_(LengthFieldSizeForVersion(spdy_version)),
       max_headers_in_block_(MaxNumberOfHeadersForVersion(spdy_version)),
       total_bytes_received_(0),
       remaining_key_value_pairs_for_frame_(0),
       handler_(handler),
+      stream_id_(kInvalidStreamId),
       error_(OK),
       spdy_version_(spdy_version) {
   // The handler that we set must not be NULL.
   DCHECK(handler_ != NULL);
 }
 
 SpdyHeadersBlockParser::~SpdyHeadersBlockParser() {}
 
 bool SpdyHeadersBlockParser::HandleControlFrameHeadersData(
     SpdyStreamId stream_id,
     const char* headers_data,
     size_t headers_data_length) {
   if (error_ == NEED_MORE_DATA) {
     error_ = OK;
   }
-  CHECK_EQ(error_, OK);
+  if (error_ != OK) {
+    LOG(DFATAL) << "Unexpected error: " << error_;
+    return false;
+  }
 
   // If this is the first call with the current header block,
   // save its stream id.
-  if (state_ == READING_HEADER_BLOCK_LEN) {
+  if (state_ == READING_HEADER_BLOCK_LEN && stream_id_ == kInvalidStreamId) {
     stream_id_ = stream_id;
   }
-  CHECK_EQ(stream_id_, stream_id);
-
+  if (stream_id != stream_id_) {
+    LOG(DFATAL) << "Unexpected stream id: " << stream_id << " (expected "
+                << stream_id_ << ")";
+    error_ = UNEXPECTED_STREAM_ID;
+    return false;
+  }
+  if (stream_id_ == kInvalidStreamId) {
+    LOG(DFATAL) << "Expected nonzero stream id, saw: " << stream_id_;
+    error_ = UNEXPECTED_STREAM_ID;
+    return false;
+  }
   total_bytes_received_ += headers_data_length;
 
   SpdyPinnableBufferPiece prefix, key, value;
   // Simultaneously tie lifetimes to the stack, and clear member variables.
   prefix.Swap(&headers_block_prefix_);
   key.Swap(&key_);
 
   // Apply the parsing state machine to the remaining prefix
   // from last invocation, plus newly-available headers data.
   Reader reader(prefix.buffer(), prefix.length(),
@@ skipping 18 matching lines @@
         break;
       case READING_VALUE_LEN:
         next_state = READING_VALUE;
         ParseFieldLength(&reader);
         break;
       case READING_VALUE:
         next_state = FINISHED_HEADER;
         if (!reader.ReadN(next_field_length_, &value)) {
           error_ = NEED_MORE_DATA;
         } else {
-          handler_->OnHeader(stream_id, key, value);
+          handler_->OnHeader(key, value);
         }
         break;
       case FINISHED_HEADER:
         // Prepare for next header or block.
         if (--remaining_key_value_pairs_for_frame_ > 0) {
           next_state = READING_KEY_LEN;
         } else {
           next_state = READING_HEADER_BLOCK_LEN;
-          handler_->OnHeaderBlockEnd(stream_id, total_bytes_received_);
+          handler_->OnHeaderBlockEnd(total_bytes_received_);
+          stream_id_ = kInvalidStreamId;
           // Expect to have consumed all buffer.
           if (reader.Available() != 0) {
             error_ = TOO_MUCH_DATA;
           }
         }
         break;
-      default:
-        CHECK(false) << "Not reached.";
     }
 
     if (error_ == OK) {
       state_ = next_state;
 
       if (next_state == READING_HEADER_BLOCK_LEN) {
         // We completed reading a full header block. Return to caller.
         total_bytes_received_ = 0;
         break;
       }
@@ skipping 11 matching lines @@
   return error_ == OK;
 }
 
 void SpdyHeadersBlockParser::ParseBlockLength(Reader* reader) {
   ParseLength(reader, &remaining_key_value_pairs_for_frame_);
   if (error_ == OK &&
     remaining_key_value_pairs_for_frame_ > max_headers_in_block_) {
     error_ = HEADER_BLOCK_TOO_LARGE;
   }
   if (error_ == OK) {
-    handler_->OnHeaderBlock(stream_id_, remaining_key_value_pairs_for_frame_);
+    handler_->OnHeaderBlock(remaining_key_value_pairs_for_frame_);
   }
 }
 
 void SpdyHeadersBlockParser::ParseFieldLength(Reader* reader) {
   ParseLength(reader, &next_field_length_);
   if (error_ == OK &&
       next_field_length_ > kMaximumFieldLength) {
     error_ = HEADER_FIELD_TOO_LARGE;
   }
 }
@@ skipping 26 matching lines @@
   // Account for the length of the header block field.
   size_t max_bytes_for_headers =
       kMaximumFieldLength - LengthFieldSizeForVersion(spdy_version);
 
   // A minimal size header is twice the length field size (and has a
   // zero-lengthed key and a zero-lengthed value).
   return max_bytes_for_headers / (2 * LengthFieldSizeForVersion(spdy_version));
 }
 
 }  // namespace net