Avoids the "re-encode HPACK as SPDY3" step.

net/spdy/spdy_framer.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 "net/spdy/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <ios>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
 #include "net/quic/quic_flags.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_bug_tracker.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
+#include "net/spdy/spdy_headers_block_parser.h"
 #include "third_party/zlib/zlib.h"
 
 using base::StringPiece;
 using std::hex;
 using std::string;
 using std::vector;
 
 namespace net {
 
 namespace {
@@ skipping 129 matching lines @@
     const char* rst_stream_data,
     size_t len) {
   return true;
 }
 
 SpdyFramer::SpdyFramer(SpdyMajorVersion version)
     : current_frame_buffer_(kControlFrameBufferSize),
       expect_continuation_(0),
       visitor_(NULL),
       debug_visitor_(NULL),
+      header_handler_(nullptr),
       display_protocol_("SPDY"),
       protocol_version_(version),
       enable_compression_(true),
       syn_frame_processed_(false),
       probable_http_response_(false),
       end_stream_when_done_(false) {
   DCHECK(protocol_version_ == SPDY3 || protocol_version_ == HTTP2);
   // TODO(bnc): The way kMaxControlFrameSize is currently interpreted, it
   // includes the frame header, whereas kSpdyInitialFrameSizeLimit does not.
   // Therefore this assertion is unnecessarily strict.
@@ skipping 258 matching lines @@
     case SPDY_COMPRESS_FAILURE:
       return "COMPRESS_FAILURE";
     case SPDY_INVALID_PADDING:
       return "SPDY_INVALID_PADDING";
     case SPDY_INVALID_DATA_FRAME_FLAGS:
       return "SPDY_INVALID_DATA_FRAME_FLAGS";
     case SPDY_INVALID_CONTROL_FRAME_FLAGS:
       return "SPDY_INVALID_CONTROL_FRAME_FLAGS";
     case SPDY_UNEXPECTED_FRAME:
       return "UNEXPECTED_FRAME";
+    case SPDY_INTERNAL_FRAMER_ERROR:
+      return "SPDY_INTERNAL_FRAMER_ERROR";
   }
   return "UNKNOWN_ERROR";
 }
 
 const char* SpdyFramer::StatusCodeToString(int status_code) {
   switch (status_code) {
     case RST_STREAM_INVALID:
       return "INVALID";
     case RST_STREAM_PROTOCOL_ERROR:
       return "PROTOCOL_ERROR";
@@ skipping 1141 matching lines @@
         }
         break;
       default:
 #ifndef NDEBUG
         LOG(FATAL) << "Invalid control frame type: " << current_frame_type_;
 #else
         set_error(SPDY_INVALID_CONTROL_FRAME);
         return original_len - len;
 #endif
     }
+
+    if (current_frame_type_ != CONTINUATION) {
+      header_handler_ = visitor_->OnHeaderFrameStart(current_frame_stream_id_);
+      if (header_handler_ == nullptr) {
+        SPDY_BUG << "visitor_->OnHeaderFrameStart returned nullptr";
+        set_error(SPDY_INTERNAL_FRAMER_ERROR);
+        return original_len - len;
+      }
+      if (protocol_version() == SPDY3) {
+        header_parser_.reset(
+            new SpdyHeadersBlockParser(protocol_version(), header_handler_));
+      } else {
+        GetHpackDecoder()->HandleControlFrameHeadersStart(header_handler_);
+      }
+    }
     CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
   }
   return original_len - len;
 }
 
 // Does not buffer the control payload. Instead, either passes directly to the
 // visitor or decompresses and then passes directly to the visitor, via
 // IncrementallyDeliverControlFrameHeaderData() or
 // IncrementallyDecompressControlFrameHeaderData() respectively.
 size_t SpdyFramer::ProcessControlFrameHeaderBlock(const char* data,
@@ skipping 36 matching lines @@
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_data_length_ == remaining_padding_payload_length_ &&
       processed_successfully) {
     if (expect_continuation_ == 0) {
       if (is_hpack_header_block) {
         size_t compressed_len = 0;
         if (GetHpackDecoder()->HandleControlFrameHeadersComplete(
                 &compressed_len)) {
-          // TODO(jgraettinger): To be removed with migration to
-          // SpdyHeadersHandlerInterface. Serializes the HPACK block as a SPDY3
-          // block, delivered via reentrant call to
-          // ProcessControlFrameHeaderBlock().
-          DeliverHpackBlockAsSpdy3Block(compressed_len);
-          return process_bytes;
+          visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
+          if (state_ == SPDY_ERROR) {
+            return data_len;
+          }
+        } else {
+          set_error(SPDY_DECOMPRESS_FAILURE);
+          processed_successfully = false;
         }
-        set_error(SPDY_DECOMPRESS_FAILURE);
-        processed_successfully = false;
       } else {
-        // The complete header block has been delivered. We send a zero-length
-        // OnControlFrameHeaderData() to indicate this.
-        visitor_->OnControlFrameHeaderData(current_frame_stream_id_, NULL, 0);
+        visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
+        if (state_ == SPDY_ERROR) {
+          return data_len;
+        }
       }
     }
     if (processed_successfully) {
       CHANGE_STATE(SPDY_CONSUME_PADDING);
     }
   }
 
   // Handle error.
   if (!processed_successfully) {
     return data_len;
@@ skipping 1390 matching lines @@
     }
 
     // Inflate will generate a Z_BUF_ERROR if it runs out of input
     // without producing any output.  The input is consumed and
     // buffered internally by zlib so we can detect this condition by
     // checking if avail_in is 0 after the call to inflate.
     bool input_exhausted = ((rv == Z_BUF_ERROR) && (decomp->avail_in == 0));
     if ((rv == Z_OK) || input_exhausted) {
       size_t decompressed_len = arraysize(buffer) - decomp->avail_out;
       if (decompressed_len > 0) {
-        processed_successfully = visitor_->OnControlFrameHeaderData(
+        processed_successfully = header_parser_->HandleControlFrameHeadersData(
             stream_id, buffer, decompressed_len);
+        if (header_parser_->get_error() ==
+            SpdyHeadersBlockParser::NEED_MORE_DATA) {
+          processed_successfully = true;
+        }
       }
       if (!processed_successfully) {
         // Assume that the problem was the header block was too large for the
         // visitor.
         set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
       }
     } else {
       DLOG(WARNING) << "inflate failure: " << rv << " " << len;
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   }
   return processed_successfully;
 }
 
 bool SpdyFramer::IncrementallyDeliverControlFrameHeaderData(
     SpdyStreamId stream_id, const char* data, size_t len) {
   bool read_successfully = true;
   while (read_successfully && len > 0) {
     size_t bytes_to_deliver = std::min(len, kHeaderDataChunkMaxSize);
-    read_successfully = visitor_->OnControlFrameHeaderData(stream_id, data,
-                                                           bytes_to_deliver);
+    read_successfully = header_parser_->HandleControlFrameHeadersData(
+        stream_id, data, bytes_to_deliver);
+    if (header_parser_->get_error() == SpdyHeadersBlockParser::NEED_MORE_DATA) {
+      read_successfully = true;
+    }
     data += bytes_to_deliver;
     len -= bytes_to_deliver;
     if (!read_successfully) {
       // Assume that the problem was the header block was too large for the
       // visitor.
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
 }
@@ skipping 85 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net