Land recent SPDY changes (through 70021377)

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"
@@ skipping 173 matching lines @@
       scoped_ptr<SpdyFrame> frame(framer.SerializePushPromise(push_promise));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
     virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
       LOG(FATAL);
     }
 
+    virtual void OnPriority(SpdyStreamId stream_id,
+                            SpdyStreamId parent_stream_id,
+                            uint8 weight,
+                            bool exclusive) OVERRIDE {
+      // Do nothing.
+    }
+
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id,
                                 uint32 delta_window_size) OVERRIDE {
       LOG(FATAL);
     }
 
@@ skipping 16 matching lines @@
 };
 
 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),
-      altsvc_count_(0),
-      test_altsvc_ir_(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),
-      fin_frame_count_(0),
-      fin_opaque_data_(),
-      fin_flag_count_(0),
-      zero_length_data_frame_count_(0),
-      control_frame_header_data_count_(0),
-      zero_length_control_frame_header_data_count_(0),
-      data_frame_count_(0),
-      last_payload_len_(0),
-      last_frame_len_(0),
-      header_buffer_(new char[kDefaultHeaderBufferSize]),
-      header_buffer_length_(0),
-      header_buffer_size_(kDefaultHeaderBufferSize),
-      header_stream_id_(-1),
-      header_control_type_(DATA),
-      header_buffer_valid_(false) {
-  }
+      : 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),
+        altsvc_count_(0),
+        priority_count_(0),
+        test_altsvc_ir_(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),
+        fin_frame_count_(0),
+        fin_opaque_data_(),
+        fin_flag_count_(0),
+        zero_length_data_frame_count_(0),
+        control_frame_header_data_count_(0),
+        zero_length_control_frame_header_data_count_(0),
+        data_frame_count_(0),
+        last_payload_len_(0),
+        last_frame_len_(0),
+        header_buffer_(new char[kDefaultHeaderBufferSize]),
+        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_;
   }
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
                                  bool fin) OVERRIDE {
@@ skipping 45 matching lines @@
     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_;
-    InitHeaderStreaming(SYN_STREAM, stream_id);
+    if (framer_.protocol_version() > SPDY3) {
+      InitHeaderStreaming(HEADERS, stream_id);
+    } else {
+      InitHeaderStreaming(SYN_STREAM, stream_id);
+    }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
     ++syn_reply_frame_count_;
-    InitHeaderStreaming(SYN_REPLY, stream_id);
+    if (framer_.protocol_version() > SPDY3) {
+      InitHeaderStreaming(HEADERS, stream_id);
+    } else {
+      InitHeaderStreaming(SYN_REPLY, stream_id);
+    }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {
     ++fin_frame_count_;
   }
 
@@ skipping 75 matching lines @@
   }
 
   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;
   }
 
+  virtual void OnPriority(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive) OVERRIDE {
+    ++priority_count_;
+  }
+
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
                                         size_t frame_len) OVERRIDE {
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
            framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
       // To make the tests more interesting, we feed random (amd small) chunks
       // into the framer.  This simulates getting strange-sized reads from
       // the socket.
       const size_t kMaxReadSize = 32;
       size_t bytes_read =
           (rand() % min(input_remaining, kMaxReadSize)) + 1;
       size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
       input_remaining -= bytes_processed;
       input_ptr += bytes_processed;
     }
   }
 
   void InitHeaderStreaming(SpdyFrameType header_control_type,
                            SpdyStreamId stream_id) {
-    DCHECK_GE(header_control_type, FIRST_CONTROL_TYPE);
-    DCHECK_LE(header_control_type, LAST_CONTROL_TYPE);
+    if (!SpdyConstants::IsValidFrameType(framer_.protocol_version(),
+        SpdyConstants::SerializeFrameType(framer_.protocol_version(),
+                                          header_control_type))) {
+      DLOG(FATAL) << "Attempted to init header streaming with "
+                  << "invalid control frame type: "
+                  << header_control_type;
+    }
     memset(header_buffer_.get(), 0, header_buffer_size_);
     header_buffer_length_ = 0;
     header_stream_id_ = stream_id;
     header_control_type_ = header_control_type;
     header_buffer_valid_ = true;
     DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
   }
 
   // Override the default buffer size (16K). Call before using the framer!
   void set_header_buffer_size(size_t header_buffer_size) {
@@ skipping 13 matching lines @@
   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_;
   int altsvc_count_;
+  int priority_count_;
   SpdyAltSvcIR test_altsvc_ir_;
   SpdyStreamId last_window_update_stream_;
   uint32 last_window_update_delta_;
   SpdyStreamId last_push_promise_stream_;
   SpdyStreamId last_push_promise_promised_stream_;
   int data_bytes_;
   int fin_frame_count_;  // The count of RST_STREAM type frames received.
   std::string fin_opaque_data_;
   int fin_flag_count_;  // The count of frames with the FIN flag set.
   int zero_length_data_frame_count_;  // The count of zero-length data frames.
@@ skipping 131 matching lines @@
 // All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
                         ::testing::Values(SPDY2, SPDY3, SPDY4));
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
-  // Encode the header block into a SynStream frame.
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.SetHeader("alpha", "beta");
-  syn_stream.SetHeader("gamma", "charlie");
-  syn_stream.SetHeader("cookie", "key1=value1; key2=value2");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+  // Encode the header block into a Headers frame.
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.SetHeader("alpha", "beta");
+  headers.SetHeader("gamma", "charlie");
+  headers.SetHeader("cookie", "key1=value1; key2=value2");
+  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(frame.get() != NULL);
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
-  EXPECT_TRUE(CompareHeaderBlocks(&syn_stream.name_value_block(),
+  EXPECT_TRUE(CompareHeaderBlocks(&headers.name_value_block(),
                                   &visitor.headers_));
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
-  // Encode the header block into a SynStream frame.
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.SetHeader("alpha", "beta");
-  syn_stream.SetHeader("gamma", "charlie");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+  // Encode the header block into a Headers frame.
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.SetHeader("alpha", "beta");
+  headers.SetHeader("gamma", "charlie");
+  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(frame.get() != NULL);
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size() - 2);
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0u, visitor.headers_.size());
 }
 
 // Test that if we receive a SYN_REPLY with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, SynReplyWithStreamIdZero) {
+  if (spdy_version_ > SPDY3) {
+    return;
+  }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdySynReplyIR syn_reply(0);
   syn_reply.SetHeader("alpha", "beta");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeSynReply(syn_reply));
   ASSERT_TRUE(frame.get() != NULL);
 
   // We shouldn't have to read the whole frame before we signal an error.
@@ skipping 210 matching lines @@
   }
   scoped_ptr<SpdyFrame> frame2(framer.SerializeSynStream(syn_stream));
   size_t uncompressed_size2 = visitor->last_payload_len_;
   size_t compressed_size2 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
 
   // Expect the second frame to be more compact than the first.
   EXPECT_LE(frame2->size(), frame1->size());
 
   // Decompress the first frame
-  scoped_ptr<SpdyFrame> frame3(SpdyFramerTestUtil::DecompressFrame(
-      &framer, *frame1.get()));
+  scoped_ptr<SpdyFrame> frame3(
+      SpdyFramerTestUtil::DecompressFrame(&framer, *frame1));
 
   // Decompress the second frame
   visitor.reset(new TestSpdyVisitor(spdy_version_));
   framer.set_debug_visitor(visitor.get());
-  scoped_ptr<SpdyFrame> frame4(SpdyFramerTestUtil::DecompressFrame(
-      &framer, *frame2.get()));
+  scoped_ptr<SpdyFrame> frame4(
+      SpdyFramerTestUtil::DecompressFrame(&framer, *frame2));
   size_t uncompressed_size4 =
       frame4->size() - framer.GetSynStreamMinimumSize();
   size_t compressed_size4 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
   if (IsSpdy2()) {
     EXPECT_EQ(139u, uncompressed_size4);
 #if defined(USE_SYSTEM_ZLIB)
     EXPECT_EQ(149u, compressed_size4);
 #else  // !defined(USE_SYSTEM_ZLIB)
     EXPECT_EQ(101u, compressed_size4);
@@ skipping 17 matching lines @@
   // Expect frames 3 to be the same as a uncompressed frame created
   // from scratch.
   framer.set_enable_compression(false);
   scoped_ptr<SpdyFrame> uncompressed_frame(
       framer.SerializeSynStream(syn_stream));
   CompareFrames("Uncompressed SYN_STREAM", *frame3, *uncompressed_frame);
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
   // See crbug.com/172383
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.SetHeader("server", "SpdyServer 1.0");
-  syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
-  syn_stream.SetHeader("status", "200");
-  syn_stream.SetHeader("version", "HTTP/1.1");
-  syn_stream.SetHeader("content-type", "text/html");
-  syn_stream.SetHeader("content-length", "12");
-  syn_stream.SetHeader("x-empty-header", "");
+  SpdyHeadersIR headers(1);
+  headers.SetHeader("server", "SpdyServer 1.0");
+  headers.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
+  headers.SetHeader("status", "200");
+  headers.SetHeader("version", "HTTP/1.1");
+  headers.SetHeader("content-type", "text/html");
+  headers.SetHeader("content-length", "12");
+  headers.SetHeader("x-empty-header", "");
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
-  scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
+  scoped_ptr<SpdyFrame> frame1(framer.SerializeHeaders(headers));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
   const unsigned char kV2Input[] = {
     0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'h', 'h',
@@ skipping 395 matching lines @@
   scoped_ptr<SpdyFrame> syn_frame_2(send_framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(syn_frame_2.get() != NULL);
 
   // Now start decompressing
   scoped_ptr<SpdyFrame> decompressed;
   scoped_ptr<SpdyFrame> uncompressed;
   base::StringPiece serialized_headers;
   SpdyHeaderBlock decompressed_headers;
 
   // Decompress SYN_STREAM #1
-  decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
-      &recv_framer, *syn_frame_1.get()));
+  decompressed.reset(
+      SpdyFramerTestUtil::DecompressFrame(&recv_framer, *syn_frame_1));
   EXPECT_TRUE(decompressed.get() != NULL);
   serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                    serialized_headers.size(),
                                                    &decompressed_headers));
   EXPECT_EQ(2u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
 
   // Decompress SYN_STREAM #2
-  decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
-      &recv_framer, *syn_frame_2.get()));
+  decompressed.reset(
+      SpdyFramerTestUtil::DecompressFrame(&recv_framer, *syn_frame_2));
   EXPECT_TRUE(decompressed.get() != NULL);
   serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
   decompressed_headers.clear();
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                    serialized_headers.size(),
                                                    &decompressed_headers));
   EXPECT_EQ(3u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
   EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
 }
 
-// Verify we don't leak when we leave streams unclosed
-TEST_P(SpdyFramerTest, UnclosedStreamDataCompressors) {
-  SpdyFramer send_framer(spdy_version_);
-
-  send_framer.set_enable_compression(true);
-
-  const char kHeader1[] = "header1";
-  const char kHeader2[] = "header2";
-  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!";
-  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());
-  data = reinterpret_cast<const unsigned char*>(send_frame->data());
-  visitor.SimulateInFramer(data, send_frame->size());
-
-  EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(0, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
-  EXPECT_EQ(bytes.size(), 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_);
-}
-
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
   SpdyFramer send_framer(spdy_version_);
 
   send_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   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);
+  SpdyHeadersIR headers(1);
+  headers.SetHeader(kHeader1, kValue1);
+  headers.SetHeader(kHeader2, kValue2);
+  scoped_ptr<SpdyFrame> headers_frame(send_framer.SerializeHeaders(headers));
+  EXPECT_TRUE(headers_frame.get() != NULL);
 
   const char bytes[] = "this is a test test test test test!";
   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) {
+  data = reinterpret_cast<const unsigned char*>(headers_frame->data());
+  for (size_t idx = 0; idx < headers_frame->size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
   data = reinterpret_cast<const unsigned char*>(send_frame->data());
   for (size_t idx = 0; idx < send_frame->size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
 
   EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1, visitor.syn_frame_count_);
+  EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
+  EXPECT_EQ(1, visitor.headers_frame_count_);
   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(
@@ skipping 63 matching lines @@
   {
     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, 0x18,      // Length = 267.  PAD_HIGH and PAD_LOW set.
+      0x00, 0xfd, 0x00, 0x08,      // Length = 253.  PADDED set.
       0x00, 0x00, 0x00, 0x01,
-      0x01, 0x04,                  // Pad Low and Pad High fields.
+      0xf7,                        // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
-      // Padding of 260 zeros (so both PAD_HIGH and PAD_LOW fields are used).
+      // Padding of 247 zeros.
       '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
+    // 247 zeros and the pad length field make the overall padding to be 248
     // bytes.
-    data_ir.set_padding_len(262);
+    data_ir.set_padding_len(248);
     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 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, 0x08,      // Length = 13.  PAD_LOW set.
+      0x00, 0x0d, 0x00, 0x08,      // Length = 13.  PADDED set.
       0x00, 0x00, 0x00, 0x01,
-      0x07,                        // Pad Low field.
+      0x07,                        // Pad length 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 overall padding to be 8 bytes.
+    // 7 zeros and the pad length 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, 0x08,      // Length = 6.  PAD_LOW set.
+      0x00, 0x06, 0x00, 0x08,      // Length = 6.  PADDED set.
       0x00, 0x00, 0x00, 0x01,
-      0x00,                        // Pad Low field.
+      0x00,                        // Pad length 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
+    // The pad length 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));
     }
@@ skipping 129 matching lines @@
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     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) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM unsupported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
 
     const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x20,
@@ skipping 14 matching lines @@
       kPri, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'b',
       'a',  'r'
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x17, 0x01, 0x24,  // HEADERS: PRIORITY | END_HEADERS
-      0x00, 0x00, 0x00, 0x01,  // Stream 1
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 0.
-      0x00, 0x00, 0x03, 0x62,
-      0x61, 0x72, 0x03, 0x66,
-      0x6f, 0x6f, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x03,
-      0x62, 0x61, 0x72,
-    };
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(framer.GetLowestPriority());
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
@@ skipping 14 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r'
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x14, 0x01, 0x25,  // HEADERS: PRIORITY | FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 255.
-      0xff, 0x00, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x00,
-      0x03, 0x66, 0x6f, 0x6f,
-      0x03, 0x62, 0x61, 0x72,
-    };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(framer.GetHighestPriority());
     syn_stream.set_fin(true);
     syn_stream.SetHeader("", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
     const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
     const unsigned char kV2FrameData[] = {
@@ skipping 15 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       kPri, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x00
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x14, 0x01, 0x25,  // HEADERS: PRIORITY | FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 219.
-      0xdb, 0x00, 0x03, 0x62,
-      0x61, 0x72, 0x03, 0x66,
-      0x6f, 0x6f, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x00,
-    };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(1);
     syn_stream.set_fin(true);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported for SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
 
     const SpdyPriority priority = IsSpdy2() ? 2 : 4;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
@@ skipping 34 matching lines @@
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(priority);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      // Deflate compression doesn't apply to HPACK.
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
+  if (spdy_version_ > SPDY3) {
+    // SYN_REPLY unsupported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x1C,
       0x00, 0x00, 0x00, 0x01,
@@ skipping 10 matching lines @@
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x12, 0x01, 0x04,  // HEADER: END_HEADERS
-      0x00, 0x00, 0x00, 0x01,  // Stream 1
-      0x00, 0x03, 0x62, 0x61,  // @.ba
-      0x72, 0x03, 0x66, 0x6f,  // r.fo
-      0x6f, 0x00, 0x03, 0x66,  // o@.f
-      0x6f, 0x6f, 0x03, 0x62,  // oo.b
-      0x61, 0x72,              // ar
-    };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x19,
@@ skipping 11 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x0f, 0x01, 0x05,  // HEADER: FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x03, 0x66,  // @..f
-      0x6f, 0x6f, 0x00, 0x03,  // oo@.
-      0x66, 0x6f, 0x6f, 0x03,  // foo.
-      0x62, 0x61, 0x72,        // bar
-    };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x19,
@@ skipping 11 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x0f, 0x01, 0x05,  // HEADER: FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x03, 0x62, 0x61,  // @.ba
-      0x72, 0x03, 0x66, 0x6f,  // r.fo
-      0x6f, 0x00, 0x03, 0x66,  // o@.f
-      0x6f, 0x6f, 0x00,        // oo.
-    };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
+  if (spdy_version_ > SPDY3) {
+    // SYN_REPLY unsupported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x32,
       0x00, 0x00, 0x00, 0x01,
@@ skipping 29 matching lines @@
     };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      // Deflate compression doesn't apply to HPACK.
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
@@ skipping 81 matching lines @@
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x0c,
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x07,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x05, 0x04, 0x00,
+      0x00, 0x06, 0x04, 0x00,
       0x00, 0x00, 0x00, 0x00,
-      0x04, 0x0a, 0x0b, 0x0c,
-      0x0d,
+      0x00, 0x04, 0x0a, 0x0b,
+      0x0c, 0x0d,
     };
 
     uint32 kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     SettingsMap settings;
     settings[kId] = SettingsFlagsAndValue(kFlags, kValue);
     EXPECT_EQ(kFlags, settings[kId].first);
@@ skipping 39 matching lines @@
       0x00, 0x00, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x03,  // 3rd Setting
       0x00, 0x00, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,  // 4th Setting
       0x00, 0x00, 0x00, 0x08,
     };
     // These end up seemingly out of order because of the way that our internal
     // ordering for settings_ir works. HTTP2 has no requirement on ordering on
     // the wire.
     const unsigned char kV4FrameData[] = {
-      0x00, 0x14, 0x04, 0x00,
+      0x00, 0x18, 0x04, 0x00,
       0x00, 0x00, 0x00, 0x00,
-      0x03,                    // 3rd Setting
+      0x00, 0x03,              // 3rd Setting
       0x00, 0x00, 0x00, 0x07,
-      0x04,                    // 4th Setting
+      0x00, 0x04,              // 4th Setting
       0x00, 0x00, 0x00, 0x08,
-      0x01,                    // 1st Setting
+      0x00, 0x01,              // 1st Setting
       0x00, 0x00, 0x00, 0x05,
-      0x02,                    // 2nd Setting
+      0x00, 0x02,              // 2nd Setting
       0x00, 0x00, 0x00, 0x06,
     };
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
                            false,  // persist
                            false,  // persisted
                            5);
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
                            false,  // persist
@@ skipping 295 matching lines @@
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
+
+  {
+    const char kDescription[] =
+        "HEADERS frame with a 0-length header val, FIN, max stream ID, pri";
+
+    const unsigned char kV4FrameData[] = {
+      0x00, 0x14, 0x01, 0x25,  // Headers: FIN | END_HEADERS | PRIORITY
+      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
+      0x00, 0x00, 0x00, 0x00,  // parent stream
+      0xdb,                    // weight
+      0x00, 0x03, 0x62, 0x61,  // @.ba
+      0x72, 0x03, 0x66, 0x6f,  // r.fo
+      0x6f, 0x00, 0x03, 0x66,  // o@.f
+      0x6f, 0x6f, 0x00,        // oo.
+    };
+    SpdyHeadersIR headers_ir(0x7fffffff);
+    headers_ir.set_fin(true);
+    headers_ir.set_priority(1);
+    headers_ir.set_has_priority(true);
+    headers_ir.SetHeader("bar", "foo");
+    headers_ir.SetHeader("foo", "");
+    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    if (IsSpdy2() || IsSpdy3()) {
+      // HEADERS with priority not supported.
+    } else {
+      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+    }
+  }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
@@ skipping 207 matching lines @@
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_max_age(5);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("pid1");
   altsvc_ir.set_host("host");
   altsvc_ir.set_origin("origin");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
+TEST_P(SpdyFramerTest, CreatePriority) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+
+  SpdyFramer framer(spdy_version_);
+
+  const char kDescription[] = "PRIORITY frame";
+  const char kType = static_cast<unsigned char>(
+      SpdyConstants::SerializeFrameType(spdy_version_, PRIORITY));
+  const unsigned char kFrameData[] = {
+      0x00, 0x05, kType, 0x00,
+      0x00, 0x00, 0x00, 0x02,  // Stream ID = 2
+      0x80, 0x00, 0x00,  0x01,  // Exclusive dependency, parent stream ID = 1
+      0x10,                     // Weight = 16
+  };
+  SpdyPriorityIR priority_ir(2, 1, 16, true);
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(priority_ir));
+  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+}
+
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
+  if (spdy_version_ > SPDY3) {
+    // SYN_STREAM not supported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
   SpdyHeaderBlock headers = syn_stream.name_value_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
+  if (spdy_version_ > SPDY3) {
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   SpdySynReplyIR syn_reply(1);
   syn_reply.SetHeader("alpha", "beta");
   syn_reply.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = syn_reply.name_value_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynReply(syn_reply));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
@@ skipping 194 matching lines @@
 // 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_);
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.set_fin(true);
-  syn_stream.SetHeader("aa", big_value);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.set_fin(true);
+  headers.SetHeader("aa", big_value);
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
@@ skipping 200 matching lines @@
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x0f, 0x04, 0x00,
+    0x00, 0x12, 0x04, 0x00,
     0x00, 0x00, 0x00, 0x00,
-    0x01,  // 1st Setting
+    0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
-    0x01,  // 2nd (duplicate) Setting
+    0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
-    0x03,  // 3rd (unprocessed) Setting
+    0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, duplicate settings are allowed;
     // each setting replaces the previous value for that setting.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
     EXPECT_EQ(1, visitor.settings_ack_sent_);
   }
 }
 
-// Tests handling of SETTINGS_COMPRESS_DATA.
-TEST_P(SpdyFramerTest, AcceptSettingsCompressData) {
-  if (!IsSpdy4()) { return; }
-  SpdyFramer framer(spdy_version_);
-
-  const unsigned char kFrameData[] = {
-    0x00, 0x05, 0x04, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x00, 0x00,
-    0x01,
-  };
-
-  TestSpdyVisitor visitor(spdy_version_);
-  visitor.use_compression_ = false;
-  visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
-  EXPECT_EQ(1, visitor.setting_count_);
-  EXPECT_EQ(0, visitor.error_count_);
-}
-
 // Tests handling of SETTINGS frame with entries out of order.
 TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x02, 0x00, 0x00, 0x00,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x01, 0x00, 0x00, 0x00,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x03, 0x00, 0x00, 0x00,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x01, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x0f, 0x04, 0x00,
+    0x00, 0x12, 0x04, 0x00,
     0x00, 0x00, 0x00, 0x00,
-    0x02,  // 1st Setting
+    0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
-    0x01,  // 2nd (out of order) Setting
+    0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
-    0x03,  // 3rd (unprocessed) Setting
+    0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
@@ skipping 24 matching lines @@
 
   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_ <= SPDY3) {
     return;
   }
 
-  const int kPaddingLen = 512;  // So we get two bytes for padding length field.
+  const int kPaddingLen = 119;
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyDataIR data_ir(1, StringPiece(data_payload, strlen(data_payload)));
   data_ir.set_padding_len(kPaddingLen);
   scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
   ASSERT_TRUE(frame.get() != NULL);
 
   int bytes_consumed = 0;
 
   // Send the frame header.
   EXPECT_CALL(visitor, OnDataFrameHeader(1,
                                          kPaddingLen + strlen(data_payload),
                                          false));
   CHECK_EQ(8u, framer.ProcessInput(frame->data(), 8));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_PADDING_LENGTH);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 8;
 
-  // Send the first byte of the padding length field.
-  CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
-  CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_PADDING_LENGTH);
-  CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
-  bytes_consumed += 1;
-
-  // Send the second byte of the padding length field.
+  // Send the padding length field.
   CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 1;
 
-  // Send the first two bytes of the data payload.
+  // Send the first two bytes of the data payload, i.e., "he".
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 2, false));
   CHECK_EQ(2u, framer.ProcessInput(frame->data() + bytes_consumed, 2));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 2;
 
-  // Send the rest three bytes of the data payload.
+  // Send the rest three bytes of the data payload, i.e., "llo".
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 3, false));
   CHECK_EQ(3u, framer.ProcessInput(frame->data() + bytes_consumed, 3));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 3;
 
   // Send the first 100 bytes of the padding payload.
   EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 100, false));
   CHECK_EQ(100u, framer.ProcessInput(frame->data() + bytes_consumed, 100));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 100;
 
   // Send rest of the padding payload.
-  EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 410, false));
-  CHECK_EQ(410u, framer.ProcessInput(frame->data() + bytes_consumed, 410));
+  EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 18, false));
+  CHECK_EQ(18u, framer.ProcessInput(frame->data() + bytes_consumed, 18));
   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(SpdyWindowUpdateIR(1, 2)));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
@@ skipping 112 matching lines @@
   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, ReadHeadersWithContinuationAndPadding) {
+TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x14, 0x01, 0x08,  // HEADERS: PAD_LOW
+    0x00, 0x14, 0x01, 0x08,  // HEADERS: PADDED
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x03,                    // Padding of 3.
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
     0x00, 0x00, 0x00,
 
-    0x00, 0x1a, 0x09, 0x18,  // CONTINUATION: PAD_LOW & PAD_HIGH
+    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
-    0x00, 0x04,              // Padding of 4.
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
-    0x00, 0x00, 0x00, 0x00,
 
-    0x00, 0x13, 0x09, 0x0c,  // CONTINUATION: PAD_LOW & END_HEADERS
+    0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
-    0x00,                    // Padding of 0.
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x00, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
     0x75, 0x65,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
@@ skipping 47 matching lines @@
   EXPECT_EQ(2, visitor.continuation_count_);
   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, ReadPushPromiseWithContinuationAndPadding) {
+TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x05, 0x18,  // PUSH_PROMISE: PAD_LOW & PAD_HIGH
+    0x00, 0x17, 0x05, 0x08,  // PUSH_PROMISE: PADDED
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x00, 0x00, 0x2A,  // Promised stream 42
-    0x00, 0x02,              // Padding of 2.
+    0x02,                    // Padding of 2.
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
     0x00, 0x00,
 
-    0x00, 0x14, 0x09, 0x00,  // CONTINUATION:
+    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
 
-    0x00, 0x17, 0x09, 0x0c,  // CONTINUATION: PAD_LOW & END_HEADERS
+    0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
-    0x04,                    // Padding of 4.
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x00, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
-    0x75, 0x65, 0x00, 0x00,
-    0x00, 0x00,
+    0x75, 0x65,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_push_promise_stream_);
   EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(2, visitor.continuation_count_);
@@ skipping 372 matching lines @@
   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",
                SpdyFramer::FrameTypeToString(RST_STREAM));
   EXPECT_STREQ("SETTINGS",
                SpdyFramer::FrameTypeToString(SETTINGS));
-  EXPECT_STREQ("NOOP",
-               SpdyFramer::FrameTypeToString(NOOP));
   EXPECT_STREQ("PING",
                SpdyFramer::FrameTypeToString(PING));
   EXPECT_STREQ("GOAWAY",
                SpdyFramer::FrameTypeToString(GOAWAY));
   EXPECT_STREQ("HEADERS",
                SpdyFramer::FrameTypeToString(HEADERS));
   EXPECT_STREQ("WINDOW_UPDATE",
                SpdyFramer::FrameTypeToString(WINDOW_UPDATE));
   EXPECT_STREQ("PUSH_PROMISE",
                SpdyFramer::FrameTypeToString(PUSH_PROMISE));
@@ skipping 73 matching lines @@
     }
   }
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   uint8 valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
-      DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
+      DATA_FLAG_PADDED;
 
   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);
 
     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.
+      if (flags & DATA_FLAG_PADDED) {
+        // Expect Error since we don't set padded in payload.
         EXPECT_CALL(visitor, OnError(_));
       } else {
         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 & ~valid_data_flags) || (flags & DATA_FLAG_PAD_LOW) ||
-        (flags & DATA_FLAG_PAD_HIGH)) {
+    if ((flags & ~valid_data_flags) || (flags & DATA_FLAG_PADDED)) {
         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, SynStreamFrameFlags) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported in SPDY>3
+    return;
+  }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
 
     SpdySynStreamIR syn_stream(8);
     syn_stream.set_associated_to_stream_id(3);
     syn_stream.set_priority(1);
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     int set_flags = flags;
-    if (IsSpdy4()) {
-      // PRIORITY required for SYN_STREAM simulation.
-      set_flags |= HEADERS_FLAG_PRIORITY;
-
-      // TODO(jgraettinger): Add padding to SynStreamIR, and implement framing.
-      set_flags &= ~HEADERS_FLAG_PAD_LOW;
-      set_flags &= ~HEADERS_FLAG_PAD_HIGH;
-    }
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
-    if (!IsSpdy4() &&
-        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
-      EXPECT_CALL(visitor, OnError(_));
-    } else if (IsSpdy4() &&
-               flags & ~(CONTROL_FLAG_FIN |
-                         HEADERS_FLAG_PRIORITY |
-                         HEADERS_FLAG_END_HEADERS |
-                         HEADERS_FLAG_END_SEGMENT |
-                         HEADERS_FLAG_PAD_LOW |
-                         HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
-      if (IsSpdy4()) {
-        EXPECT_CALL(visitor, OnSynStream(8, 0, 1, flags & CONTROL_FLAG_FIN,
-                                         false));
-      } else {
-        EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
-                                         flags & CONTROL_FLAG_UNIDIRECTIONAL));
-      }
+      EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
+                                       flags & CONTROL_FLAG_UNIDIRECTIONAL));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
           .WillRepeatedly(testing::Return(true));
-      if (flags & DATA_FLAG_FIN && (!IsSpdy4() ||
-                                    flags & HEADERS_FLAG_END_HEADERS)) {
+      if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
-    if (!IsSpdy4() &&
-        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
+    if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
-          << SpdyFramer::ErrorCodeToString(framer.error_code());
-    } else if (IsSpdy4() &&
-        flags & ~(CONTROL_FLAG_FIN |
-                  HEADERS_FLAG_PRIORITY |
-                  HEADERS_FLAG_END_HEADERS |
-                  HEADERS_FLAG_END_SEGMENT |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
-      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, SynReplyFrameFlags) {
-  if (IsSpdy4()) {
-    // Covered by HEADERS case.
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_REPLY not supported in SPDY>3
     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);
 
     SpdySynReplyIR syn_reply(37);
@@ skipping 168 matching lines @@
     } 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, HeadersFrameFlags) {
   for (int flags = 0; flags < 256; ++flags) {
-    if (IsSpdy4() && flags & HEADERS_FLAG_PRIORITY) {
-      // Covered by SYN_STREAM case.
-      continue;
-    }
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
+    if (IsSpdy4() && (flags & HEADERS_FLAG_PRIORITY)) {
+      headers_ir.set_priority(3);
+      headers_ir.set_has_priority(true);
+    }
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     int set_flags = flags;
     if (IsSpdy4()) {
       // TODO(jgraettinger): Add padding to SpdyHeadersIR,
       // and implement framing.
-      set_flags &= ~HEADERS_FLAG_PAD_LOW;
-      set_flags &= ~HEADERS_FLAG_PAD_HIGH;
+      set_flags &= ~HEADERS_FLAG_PADDED;
     }
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
     if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else if (IsSpdy4() && flags & ~(CONTROL_FLAG_FIN |
                                       HEADERS_FLAG_END_HEADERS |
                                       HEADERS_FLAG_END_SEGMENT |
-                                      HEADERS_FLAG_PAD_LOW |
-                                      HEADERS_FLAG_PAD_HIGH)) {
+                                      HEADERS_FLAG_PADDED |
+                                      HEADERS_FLAG_PRIORITY)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
-      EXPECT_CALL(visitor, OnHeaders(57,
-                                     flags & CONTROL_FLAG_FIN,
-                                     (flags & HEADERS_FLAG_END_HEADERS) ||
-                                      !IsSpdy4()));
+      if (spdy_version_ > SPDY3 && flags & HEADERS_FLAG_PRIORITY) {
+        EXPECT_CALL(visitor, OnSynStream(57,        // stream id
+                                         0,         // associated stream id
+                                         3,         // priority
+                                         flags & CONTROL_FLAG_FIN,
+                                         false));  // unidirectional
+      } else {
+        EXPECT_CALL(visitor, OnHeaders(57,
+                                       flags & CONTROL_FLAG_FIN,
+                                       (flags & HEADERS_FLAG_END_HEADERS) ||
+                                        !IsSpdy4()));
+      }
       EXPECT_CALL(visitor, OnControlFrameHeaderData(57, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN  && (!IsSpdy4() ||
                                      flags & HEADERS_FLAG_END_HEADERS)) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
     if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else if (IsSpdy4() && flags & ~(CONTROL_FLAG_FIN |
                                       HEADERS_FLAG_END_HEADERS |
                                       HEADERS_FLAG_END_SEGMENT |
-                                      HEADERS_FLAG_PAD_LOW |
-                                      HEADERS_FLAG_PAD_HIGH)) {
+                                      HEADERS_FLAG_PADDED |
+                                      HEADERS_FLAG_PRIORITY)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else if (IsSpdy4() && ~(flags & HEADERS_FLAG_END_HEADERS)) {
       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_RESET, framer.state());
@@ skipping 85 matching lines @@
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, PUSH_PROMISE, _, _));
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.SetHeader("foo", "bar");
     scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
     // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
     // and implement framing.
-    int set_flags = flags & ~HEADERS_FLAG_PAD_LOW & ~HEADERS_FLAG_PAD_HIGH;
+    int set_flags = flags & ~HEADERS_FLAG_PADDED;
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
-    if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, PUSH_PROMISE, _));
       EXPECT_CALL(visitor, OnPushPromise(42, 57,
           flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
           .WillRepeatedly(testing::Return(true));
     }
 
     framer.ProcessInput(frame->data(), frame->size());
-    if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED)) {
       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());
     }
   }
@@ skipping 22 matching lines @@
 
     SpdyHeadersIR headers_ir(42);
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame0(framer.SerializeHeaders(headers_ir));
     SetFrameFlags(frame0.get(), 0, spdy_version_);
 
     SpdyContinuationIR continuation(42);
     continuation.SetHeader("foo", "bar");
     scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializeContinuation(continuation));
-    // TODO(jgraettinger): Add padding to the eventual continuation
-    // serialization implementation.
-    int set_flags = flags & ~HEADERS_FLAG_PAD_LOW & ~HEADERS_FLAG_PAD_HIGH;
-    SetFrameFlags(frame.get(), set_flags, spdy_version_);
+    SetFrameFlags(frame.get(), flags, spdy_version_);
 
-    if (flags & ~(HEADERS_FLAG_END_HEADERS |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(HEADERS_FLAG_END_HEADERS)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _));
       EXPECT_CALL(visitor, OnContinuation(42,
                                           flags & HEADERS_FLAG_END_HEADERS));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
           .WillRepeatedly(testing::Return(true));
     }
 
     framer.ProcessInput(frame0->data(), frame0->size());
     framer.ProcessInput(frame->data(), frame->size());
-    if (flags & ~(HEADERS_FLAG_END_HEADERS |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(HEADERS_FLAG_END_HEADERS)) {
       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());
     }
   }
 }
 
 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)
 
 TEST_P(SpdyFramerTest, EmptySynStream) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported in SPDY>3.
+    return;
+  }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   testing::StrictMock<test::MockDebugVisitor> debug_visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
   framer.set_debug_visitor(&debug_visitor);
 
   EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
 
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
@@ skipping 358 matching lines @@
   EXPECT_EQ(443u, visitor.test_altsvc_ir_.port());
   EXPECT_EQ("protocolid", visitor.test_altsvc_ir_.protocol_id());
   EXPECT_EQ("hostname", visitor.test_altsvc_ir_.host());
 }
 
 // Tests handling of PRIORITY frames.
 TEST_P(SpdyFramerTest, ReadPriority) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
+  SpdyFramer framer(spdy_version_);
+  SpdyPriorityIR priority(3, 1, 255, false);
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializePriority(priority));
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  framer.set_visitor(&visitor);
+  EXPECT_CALL(visitor, OnPriority(3, 1, 255, false));
+  framer.ProcessInput(frame->data(), frame->size());
 
-  const unsigned char kFrameData[] = {
-    0x00, 0x05, 0x02, 0x00,  // PRIORITY frame
-    0x00, 0x00, 0x00, 0x03,  // stream ID 3
-    0x00, 0x00, 0x00, 0x01,  // dependent on stream id 1
-    0x00                     // weight 0
-  };
-
-  TestSpdyVisitor visitor(spdy_version_);
-  visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
-
-  EXPECT_EQ(SpdyFramer::SPDY_RESET, visitor.framer_.state());
-  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, visitor.framer_.error_code())
-      << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
+  // TODO(mlavan): once we actually maintain a priority tree,
+  // check that state is adjusted correctly.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
@@ skipping 37 matching lines @@
   EXPECT_EQ(4u, framer.MapWeightToPriority(109));
   EXPECT_EQ(4u, framer.MapWeightToPriority(74));
   EXPECT_EQ(5u, framer.MapWeightToPriority(73));
   EXPECT_EQ(5u, framer.MapWeightToPriority(37));
   EXPECT_EQ(6u, framer.MapWeightToPriority(36));
   EXPECT_EQ(6u, framer.MapWeightToPriority(1));
   EXPECT_EQ(7u, framer.MapWeightToPriority(0));
 }
 
 }  // namespace net