Land recent SPDY changes

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 72 matching lines @@
 SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(int version,
                                                       uint32 wire) {
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return SettingsFlagsAndId(ntohl(wire) >> 24, ntohl(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
     : flags_(flags), id_(id & 0x00ffffff) {
-  LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large.";
+  LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large: " << id;
 }
 
 uint32 SettingsFlagsAndId::GetWireFormat(int version) const {
   uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
@@ skipping 50 matching lines @@
   previous_state_ = SPDY_RESET;
   error_code_ = SPDY_NO_ERROR;
   remaining_data_length_ = 0;
   remaining_control_header_ = 0;
   current_frame_buffer_length_ = 0;
   current_frame_type_ = DATA;
   current_frame_flags_ = 0;
   current_frame_length_ = 0;
   current_frame_stream_id_ = kInvalidStream;
   settings_scratch_.Reset();
+  remaining_padding_payload_length_ = 0;
+  remaining_padding_length_fields_ = 0;
 }
 
 size_t SpdyFramer::GetDataFrameMinimumSize() const {
   // Size, in bytes, of the data frame header. Future versions of SPDY
   // will likely vary this, so we allow for the flexibility of a function call
   // for this value as opposed to a constant.
   return 8;
 }
 
 // Size, in bytes, of the control frame header.
 size_t SpdyFramer::GetControlFrameHeaderSize() const {
   switch (protocol_version()) {
     case SPDY2:
     case SPDY3:
     case SPDY4:
       return 8;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
   // name-value block.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 2 * 4 (stream IDs) + 1 (priority)
     // + 1 (unused, was credential slot)
     return GetControlFrameHeaderSize() + 10;
   } else {
     // Calculated as:
     // frame prefix + 4 (priority)
     return GetControlFrameHeaderSize() + 4;
   }
 }
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
   // name-value block.
   size_t size = GetControlFrameHeaderSize();
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream IDs)
     size += 4;
   }
 
   // In SPDY 2, there were 2 unused bytes before payload.
-  if (protocol_version() < 3) {
+  if (protocol_version() < SPDY3) {
     size += 2;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetRstStreamMinimumSize() const {
   // Size, in bytes, of a RST_STREAM frame.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream id) + 4 (status code)
     return GetControlFrameHeaderSize() + 8;
   } else {
     // Calculated as:
     // frame prefix + 4 (status code)
     return GetControlFrameHeaderSize() + 4;
   }
 }
 
 size_t SpdyFramer::GetSettingsMinimumSize() const {
   // Size, in bytes, of a SETTINGS frame not including the IDs and values
   // from the variable-length value block. Calculated as:
   // control frame header + 4 (number of ID/value pairs)
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     return GetControlFrameHeaderSize() + 4;
   } else {
     return GetControlFrameHeaderSize();
   }
 }
 
 size_t SpdyFramer::GetPingSize() const {
   // Size, in bytes, of this PING frame.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (id)
     return GetControlFrameHeaderSize() + 4;
   } else {
     // Calculated as:
     // control frame header + 8 (id)
     return GetControlFrameHeaderSize() + 8;
   }
 }
 
@@ skipping 10 matching lines @@
     size += 4;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetHeadersMinimumSize() const  {
   // Size, in bytes, of a HEADERS frame not including the variable-length
   // name-value block.
   size_t size = GetControlFrameHeaderSize();
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream IDs)
     size += 4;
   }
 
   // In SPDY 2, there were 2 unused bytes before payload.
-  if (protocol_version() < 3) {
+  if (protocol_version() <= SPDY2) {
     size += 2;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetWindowUpdateSize() const {
   // Size, in bytes, of a WINDOW_UPDATE frame.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream id) + 4 (delta)
     return GetControlFrameHeaderSize() + 8;
   } else {
     // Calculated as:
     // frame prefix + 4 (delta)
     return GetControlFrameHeaderSize() + 4;
   }
 }
 
@@ skipping 15 matching lines @@
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetControlFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return std::min(GetDataFrameMinimumSize(), GetControlFrameHeaderSize());
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
-  if (protocol_version() < 4) {
+  if (protocol_version() <= SPDY3) {
     // 24-bit length field plus eight-byte frame header.
     return ((1<<24) - 1) + 8;
   } else {
     // 14-bit length field.
     return (1<<14) - 1;
   }
 }
 
 size_t SpdyFramer::GetDataFrameMaximumPayload() const {
   return GetFrameMaximumSize() - GetDataFrameMinimumSize();
 }
 
 const char* SpdyFramer::StateToString(int state) {
   switch (state) {
     case SPDY_ERROR:
       return "ERROR";
     case SPDY_AUTO_RESET:
       return "AUTO_RESET";
     case SPDY_RESET:
       return "RESET";
     case SPDY_READING_COMMON_HEADER:
       return "READING_COMMON_HEADER";
     case SPDY_CONTROL_FRAME_PAYLOAD:
       return "CONTROL_FRAME_PAYLOAD";
+    case SPDY_READ_PADDING_LENGTH:
+      return "SPDY_READ_PADDING_LENGTH";
+    case SPDY_CONSUME_PADDING:
+      return "SPDY_CONSUME_PADDING";
     case SPDY_IGNORE_REMAINING_PAYLOAD:
       return "IGNORE_REMAINING_PAYLOAD";
     case SPDY_FORWARD_STREAM_FRAME:
       return "FORWARD_STREAM_FRAME";
     case SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK:
       return "SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK";
     case SPDY_CONTROL_FRAME_HEADER_BLOCK:
       return "SPDY_CONTROL_FRAME_HEADER_BLOCK";
     case SPDY_GOAWAY_FRAME_PAYLOAD:
       return "SPDY_GOAWAY_FRAME_PAYLOAD";
@@ skipping 156 matching lines @@
 
       case SPDY_SETTINGS_FRAME_PAYLOAD: {
         int bytes_read = ProcessSettingsFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
       case SPDY_CONTROL_FRAME_HEADER_BLOCK: {
         int bytes_read = ProcessControlFrameHeaderBlock(
-            data, len, spdy_version_ >= 4 ? true : false);
+            data, len, protocol_version() > SPDY3);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
       case SPDY_RST_STREAM_FRAME_PAYLOAD: {
         size_t bytes_read = ProcessRstStreamFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
       case SPDY_GOAWAY_FRAME_PAYLOAD: {
         size_t bytes_read = ProcessGoAwayFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
       case SPDY_CONTROL_FRAME_PAYLOAD: {
         size_t bytes_read = ProcessControlFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
+      case SPDY_READ_PADDING_LENGTH: {
+        size_t bytes_read = ProcessFramePaddingLength(data, len);
+        len -= bytes_read;
+        data += bytes_read;
+        break;
+      }
+
+      case SPDY_CONSUME_PADDING: {
+        size_t bytes_read = ProcessFramePadding(data, len);
+        len -= bytes_read;
+        data += bytes_read;
+        break;
+      }
+
       case SPDY_IGNORE_REMAINING_PAYLOAD:
         // control frame has too-large payload
         // intentional fallthrough
       case SPDY_FORWARD_STREAM_FRAME: {
         size_t bytes_read = ProcessDataFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
       default:
@@ skipping 42 matching lines @@
       new SpdyFrameReader(current_frame_buffer_.get(),
                           current_frame_buffer_length_));
 
   uint16 version = 0;
   bool is_control_frame = false;
 
   uint16 control_frame_type_field = DATA;
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
-  if (protocol_version() < 4) {
+  if (protocol_version() <= SPDY3) {
     bool successful_read = reader->ReadUInt16(&version);
     DCHECK(successful_read);
     is_control_frame = (version & kControlFlagMask) != 0;
     version &= ~kControlFlagMask;  // Only valid for control frames.
 
     if (is_control_frame) {
       // We check control_frame_type_field's validity in
       // ProcessControlFrameHeader().
       successful_read = reader->ReadUInt16(&control_frame_type_field);
     } else {
       reader->Rewind();
       successful_read = reader->ReadUInt31(&current_frame_stream_id_);
     }
     DCHECK(successful_read);
 
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     uint32 length_field = 0;
     successful_read = reader->ReadUInt24(&length_field);
     DCHECK(successful_read);
     remaining_data_length_ = length_field;
     current_frame_length_ = remaining_data_length_ + reader->GetBytesConsumed();
   } else {
     version = protocol_version();
     uint16 length_field = 0;
     bool successful_read = reader->ReadUInt16(&length_field);
     DCHECK(successful_read);
-    current_frame_length_ = length_field;
 
     uint8 control_frame_type_field_uint8 = DATA;
     successful_read = reader->ReadUInt8(&control_frame_type_field_uint8);
     DCHECK(successful_read);
     // We check control_frame_type_field's validity in
     // ProcessControlFrameHeader().
     control_frame_type_field = control_frame_type_field_uint8;
     is_control_frame = (control_frame_type_field != DATA);
 
+    if (is_control_frame) {
+      current_frame_length_ = length_field + GetControlFrameHeaderSize();
+    } else {
+      current_frame_length_ = length_field + GetDataFrameMinimumSize();
+    }
+
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     successful_read = reader->ReadUInt31(&current_frame_stream_id_);
     DCHECK(successful_read);
 
     remaining_data_length_ = current_frame_length_ - reader->GetBytesConsumed();
 
     // Before we accept a DATA frame, we need to make sure we're not in the
     // middle of processing a header block.
-    if (expect_continuation_ != 0 && control_frame_type_field != CONTINUATION) {
-      DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
-                  << "frame, but instead received frame type "
-                  << current_frame_type_;
-      set_error(SPDY_UNEXPECTED_FRAME);
-      return original_len - len;
-    } else if (control_frame_type_field == CONTINUATION &&
-               expect_continuation_ == 0) {
-      DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
+    const bool is_continuation_frame = (control_frame_type_field ==
+        SpdyConstants::SerializeFrameType(protocol_version(), CONTINUATION));
+    if ((expect_continuation_ != 0) != is_continuation_frame) {
+      if (expect_continuation_ != 0) {
+        DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
+                    << "frame, but instead received frame type "
+                    << control_frame_type_field;
+      } else {
+        DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
+      }
       set_error(SPDY_UNEXPECTED_FRAME);
       return original_len - len;
     }
   }
   DCHECK_EQ(is_control_frame ? GetControlFrameHeaderSize()
                              : GetDataFrameMinimumSize(),
             reader->GetBytesConsumed());
   DCHECK_EQ(current_frame_length_,
             remaining_data_length_ + reader->GetBytesConsumed());
 
   // This is just a sanity check for help debugging early frame errors.
   if (remaining_data_length_ > 1000000u) {
     // The strncmp for 5 is safe because we only hit this point if we
     // have kMinCommonHeader (8) bytes
     if (!syn_frame_processed_ &&
         strncmp(current_frame_buffer_.get(), "HTTP/", 5) == 0) {
       LOG(WARNING) << "Unexpected HTTP response to " << display_protocol_
                    << " request";
       probable_http_response_ = true;
     } else {
       LOG(WARNING) << "Unexpectedly large frame.  " << display_protocol_
                    << " session is likely corrupt.";
     }
   }
 
   // if we're here, then we have the common header all received.
   if (!is_control_frame) {
-    if (protocol_version() >= 4) {
+    if (protocol_version() > SPDY3) {
       // Catch bogus tests sending oversized DATA frames.
       DCHECK_GE(GetFrameMaximumSize(), current_frame_length_)
           << "DATA frame too large for SPDY >= 4.";
     }
 
-    if (current_frame_flags_ & ~DATA_FLAG_FIN) {
+    uint8 valid_data_flags = 0;
+    if (protocol_version() > SPDY3) {
+      valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
+          DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
+    } else {
+      valid_data_flags = DATA_FLAG_FIN;
+    }
+
+    if (current_frame_flags_ & ~valid_data_flags) {
       set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
     } else {
       visitor_->OnDataFrameHeader(current_frame_stream_id_,
                                   remaining_data_length_,
                                   current_frame_flags_ & DATA_FLAG_FIN);
       if (remaining_data_length_ > 0) {
-        CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
+        CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
       } else {
         // Empty data frame.
         if (current_frame_flags_ & DATA_FLAG_FIN) {
           visitor_->OnStreamFrameData(
               current_frame_stream_id_, NULL, 0, true);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
     }
-  } else if (version != spdy_version_) {
+  } else if (version != protocol_version()) {
     // We check version before we check validity: version can never be
     // 'invalid', it can only be unsupported.
     DVLOG(1) << "Unsupported SPDY version " << version
-             << " (expected " << spdy_version_ << ")";
+             << " (expected " << protocol_version() << ")";
     set_error(SPDY_UNSUPPORTED_VERSION);
   } else {
     ProcessControlFrameHeader(control_frame_type_field);
   }
 
   return original_len - len;
 }
 
 void SpdyFramer::ProcessControlFrameHeader(uint16 control_frame_type_field) {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
   DCHECK_LE(GetControlFrameHeaderSize(), current_frame_buffer_length_);
 
-  if (control_frame_type_field < FIRST_CONTROL_TYPE ||
-      control_frame_type_field > LAST_CONTROL_TYPE) {
+  // Early detection of deprecated frames that we ignore.
+  if (protocol_version() <= SPDY3) {
+    if (control_frame_type_field == NOOP) {
+      current_frame_type_ = NOOP;
+      DVLOG(1) << "NOOP control frame found. Ignoring.";
+      CHANGE_STATE(SPDY_AUTO_RESET);
+      return;
+    }
+
+    if (control_frame_type_field == CREDENTIAL) {
+      current_frame_type_ = CREDENTIAL;
+      DCHECK_EQ(SPDY3, protocol_version());
+      DVLOG(1) << "CREDENTIAL control frame found. Ignoring.";
+      CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
+      return;
+    }
+  }
+
+  if (!SpdyConstants::IsValidFrameType(protocol_version(),
+                                       control_frame_type_field)) {
+    DLOG(WARNING) << "Invalid control frame type " << control_frame_type_field
+                  << " (protocol version: " << protocol_version() << ")";
     set_error(SPDY_INVALID_CONTROL_FRAME);
     return;
   }
 
-  current_frame_type_ = static_cast<SpdyFrameType>(control_frame_type_field);
-
-  if (current_frame_type_ == NOOP) {
-    DVLOG(1) << "NOOP control frame found. Ignoring.";
-    CHANGE_STATE(SPDY_AUTO_RESET);
-    return;
-  }
-
-  if (current_frame_type_ == CREDENTIAL) {
-    DCHECK_EQ(3, protocol_version());
-    DVLOG(1) << "CREDENTIAL control frame found. Ignoring.";
-    CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
-    return;
-  }
+  current_frame_type_ = SpdyConstants::ParseFrameType(protocol_version(),
+                                                      control_frame_type_field);
 
   // Do some sanity checking on the control frame sizes and flags.
   switch (current_frame_type_) {
     case SYN_STREAM:
-      DCHECK_GT(4, spdy_version_);
       if (current_frame_length_ < GetSynStreamMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ &
                  ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SYN_REPLY:
       if (current_frame_length_ < GetSynReplyMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ & ~CONTROL_FLAG_FIN) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case RST_STREAM:
       // For SPDY versions < 4, the header has a fixed length.
       // For SPDY version 4 and up, the RST_STREAM frame may include optional
       // opaque data, so we only have a lower limit on the frame size.
       if ((current_frame_length_ != GetRstStreamMinimumSize() &&
-           protocol_version() < 4) ||
+           protocol_version() <= SPDY3) ||
           (current_frame_length_ < GetRstStreamMinimumSize() &&
-           protocol_version() >= 4)) {
+           protocol_version() > SPDY3)) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SETTINGS:
     {
       // Make sure that we have an integral number of 8-byte key/value pairs,
       // plus a 4-byte length field in SPDY3 and below.
-      size_t values_prefix_size = (protocol_version() < 4 ? 4 : 0);
+      size_t values_prefix_size = (protocol_version() <= SPDY3 ? 4 : 0);
       // Size of each key/value pair in bytes.
-      size_t setting_size = (protocol_version() < 4 ? 8 : 5);
+      size_t setting_size = (protocol_version() <= SPDY3 ? 8 : 5);
       if (current_frame_length_ < GetSettingsMinimumSize() ||
           (current_frame_length_ - GetControlFrameHeaderSize())
           % setting_size != values_prefix_size) {
         DLOG(WARNING) << "Invalid length for SETTINGS frame: "
                       << current_frame_length_;
         set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if (protocol_version() < 4 &&
+      } else if (protocol_version() <= SPDY3 &&
                  current_frame_flags_ &
                  ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-      } else if (protocol_version() >= 4 &&
+      } else if (protocol_version() > SPDY3 &&
                  current_frame_flags_ & ~SETTINGS_FLAG_ACK) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-      } else if (protocol_version() >= 4 &&
+      } else if (protocol_version() > SPDY3 &&
                  current_frame_flags_ & SETTINGS_FLAG_ACK &&
                  current_frame_length_ > GetSettingsMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       }
       break;
     }
     case PING:
       if (current_frame_length_ != GetPingSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if ((protocol_version() < 4 && current_frame_flags_ != 0) ||
+      } else if ((protocol_version() <= SPDY3 && current_frame_flags_ != 0) ||
                  (current_frame_flags_ & ~PING_FLAG_ACK)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case GOAWAY:
       {
         // For SPDY version < 4, there are only mandatory fields and the header
         // has a fixed length. For SPDY version >= 4, optional opaque data may
         // be appended to the GOAWAY frame, thus there is only a minimal length
         // restriction.
         if ((current_frame_length_ != GetGoAwayMinimumSize() &&
-             protocol_version() < 4) ||
+             protocol_version() <= SPDY3) ||
             (current_frame_length_ < GetGoAwayMinimumSize() &&
-             protocol_version() >= 4)) {
+             protocol_version() > SPDY3)) {
           set_error(SPDY_INVALID_CONTROL_FRAME);
         } else if (current_frame_flags_ != 0) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
         }
         break;
       }
     case HEADERS:
       {
         size_t min_size = GetHeadersMinimumSize();
-        if (spdy_version_ > 3 &&
+        if (protocol_version() > SPDY3 &&
             (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
           min_size += 4;
         }
         if (current_frame_length_ < min_size) {
           set_error(SPDY_INVALID_CONTROL_FRAME);
-        } else if (spdy_version_ < 4 &&
+        } else if (protocol_version() <= SPDY3 &&
                    current_frame_flags_ & ~CONTROL_FLAG_FIN) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-        } else if (spdy_version_ >= 4 && current_frame_flags_ &
+        } else if (protocol_version() > SPDY3 && current_frame_flags_ &
                    ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
                      HEADERS_FLAG_END_HEADERS)) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
         }
       }
       break;
     case WINDOW_UPDATE:
       if (current_frame_length_ != GetWindowUpdateSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case BLOCKED:
       if (current_frame_length_ != GetBlockedSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case PUSH_PROMISE:
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if (spdy_version_ < 4 && current_frame_flags_ != 0) {
+      } else if (protocol_version() <= SPDY3 && current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-      } else if (spdy_version_ >= 4 && current_frame_flags_ &
+      } else if (protocol_version() > SPDY3 && current_frame_flags_ &
                  ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CONTINUATION:
-      if (current_frame_length_ < GetContinuationMinimumSize() ||
-          protocol_version() < 4) {
+      if (current_frame_length_ < GetContinuationMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ & ~HEADERS_FLAG_END_HEADERS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     default:
       LOG(WARNING) << "Valid " << display_protocol_
                    << " control frame with unhandled type: "
                    << current_frame_type_;
       // This branch should be unreachable because of the frame type bounds
@@ skipping 35 matching lines @@
       break;
     case SYN_REPLY:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynReplyMinimumSize();
       break;
     case SETTINGS:
       frame_size_without_variable_data = GetSettingsMinimumSize();
       break;
     case HEADERS:
       frame_size_without_variable_data = GetHeadersMinimumSize();
-      if (spdy_version_ > 3 && current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
+      if (protocol_version() > SPDY3 &&
+          current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
         frame_size_without_variable_data += 4;  // priority
       }
       break;
     case PUSH_PROMISE:
       frame_size_without_variable_data = GetPushPromiseMinimumSize();
       break;
     case CONTINUATION:
       frame_size_without_variable_data = GetContinuationMinimumSize();
       break;
     default:
@@ skipping 264 matching lines @@
   }
 
   if (remaining_control_header_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.get(),
                            current_frame_buffer_length_);
     reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
 
     switch (current_frame_type_) {
       case SYN_STREAM:
         {
-          DCHECK_GT(4, spdy_version_);
+          DCHECK_GE(SPDY3, protocol_version());
           bool successful_read = true;
-          if (spdy_version_ < 4) {
-            successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-            DCHECK(successful_read);
-          }
+          successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+          DCHECK(successful_read);
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
 
           SpdyStreamId associated_to_stream_id = kInvalidStream;
           successful_read = reader.ReadUInt31(&associated_to_stream_id);
           DCHECK(successful_read);
 
           SpdyPriority priority = 0;
           successful_read = reader.ReadUInt8(&priority);
           DCHECK(successful_read);
-          if (protocol_version() < 3) {
+          if (protocol_version() <= SPDY2) {
             priority = priority >> 6;
           } else {
             priority = priority >> 5;
           }
 
          // Seek past unused byte; used to be credential slot in SPDY 3.
          reader.Seek(1);
 
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
           }
           visitor_->OnSynStream(
               current_frame_stream_id_,
               associated_to_stream_id,
               priority,
               (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
               (current_frame_flags_ & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case SETTINGS:
-        if (spdy_version_ >= 4 && current_frame_flags_ & SETTINGS_FLAG_ACK) {
+        if (protocol_version() > SPDY3 &&
+            current_frame_flags_ & SETTINGS_FLAG_ACK) {
           visitor_->OnSettingsAck();
           CHANGE_STATE(SPDY_AUTO_RESET);
         } else {
           visitor_->OnSettings(current_frame_flags_ &
               SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS);
           CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
         }
         break;
       case SYN_REPLY:
       case HEADERS:
         // SYN_REPLY and HEADERS are the same, save for the visitor call.
         {
-          if (spdy_version_ > 3) {
+          if (protocol_version() > SPDY3) {
             DCHECK_EQ(HEADERS, current_frame_type_);
           }
           bool successful_read = true;
-          if (spdy_version_ < 4) {
+          if (protocol_version() <= SPDY3) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
-          if (protocol_version() < 3) {
+          if (protocol_version() <= SPDY2) {
             // SPDY 2 had two unused bytes here. Seek past them.
             reader.Seek(2);
           }
-          if (spdy_version_ > 3 &&
+          if (protocol_version() > SPDY3 &&
              !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
              current_frame_type_ == HEADERS) {
             expect_continuation_ = current_frame_stream_id_;
             end_stream_when_done_ = current_frame_flags_ & CONTROL_FLAG_FIN;
           }
           const bool has_priority =
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
           uint32 priority = 0;
-          if (protocol_version() > 3 && has_priority) {
+          if (protocol_version() > SPDY3 && has_priority) {
             successful_read = reader.ReadUInt31(&priority);
             DCHECK(successful_read);
           }
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             // SPDY 4 reports HEADERS with PRIORITY as SYN_STREAM.
             SpdyFrameType reported_type = current_frame_type_;
-            if (protocol_version() > 3 && has_priority) {
+            if (protocol_version() > SPDY3 && has_priority) {
               reported_type = SYN_STREAM;
             }
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 reported_type,
                 current_frame_length_);
           }
           if (current_frame_type_ == SYN_REPLY) {
             visitor_->OnSynReply(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
-          } else if (spdy_version_ > 3 &&
+          } else if (protocol_version() > SPDY3 &&
               current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
             // SPDY 4+ is missing SYN_STREAM. Simulate it so that API changes
             // can be made independent of wire changes.
             visitor_->OnSynStream(
                 current_frame_stream_id_,
                 0,  // associated_to_stream_id
                 priority,
                 current_frame_flags_ & CONTROL_FLAG_FIN,
                 false);  // unidirectional
           } else {
             visitor_->OnHeaders(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
                 expect_continuation_ == 0);
           }
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case PUSH_PROMISE:
         {
-          DCHECK_LE(4, protocol_version());
+          DCHECK_LT(SPDY3, protocol_version());
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           SpdyStreamId promised_stream_id = kInvalidStream;
           bool successful_read = reader.ReadUInt31(&promised_stream_id);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           if (promised_stream_id == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 68 matching lines @@
   size_t process_bytes = std::min(data_len, remaining_data_length_);
   if (is_hpack_header_block) {
     if (!hpack_decoder_.HandleControlFrameHeadersData(current_frame_stream_id_,
                                                       data,
                                                       process_bytes)) {
       // TODO(jgraettinger): Finer-grained HPACK error codes.
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   } else if (process_bytes > 0) {
-    if (enable_compression_ && spdy_version_ < 4) {
+    if (enable_compression_ && protocol_version() <= SPDY3) {
       processed_successfully = IncrementallyDecompressControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     } else {
       processed_successfully = IncrementallyDeliverControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     }
   }
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
@@ skipping 36 matching lines @@
   return process_bytes;
 }
 
 size_t SpdyFramer::ProcessSettingsFramePayload(const char* data,
                                                size_t data_len) {
   DCHECK_EQ(SPDY_SETTINGS_FRAME_PAYLOAD, state_);
   DCHECK_EQ(SETTINGS, current_frame_type_);
   size_t unprocessed_bytes = std::min(data_len, remaining_data_length_);
   size_t processed_bytes = 0;
 
-  size_t setting_size = spdy_version_ < 4 ? 8 : 5;
+  size_t setting_size = protocol_version() <= SPDY3 ? 8 : 5;
 
   // Loop over our incoming data.
   while (unprocessed_bytes > 0) {
     // Process up to one setting at a time.
     size_t processing = std::min(
         unprocessed_bytes,
         static_cast<size_t>(setting_size - settings_scratch_.setting_buf_len));
 
     // Check if we have a complete setting in our input.
     if (processing == setting_size) {
@@ skipping 29 matching lines @@
   remaining_data_length_ -= processed_bytes;
   if (remaining_data_length_ == 0) {
     visitor_->OnSettingsEnd();
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
 
   return processed_bytes;
 }
 
 void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
-  DCHECK_GE(spdy_version_, SPDY4);
-  DCHECK_EQ(remaining_data_length_, 0u);
+  DCHECK_LT(SPDY3, protocol_version());
+  DCHECK_EQ(0u, remaining_data_length_);
 
   const SpdyNameValueBlock& block = hpack_decoder_.decoded_block();
   if (block.empty()) {
     // Special-case this to make tests happy.
     ProcessControlFrameHeaderBlock(NULL, 0, false);
     return;
   }
   SpdyFrameBuilder builder(
       GetSerializedLength(protocol_version(), &block));
 
   SerializeNameValueBlockWithoutCompression(&builder, block);
   scoped_ptr<SpdyFrame> frame(builder.take());
 
   remaining_data_length_ = frame->size();
   ProcessControlFrameHeaderBlock(frame->data(), frame->size(), false);
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
+  int id_field;
   SpdySettingsIds id;
   uint8 flags = 0;
   uint32 value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     const uint32 id_and_flags_wire = *(reinterpret_cast<const uint32*>(data));
     SettingsFlagsAndId id_and_flags =
-      SettingsFlagsAndId::FromWireFormat(spdy_version_, id_and_flags_wire);
-    id = static_cast<SpdySettingsIds>(id_and_flags.id());
+      SettingsFlagsAndId::FromWireFormat(protocol_version(), id_and_flags_wire);
+    id_field = id_and_flags.id();
     flags = id_and_flags.flags();
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 4)));
   } else {
-    id = static_cast<SpdySettingsIds>(*(reinterpret_cast<const uint8*>(data)));
+    id_field = *(reinterpret_cast<const uint8*>(data));
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 1)));
   }
 
   // Validate id.
-  switch (id) {
-    case SETTINGS_UPLOAD_BANDWIDTH:
-    case SETTINGS_DOWNLOAD_BANDWIDTH:
-    case SETTINGS_ROUND_TRIP_TIME:
-    case SETTINGS_MAX_CONCURRENT_STREAMS:
-    case SETTINGS_CURRENT_CWND:
-    case SETTINGS_DOWNLOAD_RETRANS_RATE:
-    case SETTINGS_INITIAL_WINDOW_SIZE:
-      // Valid values.
-      break;
-    default:
-      DLOG(WARNING) << "Unknown SETTINGS ID: " << id;
-      return false;
+  if (!SpdyConstants::IsValidSettingId(protocol_version(), id_field)) {
+    DLOG(WARNING) << "Unknown SETTINGS ID: " << id_field;
+    return false;
   }
+  id = SpdyConstants::ParseSettingId(protocol_version(), id_field);
 
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     // Detect duplicates.
-    if (static_cast<uint32>(id) <= settings_scratch_.last_setting_id) {
+    if (id <= settings_scratch_.last_setting_id) {
       DLOG(WARNING) << "Duplicate entry or invalid ordering for id " << id
                     << " in " << display_protocol_ << " SETTINGS frame "
                     << "(last setting id was "
                     << settings_scratch_.last_setting_id << ").";
       return false;
     }
     settings_scratch_.last_setting_id = id;
 
     // Validate flags.
     uint8 kFlagsMask = SETTINGS_FLAG_PLEASE_PERSIST | SETTINGS_FLAG_PERSISTED;
@@ skipping 16 matching lines @@
   remaining_data_length_ -= bytes_read;
   if (remaining_data_length_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.get(),
                            current_frame_buffer_length_);
     reader.Seek(GetControlFrameHeaderSize());  // Skip frame header.
 
     // Use frame-specific handlers.
     switch (current_frame_type_) {
       case PING: {
           SpdyPingId id = 0;
-          bool is_ack =
-              spdy_version_ >= 4 && (current_frame_flags_ & PING_FLAG_ACK);
+          bool is_ack = protocol_version() > SPDY3 &&
+              (current_frame_flags_ & PING_FLAG_ACK);
           bool successful_read = true;
-          if (spdy_version_ < 4) {
+          if (protocol_version() <= SPDY3) {
             uint32 id32 = 0;
             successful_read = reader.ReadUInt32(&id32);
             id = id32;
           } else {
             successful_read = reader.ReadUInt64(&id);
           }
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnPing(id, is_ack);
         }
         break;
       case WINDOW_UPDATE: {
           uint32 delta_window_size = 0;
           bool successful_read = true;
-          if (spdy_version_ < 4) {
+          if (protocol_version() <= SPDY3) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           successful_read = reader.ReadUInt32(&delta_window_size);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnWindowUpdate(current_frame_stream_id_,
                                    delta_window_size);
         }
         break;
       case BLOCKED: {
-          DCHECK_LE(4, protocol_version());
+          DCHECK_LT(SPDY3, protocol_version());
           DCHECK(reader.IsDoneReading());
           visitor_->OnBlocked(current_frame_stream_id_);
         }
         break;
       default:
         // Unreachable.
         LOG(FATAL) << "Unhandled control frame " << current_frame_type_;
     }
 
     CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
@@ skipping 23 matching lines @@
     if (current_frame_buffer_length_ == header_size) {
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.get(),
                              current_frame_buffer_length_);
       reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
       bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
       DCHECK(successful_read);
 
       // In SPDYv3 and up, frames also specify a status code - parse it out.
       SpdyGoAwayStatus status = GOAWAY_OK;
-      if (spdy_version_ >= 3) {
+      if (protocol_version() >= SPDY3) {
         uint32 status_raw = GOAWAY_OK;
         successful_read = reader.ReadUInt32(&status_raw);
         DCHECK(successful_read);
         // We've read an unsigned integer, so it's enough to only check
         // upper bound to ensure the value is in valid range.
         if (status_raw < GOAWAY_NUM_STATUS_CODES) {
           status = static_cast<SpdyGoAwayStatus>(status_raw);
         } else {
           // TODO(hkhalil): Probably best to OnError here, depending on
           // our interpretation of the spec. Keeping with existing liberal
@@ skipping 40 matching lines @@
   if (!already_parsed_header) {
     // Buffer the new RST_STREAM header bytes we got.
     UpdateCurrentFrameBuffer(&data, &len, unread_header_bytes);
 
     // Do we have enough to parse the constant size RST_STREAM header?
     if (current_frame_buffer_length_ == header_size) {
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.get(),
                              current_frame_buffer_length_);
       reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
-      if (protocol_version() < 4) {
+      if (protocol_version() <= SPDY3) {
         bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
         DCHECK(successful_read);
       }
 
       SpdyRstStreamStatus status = RST_STREAM_INVALID;
       uint32 status_raw = status;
       bool successful_read = reader.ReadUInt32(&status_raw);
       DCHECK(successful_read);
       // We've read an unsigned integer, so it's enough to only check
       // upper bound to ensure the value is in valid range.
@@ skipping 19 matching lines @@
   if (!processed_successfully) {
     set_error(SPDY_RST_STREAM_FRAME_CORRUPT);
   } else if (remaining_data_length_ == 0) {
     // Signal that there is not more opaque data.
     visitor_->OnRstStreamFrameData(NULL, 0);
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len;
 }
 
+size_t SpdyFramer::ProcessFramePaddingLength(const char* data, size_t len) {
+  DCHECK_EQ(SPDY_READ_PADDING_LENGTH, state_);
+
+  size_t original_len = len;
+  if (remaining_padding_length_fields_ == 0) {
+    DCHECK_EQ(remaining_padding_payload_length_, 0u);
+    bool pad_low = false;
+    bool pad_high = false;
+    if (current_frame_flags_ & net::DATA_FLAG_PAD_LOW) {
+      pad_low = true;
+      ++remaining_padding_length_fields_;
+    }
+    if (current_frame_flags_ & net::DATA_FLAG_PAD_HIGH) {
+      pad_high = true;
+      ++remaining_padding_length_fields_;
+    }
+    if ((pad_high && !pad_low) ||
+        remaining_data_length_ < remaining_padding_length_fields_) {
+      set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
+      return 0;
+    }
+  }
+
+  // Parse the padding length.
+  while (len != 0 && remaining_padding_length_fields_ != 0) {
+    remaining_padding_payload_length_ =
+        (remaining_padding_payload_length_ << 8) +
+        *reinterpret_cast<const uint8*>(data);
+    ++data;
+    --len;
+    --remaining_padding_length_fields_;
+    --remaining_data_length_;
+  }
+
+  if (remaining_padding_length_fields_ == 0) {
+    if (remaining_padding_payload_length_ > remaining_data_length_) {
+      set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
+      return 0;
+    }
+    CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
+  }
+  return original_len - len;
+}
+
+size_t SpdyFramer::ProcessFramePadding(const char* data, size_t len) {
+  DCHECK_EQ(SPDY_CONSUME_PADDING, state_);
+
+  size_t original_len = len;
+  if (remaining_padding_payload_length_ > 0) {
+    DCHECK_EQ(remaining_padding_payload_length_, remaining_data_length_);
+    size_t amount_to_discard = std::min(remaining_padding_payload_length_, len);
+    // The visitor needs to know about padding so it can send window updates.
+    // Communicate the padding to the visitor through a NULL data pointer, with
+    // a nonzero size.
+    if (amount_to_discard) {
+      visitor_->OnStreamFrameData(
+          current_frame_stream_id_, NULL, amount_to_discard, false);
+    }
+    data += amount_to_discard;
+    len -= amount_to_discard;
+    remaining_padding_payload_length_ -= amount_to_discard;
+    remaining_data_length_ -= amount_to_discard;
+
+    // If the FIN flag is set, and there is no more data in this data
+    // frame, inform the visitor of EOF via a 0-length data frame.
+    if (!remaining_data_length_ && current_frame_flags_ & DATA_FLAG_FIN) {
+      visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
+    }
+  }
+
+  if (remaining_data_length_ == 0) {
+    CHANGE_STATE(SPDY_AUTO_RESET);
+  }
+  return original_len - len;
+}
+
 size_t SpdyFramer::ProcessDataFramePayload(const char* data, size_t len) {
   size_t original_len = len;
-
-  if (remaining_data_length_ > 0) {
-    size_t amount_to_forward = std::min(remaining_data_length_, len);
+  if (remaining_data_length_ - remaining_padding_payload_length_ > 0) {
+    size_t amount_to_forward = std::min(
+        remaining_data_length_ - remaining_padding_payload_length_, len);
     if (amount_to_forward && state_ != SPDY_IGNORE_REMAINING_PAYLOAD) {
       // Only inform the visitor if there is data.
       if (amount_to_forward) {
         visitor_->OnStreamFrameData(
             current_frame_stream_id_, data, amount_to_forward, false);
       }
     }
     data += amount_to_forward;
     len -= amount_to_forward;
     remaining_data_length_ -= amount_to_forward;
 
     // If the FIN flag is set, and there is no more data in this data
     // frame, inform the visitor of EOF via a 0-length data frame.
     if (!remaining_data_length_ && current_frame_flags_ & DATA_FLAG_FIN) {
       visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
     }
   }
 
-  if (remaining_data_length_ == 0) {
-    CHANGE_STATE(SPDY_AUTO_RESET);
+  if (remaining_data_length_ == remaining_padding_payload_length_) {
+    CHANGE_STATE(SPDY_CONSUME_PADDING);
   }
   return original_len - len;
 }
 
 size_t SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
                                           size_t header_length,
                                           SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
   uint32 num_headers;
-  if (spdy_version_ < 3) {
+  if (protocol_version() <= SPDY2) {
     uint16 temp;
     if (!reader.ReadUInt16(&temp)) {
       DVLOG(1) << "Unable to read number of headers.";
       return 0;
     }
     num_headers = temp;
   } else {
     if (!reader.ReadUInt32(&num_headers)) {
       DVLOG(1) << "Unable to read number of headers.";
       return 0;
     }
   }
 
   // Read each header.
   for (uint32 index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
-    if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
+    if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return 0;
     }
     std::string name = temp.as_string();
 
     // Read header value.
-    if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
+    if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
       return 0;
     }
     std::string value = temp.as_string();
 
     // Ensure no duplicates.
     if (block->find(name) != block->end()) {
       DVLOG(1) << "Duplicate header '" << name << "' (" << index + 1 << " of "
                << num_headers << ").";
       return 0;
     }
 
     // Store header.
     (*block)[name] = value;
   }
   return reader.GetBytesConsumed();
 }
 
-SpdySerializedFrame* SpdyFramer::SerializeData(const SpdyDataIR& data) const {
-  const size_t kSize = GetDataFrameMinimumSize() + data.data().length();
-
-  SpdyDataFlags flags = DATA_FLAG_NONE;
-  if (data.fin()) {
+SpdySerializedFrame* SpdyFramer::SerializeData(const SpdyDataIR& datair) const {
+  uint8 flags = DATA_FLAG_NONE;
+  if (datair.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
-  SpdyFrameBuilder builder(kSize);
-  builder.WriteDataFrameHeader(*this, data.stream_id(), flags);
-  builder.WriteBytes(data.data().data(), data.data().length());
-  DCHECK_EQ(kSize, builder.length());
-  return builder.take();
+  if (protocol_version() > SPDY3) {
+    int num_padding_fields = 0;
+    if (datair.pad_low()) {
+      flags |= DATA_FLAG_PAD_LOW;
+      ++num_padding_fields;
+    }
+    if (datair.pad_high()) {
+      flags |= DATA_FLAG_PAD_HIGH;
+      ++num_padding_fields;
+    }
+
+    const size_t size_with_padding = num_padding_fields +
+        datair.data().length() + datair.padding_payload_len() +
+        GetDataFrameMinimumSize();
+    SpdyFrameBuilder builder(size_with_padding);
+    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
+    if (datair.pad_high()) {
+      builder.WriteUInt8(datair.padding_payload_len() >> 8);
+    }
+    if (datair.pad_low()) {
+      builder.WriteUInt8(datair.padding_payload_len() & 0xff);
+    }
+    builder.WriteBytes(datair.data().data(), datair.data().length());
+    if (datair.padding_payload_len() > 0) {
+      string padding = string(datair.padding_payload_len(), '0');
+      builder.WriteBytes(padding.data(), padding.length());
+    }
+    DCHECK_EQ(size_with_padding, builder.length());
+    return builder.take();
+  } else {
+    const size_t size = GetDataFrameMinimumSize() + datair.data().length();
+    SpdyFrameBuilder builder(size);
+    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
+    builder.WriteBytes(datair.data().data(), datair.data().length());
+    DCHECK_EQ(size, builder.length());
+    return builder.take();
+  }
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeDataFrameHeader(
     const SpdyDataIR& data) const {
   const size_t kSize = GetDataFrameMinimumSize();
 
-  SpdyDataFlags flags = DATA_FLAG_NONE;
+  uint8 flags = DATA_FLAG_NONE;
   if (data.fin()) {
     flags = DATA_FLAG_FIN;
   }
+  if (protocol_version() > SPDY3) {
+    if (data.pad_low()) {
+      flags |= DATA_FLAG_PAD_LOW;
+    }
+    if (data.pad_high()) {
+      flags |= DATA_FLAG_PAD_HIGH;
+    }
+  }
 
   SpdyFrameBuilder builder(kSize);
   builder.WriteDataFrameHeader(*this, data.stream_id(), flags);
-  if (protocol_version() < 4) {
-    builder.OverwriteLength(*this, data.data().length());
-  } else {
-    builder.OverwriteLength(*this, data.data().length() + kSize);
-  }
+  builder.OverwriteLength(*this, data.data().length());
   DCHECK_EQ(kSize, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (syn_stream.unidirectional()) {
     // TODO(hkhalil): invalid for HTTP2.
     flags |= CONTROL_FLAG_UNIDIRECTIONAL;
   }
   // In SPDY >= 4, SYN_STREAM frames are HEADERS frames, but for now
   // we never expect to have to overflow into a CONTINUATION frame.
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     flags |= HEADERS_FLAG_PRIORITY;
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // Sanitize priority.
   uint8 priority = syn_stream.priority();
   if (priority > GetLowestPriority()) {
     DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynStreamMinimumSize();
 
   string hpack_encoding;
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     hpack_encoder_.EncodeHeaderSet(syn_stream.name_value_block(),
                                    &hpack_encoding);
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_stream.name_value_block());
   }
 
   SpdyFrameBuilder builder(size);
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
     builder.WriteUInt32(syn_stream.stream_id());
     builder.WriteUInt32(syn_stream.associated_to_stream_id());
-    builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
+    builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
     builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
   } else {
     builder.WriteFramePrefix(*this,
                              HEADERS,
                              flags,
                              syn_stream.stream_id());
     builder.WriteUInt32(priority);
   }
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_stream);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = spdy_version_ >= 4 ? hpack_encoding.size() :
+    const size_t payload_len = protocol_version() > SPDY3 ?
+        hpack_encoding.size() :
         GetSerializedLength(protocol_version(),
                             &(syn_stream.name_value_block()));
     // SPDY 4 reports this compression as a SYN_STREAM compression.
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     const SpdySynReplyIR& syn_reply) {
   uint8 flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   // In SPDY >= 4, SYN_REPLY frames are HEADERS frames, but for now
   // we never expect to have to overflow into a CONTINUATION frame.
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynReplyMinimumSize();
 
   string hpack_encoding;
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     hpack_encoder_.EncodeHeaderSet(syn_reply.name_value_block(),
                                    &hpack_encoding);
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_reply.name_value_block());
   }
 
   SpdyFrameBuilder builder(size);
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
     builder.WriteUInt32(syn_reply.stream_id());
   } else {
     builder.WriteFramePrefix(*this,
                              HEADERS,
                              flags,
                              syn_reply.stream_id());
   }
-  if (protocol_version() < 3) {
+  if (protocol_version() < SPDY3) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_reply);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = spdy_version_ >= 4 ? hpack_encoding.size() :
+    const size_t payload_len = protocol_version() > SPDY3 ?
+        hpack_encoding.size() :
         GetSerializedLength(protocol_version(),
                             &(syn_reply.name_value_block()));
     debug_visitor_->OnSendCompressedFrame(syn_reply.stream_id(),
                                           SYN_REPLY,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
   // TODO(jgraettinger): For now, Chromium will support parsing RST_STREAM
   // payloads, but will not emit them. SPDY4 is used for draft HTTP/2,
   // which doesn't currently include RST_STREAM payloads. GFE flags have been
   // commented but left in place to simplify future patching.
   // Compute the output buffer size, taking opaque data into account.
   uint16 expected_length = GetRstStreamMinimumSize();
-  if (protocol_version() >= 4) {
+  if (protocol_version() > SPDY3) {
     expected_length += rst_stream.description().size();
   }
   SpdyFrameBuilder builder(expected_length);
 
   // Serialize the RST_STREAM frame.
-  if (protocol_version() < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, RST_STREAM, 0);
     builder.WriteUInt32(rst_stream.stream_id());
   } else {
     builder.WriteFramePrefix(*this, RST_STREAM, 0, rst_stream.stream_id());
   }
 
   builder.WriteUInt32(rst_stream.status());
 
   // In SPDY4 and up, RST_STREAM frames may also specify opaque data.
-  if (protocol_version() >= 4 && rst_stream.description().size() > 0) {
+  if (protocol_version() > SPDY3 && rst_stream.description().size() > 0) {
     builder.WriteBytes(rst_stream.description().data(),
                        rst_stream.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSettings(
     const SpdySettingsIR& settings) const {
   uint8 flags = 0;
 
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     if (settings.clear_settings()) {
       flags |= SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
     }
   } else {
     if (settings.is_ack()) {
       flags |= SETTINGS_FLAG_ACK;
     }
   }
   const SpdySettingsIR::ValueMap* values = &(settings.values());
 
-  size_t setting_size = (protocol_version() < 4 ? 8 : 5);
+  size_t setting_size = (protocol_version() <= SPDY3 ? 8 : 5);
   // Size, in bytes, of this SETTINGS frame.
   const size_t size = GetSettingsMinimumSize() +
                       (values->size() * setting_size);
   SpdyFrameBuilder builder(size);
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SETTINGS, flags);
   } else {
     builder.WriteFramePrefix(*this, SETTINGS, flags, 0);
   }
 
   // If this is an ACK, payload should be empty.
-  if (spdy_version_ >= 4 && settings.is_ack()) {
+  if (protocol_version() > SPDY3 && settings.is_ack()) {
     return builder.take();
   }
 
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteUInt32(values->size());
   }
   DCHECK_EQ(GetSettingsMinimumSize(), builder.length());
   for (SpdySettingsIR::ValueMap::const_iterator it = values->begin();
        it != values->end();
        ++it) {
-    if (spdy_version_ < 4) {
+    if (protocol_version() <= SPDY3) {
       uint8 setting_flags = 0;
       if (it->second.persist_value) {
         setting_flags |= SETTINGS_FLAG_PLEASE_PERSIST;
       }
       if (it->second.persisted) {
         setting_flags |= SETTINGS_FLAG_PERSISTED;
       }
-      SettingsFlagsAndId flags_and_id(setting_flags, it->first);
+      SettingsFlagsAndId flags_and_id(
+          setting_flags,
+          SpdyConstants::SerializeSettingId(protocol_version(), it->first));
       uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
       builder.WriteBytes(&id_and_flags_wire, 4);
     } else {
-      builder.WriteUInt8(static_cast<uint8>(it->first));
+      builder.WriteUInt8(SpdyConstants::SerializeSettingId(protocol_version(),
+                                                           it->first));
     }
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializeBlocked(const SpdyBlockedIR& blocked) const {
-  DCHECK_LE(4, protocol_version());
+  DCHECK_LT(SPDY3, protocol_version());
   SpdyFrameBuilder builder(GetBlockedSize());
   builder.WriteFramePrefix(*this, BLOCKED, kNoFlags, blocked.stream_id());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
   SpdyFrameBuilder builder(GetPingSize());
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, PING, kNoFlags);
     builder.WriteUInt32(static_cast<uint32>(ping.id()));
   } else {
     uint8 flags = 0;
     if (ping.is_ack()) {
       flags |= PING_FLAG_ACK;
     }
     builder.WriteFramePrefix(*this, PING, flags, 0);
     builder.WriteUInt64(ping.id());
   }
   DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeGoAway(
     const SpdyGoAwayIR& goaway) const {
 
   // Compute the output buffer size, take opaque data into account.
   uint16 expected_length = GetGoAwayMinimumSize();
-  if (protocol_version() >= 4) {
+  if (protocol_version() > SPDY3) {
     expected_length += goaway.description().size();
   }
   SpdyFrameBuilder builder(expected_length);
 
   // Serialize the GOAWAY frame.
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, GOAWAY, kNoFlags);
   } else {
     builder.WriteFramePrefix(*this, GOAWAY, 0, 0);
   }
 
   // GOAWAY frames specify the last good stream id for all SPDY versions.
   builder.WriteUInt32(goaway.last_good_stream_id());
 
   // In SPDY3 and up, GOAWAY frames also specify the error status code.
-  if (protocol_version() >= 3) {
+  if (protocol_version() >= SPDY3) {
     builder.WriteUInt32(goaway.status());
   }
 
   // In SPDY4 and up, GOAWAY frames may also specify opaque data.
-  if ((protocol_version() >= 4) && (goaway.description().size() > 0)) {
+  if ((protocol_version() > SPDY3) && (goaway.description().size() > 0)) {
     builder.WriteBytes(goaway.description().data(),
                        goaway.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     const SpdyHeadersIR& headers) {
   uint8 flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     if (headers.end_headers()) {
       flags |= HEADERS_FLAG_END_HEADERS;
     }
     if (headers.has_priority()) {
       flags |= HEADERS_FLAG_PRIORITY;
     }
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetHeadersMinimumSize();
 
   uint32 priority = headers.priority();
   if (headers.has_priority()) {
     if (priority > GetLowestPriority()) {
       DLOG(DFATAL) << "Priority out-of-bounds.";
       priority = GetLowestPriority();
     }
     size += 4;
   }
 
   string hpack_encoding;
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     hpack_encoder_.EncodeHeaderSet(headers.name_value_block(), &hpack_encoding);
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(headers.name_value_block());
   }
 
   SpdyFrameBuilder builder(size);
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, HEADERS, flags);
     builder.WriteUInt32(headers.stream_id());
   } else {
     builder.WriteFramePrefix(*this,
                              HEADERS,
                              flags,
                              headers.stream_id());
     if (headers.has_priority()) {
       builder.WriteUInt32(priority);
     }
   }
-  if (protocol_version() < 3) {
+  if (protocol_version() <= SPDY2) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, headers);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = spdy_version_ >= 4 ? hpack_encoding.size() :
+    const size_t payload_len = protocol_version() > SPDY3 ?
+        hpack_encoding.size() :
         GetSerializedLength(protocol_version(),
                             &(headers.name_value_block()));
     debug_visitor_->OnSendCompressedFrame(headers.stream_id(),
                                           HEADERS,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeWindowUpdate(
     const SpdyWindowUpdateIR& window_update) const {
   SpdyFrameBuilder builder(GetWindowUpdateSize());
-  if (spdy_version_ < 4) {
+  if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, WINDOW_UPDATE, kNoFlags);
     builder.WriteUInt32(window_update.stream_id());
   } else {
     builder.WriteFramePrefix(*this,
                              WINDOW_UPDATE,
                              kNoFlags,
                              window_update.stream_id());
   }
   builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
-  DCHECK_LE(4, protocol_version());
+  DCHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   if (push_promise.end_push_promise()) {
     flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   }
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   string hpack_encoding;
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     hpack_encoder_.EncodeHeaderSet(push_promise.name_value_block(),
                                    &hpack_encoding);
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(push_promise.name_value_block());
   }
 
   SpdyFrameBuilder builder(size);
   builder.WriteFramePrefix(*this, PUSH_PROMISE, flags,
       push_promise.stream_id());
   builder.WriteUInt32(push_promise.promised_stream_id());
   DCHECK_EQ(GetPushPromiseMinimumSize(), builder.length());
 
-  if (spdy_version_ >= 4) {
+  if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, push_promise);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = spdy_version_ >= 4 ? hpack_encoding.size() :
+    const size_t payload_len = protocol_version() > SPDY3 ?
+        hpack_encoding.size() :
         GetSerializedLength(protocol_version(),
                             &(push_promise.name_value_block()));
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
         PUSH_PROMISE, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 // TODO(jgraettinger): This implementation is incorrect. The continuation
 // frame continues a previously-begun HPACK encoding; it doesn't begin a
 // new one. Figure out whether it makes sense to keep SerializeContinuation().
 SpdyFrame* SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) {
-  CHECK_GE(spdy_version_, 4);
+  CHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   if (continuation.end_headers()) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetContinuationMinimumSize();
   string hpack_encoding;
   hpack_encoder_.EncodeHeaderSet(continuation.name_value_block(),
                                  &hpack_encoding);
@@ skipping 71 matching lines @@
 
 }  // namespace
 
 SpdySerializedFrame* SpdyFramer::SerializeFrame(const SpdyFrameIR& frame) {
   FrameSerializationVisitor visitor(this);
   frame.Visit(&visitor);
   return visitor.ReleaseSerializedFrame();
 }
 
 size_t SpdyFramer::GetSerializedLength(const SpdyHeaderBlock& headers) {
-  CHECK_LT(spdy_version_, 4);
+  CHECK_GE(SPDY3, protocol_version());
   const size_t uncompressed_length =
     GetSerializedLength(protocol_version(), &headers);
   if (!enable_compression_) {
     return uncompressed_length;
   }
   z_stream* compressor = GetHeaderCompressor();
   // Since we'll be performing lots of flushes when compressing the data,
   // zlib's lower bounds may be insufficient.
   return 2 * deflateBound(compressor, uncompressed_length);
 }
@@ skipping 19 matching lines @@
   header_compressor_.reset(new z_stream);
   memset(header_compressor_.get(), 0, sizeof(z_stream));
 
   int success = deflateInit2(header_compressor_.get(),
                              kCompressorLevel,
                              Z_DEFLATED,
                              kCompressorWindowSizeInBits,
                              kCompressorMemLevel,
                              Z_DEFAULT_STRATEGY);
   if (success == Z_OK) {
-    const char* dictionary = (spdy_version_ < 3) ? kV2Dictionary
-                                                 : kV3Dictionary;
-    const int dictionary_size = (spdy_version_ < 3) ? kV2DictionarySize
-                                                    : kV3DictionarySize;
+    const char* dictionary = (protocol_version() <= SPDY2) ?
+        kV2Dictionary : kV3Dictionary;
+    const int dictionary_size = (protocol_version() <= SPDY2) ?
+        kV2DictionarySize : kV3DictionarySize;
     success = deflateSetDictionary(header_compressor_.get(),
                                    reinterpret_cast<const Bytef*>(dictionary),
                                    dictionary_size);
   }
   if (success != Z_OK) {
     LOG(WARNING) << "deflateSetDictionary failure: " << success;
     header_compressor_.reset(NULL);
     return NULL;
   }
   return header_compressor_.get();
@@ skipping 39 matching lines @@
   // If we get a SYN_STREAM/SYN_REPLY/HEADERS frame with stream ID zero, we
   // signal an error back in ProcessControlFrameBeforeHeaderBlock.  So if we've
   // reached this method successfully, stream_id should be nonzero.
   DCHECK_LT(0u, stream_id);
   while (decomp->avail_in > 0 && processed_successfully) {
     decomp->next_out = reinterpret_cast<Bytef*>(buffer);
     decomp->avail_out = arraysize(buffer);
 
     int rv = inflate(decomp, Z_SYNC_FLUSH);
     if (rv == Z_NEED_DICT) {
-      const char* dictionary = (spdy_version_ < 3) ? kV2Dictionary
-                                                   : kV3Dictionary;
-      const int dictionary_size = (spdy_version_ < 3) ? kV2DictionarySize
-                                                      : kV3DictionarySize;
+      const char* dictionary = (protocol_version() <= SPDY2) ? kV2Dictionary
+                                                             : kV3Dictionary;
+      const int dictionary_size = (protocol_version() <= SPDY2) ?
+          kV2DictionarySize : kV3DictionarySize;
       const DictionaryIds& ids = g_dictionary_ids.Get();
-      const uLong dictionary_id = (spdy_version_ < 3) ? ids.v2_dictionary_id
-                                                      : ids.v3_dictionary_id;
+      const uLong dictionary_id = (protocol_version() <= SPDY2) ?
+          ids.v2_dictionary_id : ids.v3_dictionary_id;
       // Need to try again with the right dictionary.
       if (decomp->adler == dictionary_id) {
         rv = inflateSetDictionary(decomp,
                                   reinterpret_cast<const Bytef*>(dictionary),
                                   dictionary_size);
         if (rv == Z_OK)
           rv = inflate(decomp, Z_SYNC_FLUSH);
       }
     }
 
@@ skipping 37 matching lines @@
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
 }
 
 void SpdyFramer::SerializeNameValueBlockWithoutCompression(
     SpdyFrameBuilder* builder,
     const SpdyNameValueBlock& name_value_block) const {
   // Serialize number of headers.
-  if (protocol_version() < 3) {
+  if (protocol_version() <= SPDY2) {
     builder->WriteUInt16(name_value_block.size());
   } else {
     builder->WriteUInt32(name_value_block.size());
   }
 
   // Serialize each header.
   for (SpdyHeaderBlock::const_iterator it = name_value_block.begin();
        it != name_value_block.end();
        ++it) {
-    if (protocol_version() < 3) {
+    if (protocol_version() <= SPDY2) {
       builder->WriteString(it->first);
       builder->WriteString(it->second);
     } else {
       builder->WriteStringPiece32(it->first);
       builder->WriteStringPiece32(it->second);
     }
   }
 }
 
 void SpdyFramer::SerializeNameValueBlock(
     SpdyFrameBuilder* builder,
     const SpdyFrameWithNameValueBlockIR& frame) {
-  CHECK_LT(spdy_version_, 4);
+  CHECK_GE(SPDY3, protocol_version());
   if (!enable_compression_) {
     return SerializeNameValueBlockWithoutCompression(builder,
                                                      frame.name_value_block());
   }
 
   // First build an uncompressed version to be fed into the compressor.
   const size_t uncompressed_len = GetSerializedLength(
       protocol_version(), &(frame.name_value_block()));
   SpdyFrameBuilder uncompressed_builder(uncompressed_len);
   SerializeNameValueBlockWithoutCompression(&uncompressed_builder,
@@ skipping 47 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net