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

net/spdy/spdy_framer.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_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/strings/string_piece.h"
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
 #include "net/spdy/hpack/hpack_decoder.h"
 #include "net/spdy/hpack/hpack_encoder.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_header_block.h"
+#include "net/spdy/spdy_headers_block_parser.h"
 #include "net/spdy/spdy_protocol.h"
 
 typedef struct z_stream_s z_stream;  // Forward declaration for zlib.
 
 namespace net {
 
 class HttpProxyClientSocketPoolTest;
 class HttpNetworkLayer;
 class HttpNetworkTransactionTest;
 class SpdyHttpStreamTest;
@@ skipping 87 matching lines @@
   virtual void OnStreamEnd(SpdyStreamId stream_id) = 0;
 
   // Called when padding is received (padding length field or padding octets).
   // |stream_id| The stream receiving data.
   // |len| The number of padding octets.
   virtual void OnStreamPadding(SpdyStreamId stream_id, size_t len) = 0;
 
   // Called just before processing the payload of a frame containing header
   // data. Should return an implementation of SpdyHeadersHandlerInterface that
   // will receive headers for stream |stream_id|. The caller will not take
-  // ownership of the headers handler. The same instance should be returned
-  // for all header frames comprising a logical header block (i.e. until
-  // OnHeaderFrameEnd() is called with end_headers == true).
+  // ownership of the headers handler. The same instance should remain live
+  // and be returned for all header frames comprising a logical header block
+  // (i.e. until OnHeaderFrameEnd() is called with end_headers == true).
   virtual SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) = 0;
 
   // Called after processing the payload of a frame containing header data.
   // |end_headers| is true if there will not be any subsequent CONTINUATION
   // frames.
   virtual void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) = 0;
 
   // Called when a chunk of header data is available. This is called
   // after OnSynStream, OnSynReply, OnHeaders(), or OnPushPromise.
@@ skipping 188 matching lines @@
     SPDY_ZLIB_INIT_FAILURE,            // The Zlib library could not initialize.
     SPDY_UNSUPPORTED_VERSION,          // Control frame has unsupported version.
     SPDY_DECOMPRESS_FAILURE,           // There was an error decompressing.
     SPDY_COMPRESS_FAILURE,             // There was an error compressing.
     SPDY_GOAWAY_FRAME_CORRUPT,         // GOAWAY frame could not be parsed.
     SPDY_RST_STREAM_FRAME_CORRUPT,     // RST_STREAM frame could not be parsed.
     SPDY_INVALID_PADDING,              // HEADERS or DATA frame padding invalid
     SPDY_INVALID_DATA_FRAME_FLAGS,     // Data frame has invalid flags.
     SPDY_INVALID_CONTROL_FRAME_FLAGS,  // Control frame has invalid flags.
     SPDY_UNEXPECTED_FRAME,             // Frame received out of order.
+    SPDY_INTERNAL_FRAMER_ERROR,        // SpdyFramer was used incorrectly.
     SPDY_INVALID_CONTROL_FRAME_SIZE,   // Control frame not sized to spec
 
     LAST_ERROR,  // Must be the last entry in the enum.
   };
 
   // Constant for invalid (or unknown) stream IDs.
   static const SpdyStreamId kInvalidStream;
 
   // The maximum size of header data chunks delivered to the framer visitor
   // through OnControlFrameHeaderData. (It is exposed here for unit test
@@ skipping 210 matching lines @@
       const char* data,
       size_t len);
 
   // Updates the maximum size of the header encoder compression table.
   void UpdateHeaderEncoderTableSize(uint32_t value);
 
   // Returns the maximum size of the header encoder compression table.
   size_t header_encoder_table_size() const;
 
  protected:
+  friend class BufferedSpdyFramer;
   friend class HttpNetworkLayer;  // This is temporary for the server.
   friend class HttpNetworkTransactionTest;
   friend class HttpProxyClientSocketPoolTest;
   friend class SpdyHttpStreamTest;
   friend class SpdyNetworkTransactionTest;
   friend class SpdyProxyClientSocketTest;
   friend class SpdySessionTest;
   friend class SpdyStreamTest;
   friend class test::TestSpdyVisitor;
   friend class test::SpdyFramerPeer;
@@ skipping 179 matching lines @@
   // SPDY header compressors.
   std::unique_ptr<z_stream> header_compressor_;
   std::unique_ptr<z_stream> header_decompressor_;
 
   std::unique_ptr<HpackEncoder> hpack_encoder_;
   std::unique_ptr<HpackDecoder> hpack_decoder_;
 
   SpdyFramerVisitorInterface* visitor_;
   SpdyFramerDebugVisitorInterface* debug_visitor_;
 
+  std::unique_ptr<SpdyHeadersBlockParser> header_parser_;
+  SpdyHeadersHandlerInterface* header_handler_;
+
   std::string display_protocol_;
 
   // The protocol version to be spoken/understood by this framer.
   const SpdyMajorVersion protocol_version_;
 
   // The flags field of the frame currently being read.
   uint8_t current_frame_flags_;
 
   // Determines whether HPACK or gzip compression is used.
   bool enable_compression_;
@@ skipping 20 matching lines @@
   bool end_stream_when_done_;
 
   // If true, then ProcessInput returns after processing a full frame,
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_