Land recent SPDY changes (through 66310528)

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 "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 105 matching lines @@
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
     const char* rst_stream_data,
     size_t len) {
   return true;
 }
 
 SpdyFramer::SpdyFramer(SpdyMajorVersion version)
     : current_frame_buffer_(new char[kControlFrameBufferSize]),
       enable_compression_(true),
-      hpack_encoder_(ObtainHpackHuffmanTable()),
-      hpack_decoder_(ObtainHpackHuffmanTable()),
       visitor_(NULL),
       debug_visitor_(NULL),
       display_protocol_("SPDY"),
       spdy_version_(version),
       syn_frame_processed_(false),
       probable_http_response_(false),
       expect_continuation_(0),
       end_stream_when_done_(false) {
   DCHECK_GE(spdy_version_, SPDY_MIN_VERSION);
   DCHECK_LE(spdy_version_, SPDY_MAX_VERSION);
   Reset();
+
+  // SPDY4 and up use HPACK. Allocate instances for these protocol versions.
+  if (spdy_version_ > SPDY3) {
+    hpack_encoder_.reset(new HpackEncoder(ObtainHpackHuffmanTable()));
+    hpack_decoder_.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
+  }
 }
 
 SpdyFramer::~SpdyFramer() {
   if (header_compressor_.get()) {
     deflateEnd(header_compressor_.get());
   }
   if (header_decompressor_.get()) {
     inflateEnd(header_decompressor_.get());
   }
 }
@@ skipping 1321 matching lines @@
   bool processed_successfully = true;
   if (current_frame_type_ != SYN_STREAM &&
       current_frame_type_ != SYN_REPLY &&
       current_frame_type_ != HEADERS &&
       current_frame_type_ != PUSH_PROMISE &&
       current_frame_type_ != CONTINUATION) {
     LOG(DFATAL) << "Unhandled frame type in ProcessControlFrameHeaderBlock.";
   }
   size_t process_bytes = std::min(data_len, remaining_data_length_);
   if (is_hpack_header_block) {
-    if (!hpack_decoder_.HandleControlFrameHeadersData(current_frame_stream_id_,
-                                                      data,
-                                                      process_bytes)) {
+    if (!hpack_decoder_->HandleControlFrameHeadersData(current_frame_stream_id_,
+                                                       data,
+                                                       process_bytes)) {
       // TODO(jgraettinger): Finer-grained HPACK error codes.
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   } else if (process_bytes > 0) {
     if (enable_compression_ && protocol_version() <= SPDY3) {
       processed_successfully = IncrementallyDecompressControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     } else {
       processed_successfully = IncrementallyDeliverControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     }
   }
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_data_length_ == 0 && processed_successfully) {
     if (expect_continuation_ == 0) {
       if (is_hpack_header_block) {
-        if (!hpack_decoder_.HandleControlFrameHeadersComplete(
+        if (!hpack_decoder_->HandleControlFrameHeadersComplete(
             current_frame_stream_id_)) {
           set_error(SPDY_DECOMPRESS_FAILURE);
           processed_successfully = false;
         } else {
           // TODO(jgraettinger): To be removed with migration to
           // SpdyHeadersHandlerInterface. Serializes the HPACK block as a SPDY3
           // block, delivered via reentrant call to
           // ProcessControlFrameHeaderBlock().
           DeliverHpackBlockAsSpdy3Block();
           return process_bytes;
@@ skipping 75 matching lines @@
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
 
   return processed_bytes;
 }
 
 void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
   DCHECK_LT(SPDY3, protocol_version());
   DCHECK_EQ(0u, remaining_data_length_);
 
-  const SpdyNameValueBlock& block = hpack_decoder_.decoded_block();
+  const SpdyNameValueBlock& block = hpack_decoder_->decoded_block();
   if (block.empty()) {
     // Special-case this to make tests happy.
     ProcessControlFrameHeaderBlock(NULL, 0, false);
     return;
   }
   SpdyFrameBuilder builder(
       GetSerializedLength(protocol_version(), &block),
       SPDY3);
 
   SerializeNameValueBlockWithoutCompression(&builder, block);
@@ skipping 528 matching lines @@
     DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynStreamMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
+      hpack_encoder_->EncodeHeaderSet(
           syn_stream.name_value_block(), &hpack_encoding);
     } else {
-      hpack_encoder_.EncodeHeaderSetWithoutCompression(
+      hpack_encoder_->EncodeHeaderSetWithoutCompression(
           syn_stream.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_stream.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
@@ skipping 41 matching lines @@
   if (protocol_version() > SPDY3) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynReplyMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
+      hpack_encoder_->EncodeHeaderSet(
           syn_reply.name_value_block(), &hpack_encoding);
     } else {
-      hpack_encoder_.EncodeHeaderSetWithoutCompression(
+      hpack_encoder_->EncodeHeaderSetWithoutCompression(
           syn_reply.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_reply.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
@@ skipping 174 matching lines @@
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     const SpdyHeadersIR& headers) {
   uint8 flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (protocol_version() > SPDY3) {
-    // TODO(mlavan): If we overflow into a CONTINUATION frame, this will
-    // get overwritten below, so we should probably just get rid of the
-    // end_headers field.
-    if (headers.end_headers()) {
-      flags |= HEADERS_FLAG_END_HEADERS;
-    }
+    // This will get overwritten if we overflow into a CONTINUATION frame.
+    flags |= HEADERS_FLAG_END_HEADERS;
     if (headers.has_priority()) {
       flags |= HEADERS_FLAG_PRIORITY;
     }
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetHeadersMinimumSize();
 
   uint32 priority = headers.priority();
   if (headers.has_priority()) {
     if (priority > GetLowestPriority()) {
       DLOG(DFATAL) << "Priority out-of-bounds.";
       priority = GetLowestPriority();
     }
     size += 4;
   }
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
+      hpack_encoder_->EncodeHeaderSet(
           headers.name_value_block(), &hpack_encoding);
     } else {
-      hpack_encoder_.EncodeHeaderSetWithoutCompression(
+      hpack_encoder_->EncodeHeaderSetWithoutCompression(
           headers.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
     if (size > GetControlFrameBufferMaxSize()) {
       size += GetNumberRequiredContinuationFrames(size) *
               GetContinuationMinimumSize();
       flags &= ~HEADERS_FLAG_END_HEADERS;
     }
   } else {
     size += GetSerializedLength(headers.name_value_block());
@@ skipping 61 matching lines @@
   DCHECK_LT(SPDY3, protocol_version());
   SpdyFrameBuilder builder(GetBlockedSize(), protocol_version());
   builder.BeginNewFrame(*this, BLOCKED, kNoFlags, blocked.stream_id());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   DCHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
-  // TODO(mlavan): If we overflow into a CONTINUATION frame, this will
-  // get overwritten below, so we should probably just get rid of the
-  // end_push_promise field.
-  if (push_promise.end_push_promise()) {
-    flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
-  }
+  // This will get overwritten if we overflow into a CONTINUATION frame.
+  flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
+      hpack_encoder_->EncodeHeaderSet(
           push_promise.name_value_block(), &hpack_encoding);
     } else {
-      hpack_encoder_.EncodeHeaderSetWithoutCompression(
+      hpack_encoder_->EncodeHeaderSetWithoutCompression(
           push_promise.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
     if (size > GetControlFrameBufferMaxSize()) {
       size += GetNumberRequiredContinuationFrames(size) *
               GetContinuationMinimumSize();
       flags &= ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
     }
   } else {
     size += GetSerializedLength(push_promise.name_value_block());
@@ skipping 36 matching lines @@
   CHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   if (continuation.end_headers()) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetContinuationMinimumSize();
   string hpack_encoding;
   if (enable_compression_) {
-    hpack_encoder_.EncodeHeaderSet(
+    hpack_encoder_->EncodeHeaderSet(
         continuation.name_value_block(), &hpack_encoding);
   } else {
-    hpack_encoder_.EncodeHeaderSetWithoutCompression(
+    hpack_encoder_->EncodeHeaderSetWithoutCompression(
         continuation.name_value_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.BeginNewFrame(*this, CONTINUATION, flags,
       continuation.stream_id());
   DCHECK_EQ(GetContinuationMinimumSize(), builder.length());
 
   builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
@@ skipping 384 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net