SPDY & HPACK: Land recent internal changes (through 65328503)

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/hpack_output_stream.h"
 #include "net/spdy/mock_spdy_framer_visitor.h"
 #include "net/spdy/spdy_frame_builder.h"
+#include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
 using base::StringPiece;
 using std::string;
 using std::max;
 using std::min;
@@ skipping 190 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(DecompressionVisitor);
   };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
 };
 
 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
                         public SpdyFramerDebugVisitorInterface {
  public:
+  // This is larger than our max frame size because header blocks that
+  // are too long can spill over into CONTINUATION frames.
   static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
 
   explicit TestSpdyVisitor(SpdyMajorVersion version)
     : framer_(version),
       use_compression_(false),
       error_count_(0),
       syn_frame_count_(0),
       syn_reply_frame_count_(0),
       headers_frame_count_(0),
+      push_promise_frame_count_(0),
       goaway_count_(0),
       setting_count_(0),
       settings_ack_sent_(0),
       settings_ack_received_(0),
       continuation_count_(0),
       last_window_update_stream_(0),
       last_window_update_delta_(0),
       last_push_promise_stream_(0),
       last_push_promise_promised_stream_(0),
       data_bytes_(0),
@@ skipping 10 matching lines @@
       header_buffer_length_(0),
       header_buffer_size_(kDefaultHeaderBufferSize),
       header_stream_id_(-1),
       header_control_type_(DATA),
       header_buffer_valid_(false) {
   }
 
   virtual void OnError(SpdyFramer* f) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
-    error_count_++;
+    ++error_count_;
   }
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
                                  bool fin) OVERRIDE {
-    data_frame_count_++;
+    ++data_frame_count_;
     header_stream_id_ = stream_id;
   }
 
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
                                  bool fin) OVERRIDE {
     EXPECT_EQ(header_stream_id_, stream_id);
     if (len == 0)
       ++zero_length_data_frame_count_;
@@ skipping 13 matching lines @@
                                         size_t len) OVERRIDE {
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
       ++zero_length_control_frame_header_data_count_;
       // Indicates end-of-header-block.
       headers_.clear();
       CHECK(header_buffer_valid_);
       size_t parsed_length = framer_.ParseHeaderBlockInBuffer(
           header_buffer_.get(), header_buffer_length_, &headers_);
-      DCHECK_EQ(header_buffer_length_, parsed_length);
+      LOG_IF(DFATAL, header_buffer_length_ != parsed_length)
+          << "Check failed: header_buffer_length_ == parsed_length "
+          << "(" << header_buffer_length_ << " vs. " << parsed_length << ")";
       return true;
     }
     const size_t available = header_buffer_size_ - header_buffer_length_;
     if (len > available) {
       header_buffer_valid_ = false;
       return false;
     }
     memcpy(header_buffer_.get() + header_buffer_length_, header_data, len);
     header_buffer_length_ += len;
     return true;
   }
 
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional) OVERRIDE {
-    syn_frame_count_++;
+    ++syn_frame_count_;
     InitHeaderStreaming(SYN_STREAM, stream_id);
     if (fin) {
-      fin_flag_count_++;
+      ++fin_flag_count_;
     }
   }
 
   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
-    syn_reply_frame_count_++;
+    ++syn_reply_frame_count_;
     InitHeaderStreaming(SYN_REPLY, stream_id);
     if (fin) {
-      fin_flag_count_++;
+      ++fin_flag_count_;
     }
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {
-    fin_frame_count_++;
+    ++fin_frame_count_;
   }
 
   virtual bool OnRstStreamFrameData(const char* rst_stream_data,
                                     size_t len) OVERRIDE {
     if ((rst_stream_data != NULL) && (len > 0)) {
       fin_opaque_data_ += std::string(rst_stream_data, len);
     }
     return true;
   }
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
                          uint32 value) OVERRIDE {
-    setting_count_++;
+    ++setting_count_;
   }
 
   virtual void OnSettingsAck() OVERRIDE {
-    DCHECK_GE(4, framer_.protocol_version());
-    settings_ack_received_++;
+    DCHECK_LT(SPDY3, framer_.protocol_version());
+    ++settings_ack_received_;
   }
 
   virtual void OnSettingsEnd() OVERRIDE {
-    if (framer_.protocol_version() < 4) { return; }
-    settings_ack_sent_++;
+    if (framer_.protocol_version() <= SPDY3) { return; }
+    ++settings_ack_sent_;
   }
 
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
     DLOG(FATAL);
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
                         SpdyGoAwayStatus status) OVERRIDE {
-    goaway_count_++;
+    ++goaway_count_;
   }
 
   virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
-    headers_frame_count_++;
+    ++headers_frame_count_;
     InitHeaderStreaming(HEADERS, stream_id);
     if (fin) {
-      fin_flag_count_++;
+      ++fin_flag_count_;
     }
   }
 
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
                               uint32 delta_window_size) OVERRIDE {
     last_window_update_stream_ = stream_id;
     last_window_update_delta_ = delta_window_size;
   }
 
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
                              bool end) OVERRIDE {
+    ++push_promise_frame_count_;
     InitHeaderStreaming(PUSH_PROMISE, stream_id);
     last_push_promise_stream_ = stream_id;
     last_push_promise_promised_stream_ = promised_stream_id;
   }
 
   virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
-    continuation_count_++;
+    ++continuation_count_;
   }
 
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
                                      size_t frame_len) OVERRIDE {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
@@ skipping 46 matching lines @@
   }
 
   SpdyFramer framer_;
   bool use_compression_;
 
   // Counters from the visitor callbacks.
   int error_count_;
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
+  int push_promise_frame_count_;
   int goaway_count_;
   int setting_count_;
   int settings_ack_sent_;
   int settings_ack_received_;
   int continuation_count_;
   SpdyStreamId last_window_update_stream_;
   uint32 last_window_update_delta_;
   SpdyStreamId last_push_promise_stream_;
   SpdyStreamId last_push_promise_promised_stream_;
   int data_bytes_;
@@ skipping 11 matching lines @@
   // Header block streaming state:
   scoped_ptr<char[]> header_buffer_;
   size_t header_buffer_length_;
   size_t header_buffer_size_;
   SpdyStreamId header_stream_id_;
   SpdyFrameType header_control_type_;
   bool header_buffer_valid_;
   SpdyHeaderBlock headers_;
 };
 
-// Retrieves serialized headers from SYN_STREAM frame.
-// Does not check that the given frame is a SYN_STREAM.
+// Retrieves serialized headers from a HEADERS or SYN_STREAM frame.
 base::StringPiece GetSerializedHeaders(const SpdyFrame* frame,
                                        const SpdyFramer& framer) {
-  return base::StringPiece(frame->data() + framer.GetSynStreamMinimumSize(),
-                           frame->size() - framer.GetSynStreamMinimumSize());
+  SpdyFrameReader reader(frame->data(), frame->size());
+  reader.Seek(2);  // Seek past the frame length.
+  SpdyFrameType frame_type;
+  if (framer.protocol_version() > SPDY3) {
+    uint8 serialized_type;
+    reader.ReadUInt8(&serialized_type);
+    frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
+                                               serialized_type);
+    DCHECK_EQ(HEADERS, frame_type);
+    uint8 flags;
+    reader.ReadUInt8(&flags);
+    if (flags & HEADERS_FLAG_PRIORITY) {
+      frame_type = SYN_STREAM;
+    }
+  } else {
+    uint16 serialized_type;
+    reader.ReadUInt16(&serialized_type);
+    frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
+                                               serialized_type);
+    DCHECK(frame_type == HEADERS ||
+           frame_type == SYN_STREAM) << frame_type;
+  }
+
+  if (frame_type == SYN_STREAM) {
+    return StringPiece(frame->data() + framer.GetSynStreamMinimumSize(),
+                       frame->size() - framer.GetSynStreamMinimumSize());
+  } else {
+    return StringPiece(frame->data() + framer.GetHeadersMinimumSize(),
+                       frame->size() - framer.GetHeadersMinimumSize());
+  }
 }
 
 }  // namespace test
 
 }  // namespace net
 
 using net::test::SetFrameLength;
 using net::test::SetFrameFlags;
 using net::test::CompareCharArraysWithHexError;
 using net::test::SpdyFramerTestUtil;
 using net::test::TestSpdyVisitor;
 using net::test::GetSerializedHeaders;
 
 namespace net {
 
 class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> {
  protected:
   virtual void SetUp() {
     spdy_version_ = GetParam();
-    spdy_version_ch_ = static_cast<unsigned char>(spdy_version_);
+    spdy_version_ch_ = static_cast<unsigned char>(
+        SpdyConstants::SerializeMajorVersion(spdy_version_));
   }
 
   void CompareFrame(const string& description,
                     const SpdyFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     CompareCharArraysWithHexError(
         description, actual, actual_frame.size(), expected, expected_len);
@@ skipping 135 matching lines @@
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
 // error (but don't crash).
 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
-  if (spdy_version_ < SPDY4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
   scoped_ptr<SpdySerializedFrame> frame(
       framer.SerializePushPromise(push_promise));
   ASSERT_TRUE(frame.get() != NULL);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
 // signal an error (but don't crash).
 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
-  if (spdy_version_ < SPDY4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   ASSERT_TRUE(frame.get() != NULL);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, DuplicateHeader) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): Punting on this because we haven't determined
     // whether duplicate HPACK headers other than Cookie are an error.
     // If they are, this will need to be updated to use HpackOutputStream.
     return;
   }
   SpdyFramer framer(spdy_version_);
   // Frame builder with plentiful buffer size.
-  SpdyFrameBuilder frame(1024);
-  if (spdy_version_ < 4) {
+  SpdyFrameBuilder frame(1024, spdy_version_);
+  if (spdy_version_ <= SPDY3) {
     frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
     frame.WriteUInt32(3);  // stream_id
     frame.WriteUInt32(0);  // associated stream id
     frame.WriteUInt16(0);  // Priority.
   } else {
-    frame.WriteFramePrefix(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
+    frame.BeginNewFrame(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
     frame.WriteUInt32(framer.GetHighestPriority());
   }
 
   if (IsSpdy2()) {
     frame.WriteUInt16(2);  // Number of headers.
     frame.WriteString("name");
     frame.WriteString("value1");
     frame.WriteString("name");
     frame.WriteString("value2");
   } else {
@@ skipping 13 matching lines @@
       GetSerializedHeaders(control_frame.get(), framer);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                serialized_headers.size(),
                                                &new_headers));
 }
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
   SpdyFramer framer(spdy_version_);
   // Frame builder with plentiful buffer size.
-  SpdyFrameBuilder frame(1024);
-  if (spdy_version_ < 4) {
+  SpdyFrameBuilder frame(1024, spdy_version_);
+  if (spdy_version_ <= SPDY3) {
     frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
     frame.WriteUInt32(3);  // stream_id
     frame.WriteUInt32(0);  // associated stream id
     frame.WriteUInt16(0);  // Priority.
   } else {
-    frame.WriteFramePrefix(framer,
-                           HEADERS,
-                           HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS,
-                           3);
+    frame.BeginNewFrame(framer,
+                        HEADERS,
+                        HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS,
+                        3);
     frame.WriteUInt32(framer.GetHighestPriority());
   }
 
   string value("value1\0value2", 13);
   if (IsSpdy2()) {
     frame.WriteUInt16(1);  // Number of headers.
     frame.WriteString("name");
     frame.WriteString(value);
-  } else if (spdy_version_ >= 4) {
-    HpackOutputStream output_stream(1024);
-    output_stream.AppendLiteralHeaderNoIndexingWithName("name", value);
+  } else if (spdy_version_ > SPDY3) {
+    // TODO(jgraettinger): If this pattern appears again, move to test class.
+    std::map<string, string> header_set;
+    header_set["name"] = value;
     string buffer;
-    output_stream.TakeString(&buffer);
+    HpackEncoder encoder(ObtainHpackHuffmanTable());
+    encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
     frame.WriteBytes(&buffer[0], buffer.size());
   } else {
     frame.WriteUInt32(1);  // Number of headers.
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32(value);
   }
   // write the length
   frame.RewriteLength(framer);
 
   framer.set_enable_compression(false);
   scoped_ptr<SpdyFrame> control_frame(frame.take());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("name", value)));
 }
 
 TEST_P(SpdyFramerTest, BasicCompression) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // Deflate compression doesn't apply to HPACK.
     return;
   }
   scoped_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor(spdy_version_));
   SpdyFramer framer(spdy_version_);
   framer.set_debug_visitor(visitor.get());
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("server", "SpdyServer 1.0");
   syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
@@ skipping 124 matching lines @@
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
 
     0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
   };
 
   const unsigned char kV3Input[] = {
     0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
@@ skipping 30 matching lines @@
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
 
     0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
   };
 
   // SYN_STREAM doesn't exist in SPDY4, so instead we send
   // HEADERS frames with PRIORITY and END_HEADERS set.
   const unsigned char kV4Input[] = {
     0x00, 0x05, 0x01, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x00, 0x00, 0x00, 0x00,           // Priority 0
     0x82,                             // :method: GET
 
@@ skipping 16 matching lines @@
     0x00, 0x00, 0x00, 0x03,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x04, 0x00, 0x00,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x01,
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x04, 0x03, 0x00,           // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08,           // RST_STREAM_CANCEL
 
     0x00, 0x00, 0x00, 0x00,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x03,
 
     0x00, 0x0f, 0x03, 0x00,           // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08,           // RST_STREAM_CANCEL
     0x52, 0x45, 0x53, 0x45,           // opaque data
     0x54, 0x53, 0x54, 0x52,
     0x45, 0x41, 0x4d,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
@@ skipping 198 matching lines @@
     EXPECT_EQ(0, visitor.headers_frame_count_);
   }
   EXPECT_EQ(0, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, HeaderCompression) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // Deflate compression doesn't apply to HPACK.
     return;
   }
   SpdyFramer send_framer(spdy_version_);
   SpdyFramer recv_framer(spdy_version_);
 
   send_framer.set_enable_compression(true);
   recv_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
@@ skipping 63 matching lines @@
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdySynStreamIR syn_stream(1);
   syn_stream.SetHeader(kHeader1, kValue1);
   syn_stream.SetHeader(kHeader2, kValue2);
   scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(syn_frame.get() != NULL);
 
   StringPiece bytes = "this is a test test test test test!";
-  net::SpdyDataIR data_ir(1, bytes);
+  SpdyDataIR data_ir(1, bytes);
   data_ir.set_fin(true);
   scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
   EXPECT_TRUE(send_frame.get() != NULL);
 
   // Run the inputs through the framer.
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   const unsigned char* data;
   data = reinterpret_cast<const unsigned char*>(syn_frame->data());
   visitor.SimulateInFramer(data, syn_frame->size());
@@ skipping 23 matching lines @@
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdySynStreamIR syn_stream(1);
   syn_stream.SetHeader(kHeader1, kValue1);
   syn_stream.SetHeader(kHeader2, kValue2);
   scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(syn_frame.get() != NULL);
 
   const char bytes[] = "this is a test test test test test!";
-  net::SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
+  SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
   data_ir.set_fin(true);
   scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
   EXPECT_TRUE(send_frame.get() != NULL);
 
   // Run the inputs through the framer.
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   const unsigned char* data;
   data = reinterpret_cast<const unsigned char*>(syn_frame->data());
   for (size_t idx = 0; idx < syn_frame->size(); ++idx) {
@@ skipping 13 matching lines @@
   EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-      net::SpdyWindowUpdateIR(1, 0x12345678)));
+      SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kV3FrameData[] = {  // Also applies for V2.
     0x80, spdy_version_ch_, 0x00, 0x09,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x12, 0x34, 0x56, 0x78
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x04, 0x08, 0x00,
@@ skipping 32 matching lines @@
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
 
     SpdyDataIR data_header_ir(1);
     data_header_ir.SetDataShallow(base::StringPiece(bytes, strlen(bytes)));
-    frame.reset(framer.SerializeDataFrameHeader(data_header_ir));
+    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(
+        data_header_ir));
     CompareCharArraysWithHexError(
         kDescription,
         reinterpret_cast<const unsigned char*>(frame->data()),
+        framer.GetDataFrameMinimumSize(),
+        IsSpdy4() ? kV4FrameData : kV3FrameData,
+        framer.GetDataFrameMinimumSize());
+  }
+
+  {
+    const char kDescription[] = "'hello' data frame with more padding, no FIN";
+    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x00, 0x05,
+      'h',  'e',  'l',  'l',
+      'o'
+    };
+
+    const unsigned char kV4FrameData[] = {
+      0x01, 0x0b, 0x00, 0x30,      // Length = 267.  PAD_HIGH and PAD_LOW set.
+      0x00, 0x00, 0x00, 0x01,
+      0x01, 0x04,                  // Pad Low and Pad High fields.
+      'h',  'e',  'l',  'l',       // Data
+      'o',
+      // Padding of 260 zeros (so both PAD_HIGH and PAD_LOW fields are used).
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+      '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
+    };
+    const char bytes[] = "hello";
+
+    SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
+    // 260 zeros and the pad low/high fields make the overall padding to be 262
+    // bytes.
+    data_ir.set_padding_len(262);
+    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    if (IsSpdy4()) {
+       CompareFrame(
+           kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+    } else {
+       CompareFrame(
+           kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+    }
+
+    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    CompareCharArraysWithHexError(
+        kDescription,
+        reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy4() ? kV4FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
-    const char kDescription[] = "'hello' data frame with padding, no FIN";
+    const char kDescription[] = "'hello' data frame with few padding, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kV4FrameData[] = {
       0x00, 0x0d, 0x00, 0x10,      // Length = 13.  PAD_LOW set.
       0x00, 0x00, 0x00, 0x01,
       0x07,                        // Pad Low field.
       'h',  'e',  'l',  'l',       // Data
       'o',
       '0',  '0',  '0',  '0',       // Padding
       '0',  '0',  '0'
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
-    // 7 zeros and the pad low field make the overal padding to be 8 bytes.
+    // 7 zeros and the pad low field make the overall padding to be 8 bytes.
     data_ir.set_padding_len(8);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
+    const char kDescription[] =
+        "'hello' data frame with 1 byte padding, no FIN";
+    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x00, 0x05,
+      'h',  'e',  'l',  'l',
+      'o'
+    };
+
+    const unsigned char kV4FrameData[] = {
+      0x00, 0x06, 0x00, 0x10,      // Length = 6.  PAD_LOW set.
+      0x00, 0x00, 0x00, 0x01,
+      0x00,                        // Pad Low field.
+      'h',  'e',  'l',  'l',       // Data
+      'o',
+    };
+    const char bytes[] = "hello";
+
+    SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
+    // The pad low field itself is used for the 1-byte padding and no padding
+    // payload is needed.
+    data_ir.set_padding_len(1);
+    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    if (IsSpdy4()) {
+       CompareFrame(
+           kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+    } else {
+       CompareFrame(
+           kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+    }
+
+    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    CompareCharArraysWithHexError(
+        kDescription,
+        reinterpret_cast<const unsigned char*>(frame->data()),
+        framer.GetDataFrameMinimumSize(),
+        IsSpdy4() ? kV4FrameData : kV3FrameData,
+        framer.GetDataFrameMinimumSize());
+  }
+
+  {
     const char kDescription[] = "Data frame with negative data byte, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x01, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
-    net::SpdyDataIR data_ir(1, StringPiece("\xff", 1));
+    SpdyDataIR data_ir(1, StringPiece("\xff", 1));
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "'hello' data frame, with FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x05, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       'h',  'e',  'l',  'l',
       'o'
     };
-    net::SpdyDataIR data_ir(1, StringPiece("hello", 5));
+    SpdyDataIR data_ir(1, StringPiece("hello", 5));
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty data frame";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x01,
     };
-    net::SpdyDataIR data_ir(1, StringPiece());
+    SpdyDataIR data_ir(1, StringPiece());
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
+
+    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    CompareCharArraysWithHexError(
+        kDescription,
+        reinterpret_cast<const unsigned char*>(frame->data()),
+        framer.GetDataFrameMinimumSize(),
+        IsSpdy4() ? kV4FrameData : kV3FrameData,
+        framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x7f, 0xff, 0xff, 0xff,
       0x01, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x05, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
       'h',  'e',  'l',  'l',
       'o'
     };
-    net::SpdyDataIR data_ir(0x7fffffff, "hello");
+    SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   if (!IsSpdy4()) {
     // This test does not apply to SPDY 4 because the max frame size is smaller
     // than 4MB.
     const char kDescription[] = "Large data frame";
     const int kDataSize = 4 * 1024 * 1024;  // 4 MB
     const string kData(kDataSize, 'A');
     const unsigned char kFrameHeader[] = {
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x40, 0x00, 0x00,
     };
 
     const int kFrameSize = arraysize(kFrameHeader) + kDataSize;
     scoped_ptr<unsigned char[]> expected_frame_data(
         new unsigned char[kFrameSize]);
     memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
-    net::SpdyDataIR data_ir(1, StringPiece(kData.data(), kData.size()));
+    SpdyDataIR data_ir(1, StringPiece(kData.data(), kData.size()));
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
@@ skipping 453 matching lines @@
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x07, 0x03, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0x52, 0x53, 0x54
     };
-    net::SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR, "RST");
+    SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR, "RST");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x04, 0x03, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
-    net::SpdyRstStreamIR rst_stream(0x7FFFFFFF,
-                                    RST_STREAM_PROTOCOL_ERROR,
-                                    "");
+    SpdyRstStreamIR rst_stream(0x7FFFFFFF,
+                               RST_STREAM_PROTOCOL_ERROR,
+                               "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max status code";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x04, 0x03, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
-    net::SpdyRstStreamIR rst_stream(0x7FFFFFFF,
-                                    RST_STREAM_INTERNAL_ERROR,
-                                    "");
+    SpdyRstStreamIR rst_stream(0x7FFFFFFF,
+                               RST_STREAM_INTERNAL_ERROR,
+                               "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
@@ skipping 475 matching lines @@
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x04, 0x08, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     scoped_ptr<SpdyFrame> frame(
-        framer.SerializeWindowUpdate(net::SpdyWindowUpdateIR(1, 1)));
+        framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x04, 0x08, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        net::SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
+        SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x04, 0x08, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        net::SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
+        SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SerializeBlocked) {
   if (spdy_version_ < SPDY4) {
@@ skipping 24 matching lines @@
 
   scoped_ptr<SpdySerializedFrame> frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
   scoped_ptr<SpdySerializedFrame> frame_created(
                                     framer.SerializeFrame(blocked_ir));
 
   CompareFrames(kDescription, *frame_serialized, *frame_created);
 }
 
-TEST_P(SpdyFramerTest, CreatePushPromise) {
+TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
-
+  framer.set_enable_compression(false);
   const char kDescription[] = "PUSH_PROMISE frame";
 
   const unsigned char kFrameData[] = {
     0x00, 0x16, 0x05, 0x04,  // PUSH_PROMISE: END_HEADERS
     0x00, 0x00, 0x00, 0x2a,  // Stream 42
     0x00, 0x00, 0x00, 0x39,  // Promised stream 57
     0x40, 0x03, 0x62, 0x61,  // @.ba
     0x72, 0x03, 0x66, 0x6f,  // r.fo
     0x6f, 0x40, 0x03, 0x66,  // o@.f
     0x6f, 0x6f, 0x03, 0x62,  // oo.b
@@ skipping 92 matching lines @@
   // produced by rand(), so adding, removing or running single tests
   // alters this value.  The best we can do is assert that it happens
   // at least twice.
   EXPECT_LE(2, visitor.control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ControlFrameAtMaxSizeLimit) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "");
@@ skipping 14 matching lines @@
       control_frame->size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_LT(kBigValueSize, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameTooLarge) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.SetHeader("aa", "");
   syn_stream.set_priority(1);
@@ skipping 19 matching lines @@
       control_frame->size());
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
+TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+  framer.set_enable_compression(false);
+  SpdyHeadersIR headers(1);
+
+  // Exact payload length will change with HPACK, but this should be long
+  // enough to cause an overflow.
+  const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
+  string big_value(kBigValueSize, 'x');
+  headers.SetHeader("aa", big_value.c_str());
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
+  EXPECT_TRUE(control_frame.get() != NULL);
+  EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
+
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(control_frame->data()),
+      control_frame->size());
+  EXPECT_TRUE(visitor.header_buffer_valid_);
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1, visitor.headers_frame_count_);
+  EXPECT_EQ(1, visitor.continuation_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
+}
+
+TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+  framer.set_enable_compression(false);
+  SpdyPushPromiseIR push_promise(1, 2);
+
+  // Exact payload length will change with HPACK, but this should be long
+  // enough to cause an overflow.
+  const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
+  string big_value(kBigValueSize, 'x');
+  push_promise.SetHeader("aa", big_value.c_str());
+  scoped_ptr<SpdyFrame> control_frame(
+      framer.SerializePushPromise(push_promise));
+  EXPECT_TRUE(control_frame.get() != NULL);
+  EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
+
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(control_frame->data()),
+      control_frame->size());
+  EXPECT_TRUE(visitor.header_buffer_valid_);
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1, visitor.push_promise_frame_count_);
+  EXPECT_EQ(1, visitor.continuation_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
+}
+
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
   string big_value(kBigValueSize, 'x');
   SpdyFramer framer(spdy_version_);
@@ skipping 24 matching lines @@
   // at least kHeaderBufferChunks + 1.
   EXPECT_LE(kHeaderBufferChunks + 1,
             static_cast<unsigned>(visitor.control_frame_header_data_count_));
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   // The framer should not have sent half-close to the visitor.
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, DecompressCorruptHeaderBlock) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     // Deflate compression doesn't apply to HPACK.
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   // Construct a SYN_STREAM control frame without compressing the header block,
   // and have the framer try to decompress it. This will cause the framer to
   // deal with a decompression error.
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
@@ skipping 58 matching lines @@
 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
   SetFrameLength(control_frame.get(), 0, spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       framer.GetControlFrameHeaderSize());
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     // Should generate an error, since zero-len settings frames are unsupported.
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // Zero-len settings frames are permitted as of SPDY 4.
     EXPECT_EQ(0, visitor.error_count_);
   }
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
@@ skipping 41 matching lines @@
             control_frame->size());
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
 
   // Read all at once.
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3, visitor.setting_count_);
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     EXPECT_EQ(1, visitor.settings_ack_sent_);
   }
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame->size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3 * 2, visitor.setting_count_);
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     EXPECT_EQ(2, visitor.settings_ack_sent_);
   }
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
 TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
@@ skipping 102 matching lines @@
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, settings are allowed in any order.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
     // EXPECT_EQ(1, visitor.settings_ack_count_);
   }
 }
 
 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kFrameData[] = {
     0x00, 0x00, 0x04, 0x01,
     0x00, 0x00, 0x00, 0x00,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_received_);
 }
 
 
 TEST_P(SpdyFramerTest, ProcessDataFrameWithPadding) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const int kPaddingLen = 512;  // So we get two bytes for padding length field.
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
@@ skipping 49 matching lines @@
   // Send rest of the padding payload.
   EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 410, false));
   CHECK_EQ(410u, framer.ProcessInput(frame->data() + bytes_consumed, 410));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_RESET);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
 }
 
 TEST_P(SpdyFramerTest, ReadWindowUpdate) {
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> control_frame(
-      framer.SerializeWindowUpdate(net::SpdyWindowUpdateIR(1, 2)));
+      framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2u, visitor.last_window_update_delta_);
 }
 
 TEST_P(SpdyFramerTest, ReceiveCredentialFrame) {
   if (!IsSpdy3()) {
@@ skipping 43 matching lines @@
       't',  0x00, 0x00, 0x00,
       0x0A, 'f',  'i',  'n',
       'a',  'l',  ' ',  'c',
       'e',  'r',  't',
   };
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   string multiple_frame_data(reinterpret_cast<const char*>(kV3FrameData),
                              arraysize(kV3FrameData));
   scoped_ptr<SpdyFrame> control_frame(
-      framer.SerializeWindowUpdate(net::SpdyWindowUpdateIR(1, 2)));
+      framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
   multiple_frame_data.append(string(control_frame->data(),
                                     control_frame->size()));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned const char*>(multiple_frame_data.data()),
       multiple_frame_data.length());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2u, visitor.last_window_update_delta_);
 }
 
-TEST_P(SpdyFramerTest, CreateContinuation) {
+TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
-
+  framer.set_enable_compression(false);
   const char kDescription[] = "CONTINUATION frame";
 
   const unsigned char kFrameData[] = {
      0x00, 0x12, 0x09, 0x00,  // CONTINUATION
      0x00, 0x00, 0x00, 0x2a,  // Stream 42
      0x40, 0x03, 0x62, 0x61,  // @.ba
      0x72, 0x03, 0x66, 0x6f,  // r.fo
      0x6f, 0x40, 0x03, 0x66,  // o@.f
      0x6f, 0x6f, 0x03, 0x62,  // oo.b
      0x61, 0x72,              // ar
   };
 
   SpdyContinuationIR continuation(42);
   continuation.SetHeader("bar", "foo");
   continuation.SetHeader("foo", "bar");
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializeContinuation(continuation));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdyHeaderBlock headers = push_promise.name_value_block();
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   EXPECT_TRUE(frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
@@ skipping 24 matching lines @@
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("Cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuationAndFin) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x01, 0x01,  // HEADERS: FIN
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
@@ skipping 25 matching lines @@
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("Cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x14, 0x05, 0x00,  // PUSH_PROMISE
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x00, 0x00, 0x2A,  // Promised stream 42
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
@@ skipping 26 matching lines @@
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("Cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadContinuationWithWrongStreamId) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
@@ skipping 15 matching lines @@
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ReadContinuationOutOfOrder) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveData) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
@@ skipping 12 matching lines @@
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
     0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
@@ skipping 172 matching lines @@
                SpdyFramer::StatusCodeToString(RST_STREAM_REFUSED_STREAM));
   EXPECT_STREQ("UNSUPPORTED_VERSION",
                SpdyFramer::StatusCodeToString(RST_STREAM_UNSUPPORTED_VERSION));
   EXPECT_STREQ("CANCEL",
                SpdyFramer::StatusCodeToString(RST_STREAM_CANCEL));
   EXPECT_STREQ("INTERNAL_ERROR",
                SpdyFramer::StatusCodeToString(RST_STREAM_INTERNAL_ERROR));
   EXPECT_STREQ("FLOW_CONTROL_ERROR",
                SpdyFramer::StatusCodeToString(RST_STREAM_FLOW_CONTROL_ERROR));
   EXPECT_STREQ("UNKNOWN_STATUS",
-               SpdyFramer::StatusCodeToString(RST_STREAM_NUM_STATUS_CODES));
+               SpdyFramer::StatusCodeToString(-1));
 }
 
 TEST_P(SpdyFramerTest, FrameTypeToStringTest) {
   EXPECT_STREQ("DATA",
                SpdyFramer::FrameTypeToString(DATA));
   EXPECT_STREQ("SYN_STREAM",
                SpdyFramer::FrameTypeToString(SYN_STREAM));
   EXPECT_STREQ("SYN_REPLY",
                SpdyFramer::FrameTypeToString(SYN_REPLY));
   EXPECT_STREQ("RST_STREAM",
@@ skipping 43 matching lines @@
     EXPECT_CALL(visitor, OnError(_));
     framer.ProcessInput("HTTP/1.0", 8);
     EXPECT_TRUE(framer.probable_http_response());
     EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   }
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV2V3) {
-  if (spdy_version_ >= 4) {
+  if (spdy_version_ > SPDY3) {
     return;
   }
 
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
-    net::SpdyDataIR data_ir(1, StringPiece("hello", 5));
+    SpdyDataIR data_ir(1, StringPiece("hello", 5));
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
-  if (spdy_version_ < 4) {
+  if (spdy_version_ <= SPDY3) {
     return;
   }
 
   uint8 valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
       DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
 
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
-    net::SpdyDataIR data_ir(1, StringPiece("hello", 5));
+    SpdyDataIR data_ir(1, StringPiece("hello", 5));
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
     if (flags & ~valid_data_flags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       if ((flags & DATA_FLAG_PAD_LOW) || (flags & DATA_FLAG_PAD_HIGH)) {
         // Expect Error since we don't set pad_high and pad_low in payload.
         EXPECT_CALL(visitor, OnError(_));
@@ skipping 138 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
-    net::SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL, "");
+    SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL, "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
     }
 
     framer.ProcessInput(frame->data(), frame->size());
     if (flags != 0) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlagsOldFormat) {
-  if (spdy_version_ >= 4) { return; }
+  if (spdy_version_ > SPDY3) { return; }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_UPLOAD_BANDWIDTH,
                            false,
@@ skipping 20 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
-  if (spdy_version_ < 4) { return; }
+  if (spdy_version_ <= SPDY3) { return; }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
@@ skipping 125 matching lines @@
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializePing(SpdyPingIR(42)));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
-    if (spdy_version_ >= SPDY4 &&
+    if (spdy_version_ > SPDY3 &&
         flags == PING_FLAG_ACK) {
       EXPECT_CALL(visitor, OnPing(42, true));
     } else if (flags == 0) {
       EXPECT_CALL(visitor, OnPing(42, false));
     } else {
       EXPECT_CALL(visitor, OnError(_));
     }
 
     framer.ProcessInput(frame->data(), frame->size());
-    if ((spdy_version_ >= SPDY4 && flags == PING_FLAG_ACK) ||
+    if ((spdy_version_ > SPDY3 && flags == PING_FLAG_ACK) ||
         flags == 0) {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        net::SpdyWindowUpdateIR(4, 1024)));
+        SpdyWindowUpdateIR(4, 1024)));
     SetFrameFlags(frame.get(), flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
     }
 
     framer.ProcessInput(frame->data(), frame->size());
     if (flags != 0) {
@@ skipping 147 matching lines @@
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
-  DCHECK_GE(0xff, RST_STREAM_NUM_STATUS_CODES);
-
+  const unsigned char kRstStreamStatusTooLow = 0x00;
+  const unsigned char kRstStreamStatusTooHigh = 0xff;
   const unsigned char kV3RstStreamInvalid[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, RST_STREAM_INVALID
+    0x00, 0x00, 0x00, kRstStreamStatusTooLow
   };
   const unsigned char kV4RstStreamInvalid[] = {
     0x00, 0x04, 0x03, 0x00,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, RST_STREAM_INVALID
+    0x00, 0x00, 0x00, kRstStreamStatusTooLow
   };
 
   const unsigned char kV3RstStreamNumStatusCodes[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, RST_STREAM_NUM_STATUS_CODES
+    0x00, 0x00, 0x00, kRstStreamStatusTooHigh
   };
   const unsigned char kV4RstStreamNumStatusCodes[] = {
     0x00, 0x04, 0x03, 0x00,
     0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, RST_STREAM_NUM_STATUS_CODES
+    0x00, 0x00, 0x00, kRstStreamStatusTooHigh
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
-  EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
   if (IsSpdy4()) {
+    EXPECT_CALL(visitor, OnError(_));
     framer.ProcessInput(reinterpret_cast<const char*>(kV4RstStreamInvalid),
                         arraysize(kV4RstStreamInvalid));
+    EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
   } else {
+    EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
     framer.ProcessInput(reinterpret_cast<const char*>(kV3RstStreamInvalid),
                         arraysize(kV3RstStreamInvalid));
+    EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+    EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
   }
-  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
-  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
-      << SpdyFramer::ErrorCodeToString(framer.error_code());
 
-  EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
+
+  framer.Reset();
+
   if (IsSpdy4()) {
+    EXPECT_CALL(visitor, OnError(_));
     framer.ProcessInput(
         reinterpret_cast<const char*>(kV4RstStreamNumStatusCodes),
         arraysize(kV4RstStreamNumStatusCodes));
+    EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
   } else {
+    EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
     framer.ProcessInput(
         reinterpret_cast<const char*>(kV3RstStreamNumStatusCodes),
         arraysize(kV3RstStreamNumStatusCodes));
+    EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+    EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
   }
-  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
-  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
-      << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of a GOAWAY frame with out-of-bounds stream ID.
 TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x04,
     0xff, 0xff, 0xff, 0xff,
   };
   const unsigned char kV3FrameData[] = {
@@ skipping 45 matching lines @@
   SpdyBlockedIR blocked_ir(0);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
   framer.ProcessInput(frame->data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 }  // namespace net