Remove enum SpdyMajorVersion.

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 98 matching lines @@
 #else
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
     DCHECK(state_ != SPDY_ERROR);                               \
     DCHECK_EQ(previous_state_, state_);                         \
     previous_state_ = state_;                                   \
     state_ = newstate;                                          \
   } while (false)
 #endif
 
-SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(SpdyMajorVersion version,
-                                                      uint32_t wire) {
+SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(uint32_t wire) {
   return SettingsFlagsAndId(base::NetToHost32(wire) >> 24,
                             base::NetToHost32(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8_t flags, uint32_t id)
     : flags_(flags), id_(id & 0x00ffffff) {
   SPDY_BUG_IF(id > (1u << 24)) << "HTTP2 setting ID too large: " << id;
 }
 
-uint32_t SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version) const {
+uint32_t SettingsFlagsAndId::GetWireFormat() const {
   return base::HostToNet32(id_ & 0x00ffffff) | base::HostToNet32(flags_ << 24);
 }
 
 bool SpdyFramerVisitorInterface::OnGoAwayFrameData(const char* goaway_data,
                                                    size_t len) {
   return true;
 }
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
     const char* rst_stream_data,
     size_t len) {
   return true;
 }
 
-SpdyFramer::SpdyFramer(SpdyMajorVersion version,
-                       SpdyFramer::DecoderAdapterFactoryFn adapter_factory)
+SpdyFramer::SpdyFramer(SpdyFramer::DecoderAdapterFactoryFn adapter_factory)
     : current_frame_buffer_(kControlFrameBufferSize),
       expect_continuation_(0),
       visitor_(NULL),
       debug_visitor_(NULL),
       header_handler_(nullptr),
-      protocol_version_(version),
       enable_compression_(true),
       probable_http_response_(false),
       end_stream_when_done_(false) {
-  DCHECK(protocol_version_ == HTTP2);
   // TODO(bnc): The way kMaxControlFrameSize is currently interpreted, it
   // includes the frame header, whereas kSpdyInitialFrameSizeLimit does not.
   // Therefore this assertion is unnecessarily strict.
   static_assert(kMaxControlFrameSize <= kSpdyInitialFrameSizeLimit,
                 "Our send limit should be at most our receive limit");
   Reset();
 
-  if (version == HTTP2 && adapter_factory != nullptr) {
+  if (adapter_factory != nullptr) {
     decoder_adapter_ = adapter_factory(this);
   }
 }
 
-SpdyFramer::SpdyFramer(SpdyMajorVersion version)
-    : SpdyFramer(version, &DecoderAdapterFactory) {}
+SpdyFramer::SpdyFramer() : SpdyFramer(&DecoderAdapterFactory) {}
 
 SpdyFramer::~SpdyFramer() {
 }
 
 void SpdyFramer::Reset() {
   if (decoder_adapter_ != nullptr) {
     decoder_adapter_->Reset();
   }
   state_ = SPDY_READY_FOR_FRAME;
   previous_state_ = SPDY_READY_FOR_FRAME;
@@ skipping 47 matching lines @@
 }
 
 SpdyFramer::SpdyState SpdyFramer::state() const {
   if (decoder_adapter_ != nullptr) {
     return decoder_adapter_->state();
   }
   return state_;
 }
 
 size_t SpdyFramer::GetDataFrameMinimumSize() const {
-  return SpdyConstants::GetDataFrameMinimumSize(protocol_version_);
+  return SpdyConstants::kDataFrameMinimumSize;
 }
 
 // Size, in bytes, of the control frame header.
 size_t SpdyFramer::GetFrameHeaderSize() const {
-  return SpdyConstants::GetFrameHeaderSize(protocol_version_);
+  return SpdyConstants::kFrameHeaderSize;
 }
 
 // TODO(jamessynge): Rename this to GetRstStreamSize as the frame is fixed size.
 size_t SpdyFramer::GetRstStreamMinimumSize() const {
   // Size, in bytes, of a RST_STREAM frame.
   // Calculated as:
   // frame prefix + 4 (status code)
   return GetFrameHeaderSize() + 4;
 }
 
@@ skipping 23 matching lines @@
 }
 
 size_t SpdyFramer::GetWindowUpdateSize() const {
   // Size, in bytes, of a WINDOW_UPDATE frame.
   // Calculated as:
   // frame prefix + 4 (delta)
   return GetFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetBlockedSize() const {
-  DCHECK_EQ(HTTP2, protocol_version_);
   // Size, in bytes, of a BLOCKED frame.
   // The BLOCKED frame has no payload beyond the control frame header.
   return GetFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetPushPromiseMinimumSize() const {
-  DCHECK_EQ(HTTP2, protocol_version_);
   // Size, in bytes, of a PUSH_PROMISE frame, sans the embedded header block.
   // Calculated as frame prefix + 4 (promised stream id)
   return GetFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetContinuationMinimumSize() const {
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetFrameHeaderSize();
 }
@@ skipping 11 matching lines @@
   // Size, in bytes, of a PRIORITY frame.
   return GetFrameHeaderSize() + kPriorityDependencyPayloadSize +
          kPriorityWeightPayloadSize;
 }
 
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return GetFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
-  if (protocol_version_ == HTTP2) {
-    return send_frame_size_limit_ +
-           SpdyConstants::GetFrameHeaderSize(protocol_version_);
-  } else {
-    return SpdyConstants::GetMaxFrameSizeLimit(protocol_version_);
-  }
+  return send_frame_size_limit_ + SpdyConstants::kFrameHeaderSize;
 }
 
 size_t SpdyFramer::GetDataFrameMaximumPayload() const {
-  if (protocol_version_ == HTTP2) {
-    return std::min(kMaxDataPayloadSendSize,
-                    GetFrameMaximumSize() - GetDataFrameMinimumSize());
-  } else {
-    return GetFrameMaximumSize() - GetDataFrameMinimumSize();
-  }
+  return std::min(kMaxDataPayloadSendSize,
+                  GetFrameMaximumSize() - GetDataFrameMinimumSize());
 }
 
 const char* SpdyFramer::StateToString(int state) {
   switch (state) {
     case SPDY_ERROR:
       return "ERROR";
     case SPDY_FRAME_COMPLETE:
       return "FRAME_COMPLETE";
     case SPDY_READY_FOR_FRAME:
       return "READY_FOR_FRAME";
@@ skipping 199 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, protocol_version_ == HTTP2);
+        int bytes_read = ProcessControlFrameHeaderBlock(data, len);
         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;
@@ skipping 87 matching lines @@
     : buffer(8), last_setting_id(-1) {}
 
 void SpdyFramer::SpdySettingsScratch::Reset() {
   buffer.Rewind();
   last_setting_id = -1;
 }
 
 SpdyFrameType SpdyFramer::ValidateFrameHeader(bool is_control_frame,
                                               int frame_type_field,
                                               size_t payload_length_field) {
-  if (!SpdyConstants::IsValidFrameType(protocol_version_, frame_type_field)) {
-    // In HTTP2 we ignore unknown frame types for extensibility, as long as
+  if (!SpdyConstants::IsValidFrameType(frame_type_field)) {
+    // We ignore unknown frame types for extensibility, as long as
     // the rest of the control frame header is valid.
     // We rely on the visitor to check validity of current_frame_stream_id_.
     bool valid_stream =
         visitor_->OnUnknownFrame(current_frame_stream_id_, frame_type_field);
     if (expect_continuation_) {
       // Report an unexpected frame error and close the connection
       // if we expect a continuation and receive an unknown frame.
       DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
                   << "frame, but instead received an unknown frame of type "
                   << frame_type_field;
       set_error(SPDY_UNEXPECTED_FRAME);
     } else if (!valid_stream) {
       // Report an invalid frame error and close the stream if the
       // stream_id is not valid.
       DLOG(WARNING) << "Unknown control frame type " << frame_type_field
                     << " received on invalid stream "
                     << current_frame_stream_id_;
       set_error(SPDY_INVALID_CONTROL_FRAME);
     } else {
       DVLOG(1) << "Ignoring unknown frame type.";
       CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
     }
     return DATA;
   }
 
-  SpdyFrameType frame_type =
-      SpdyConstants::ParseFrameType(protocol_version_, frame_type_field);
+  SpdyFrameType frame_type = SpdyConstants::ParseFrameType(frame_type_field);
 
-  if (protocol_version_ == HTTP2) {
-    if (!SpdyConstants::IsValidHTTP2FrameStreamId(current_frame_stream_id_,
-                                                  frame_type)) {
-      DLOG(ERROR) << "The framer received an invalid streamID of "
-                  << current_frame_stream_id_ << " for a frame of type "
-                  << FrameTypeToString(frame_type);
-      set_error(SPDY_INVALID_STREAM_ID);
-      return frame_type;
-    }
-
-    // Ensure that we see a CONTINUATION frame iff we expect to.
-    if ((frame_type == CONTINUATION) != (expect_continuation_ != 0)) {
-      if (expect_continuation_ != 0) {
-        DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
-                    << "frame, but instead received a frame of type "
-                    << FrameTypeToString(frame_type);
-      } else {
-        DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
-      }
-      set_error(SPDY_UNEXPECTED_FRAME);
-      return frame_type;
-    }
+  if (!SpdyConstants::IsValidHTTP2FrameStreamId(current_frame_stream_id_,
+                                                frame_type)) {
+    DLOG(ERROR) << "The framer received an invalid streamID of "
+                << current_frame_stream_id_ << " for a frame of type "
+                << FrameTypeToString(frame_type);
+    set_error(SPDY_INVALID_STREAM_ID);
+    return frame_type;
   }
 
-  if (protocol_version_ == HTTP2 &&
-      payload_length_field > recv_frame_size_limit_) {
+  // Ensure that we see a CONTINUATION frame iff we expect to.
+  if ((frame_type == CONTINUATION) != (expect_continuation_ != 0)) {
+    if (expect_continuation_ != 0) {
+      DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
+                  << "frame, but instead received a frame of type "
+                  << FrameTypeToString(frame_type);
+    } else {
+      DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
+    }
+    set_error(SPDY_UNEXPECTED_FRAME);
+    return frame_type;
+  }
+
+  if (payload_length_field > recv_frame_size_limit_) {
     set_error(SPDY_OVERSIZED_PAYLOAD);
   }
 
   return frame_type;
 }
 
 size_t SpdyFramer::ProcessCommonHeader(const char* data, size_t len) {
   // This should only be called when we're in the SPDY_READING_COMMON_HEADER
   // state.
   DCHECK_EQ(state_, SPDY_READING_COMMON_HEADER);
 
   size_t original_len = len;
 
   // Update current frame buffer as needed.
   if (current_frame_buffer_.len() < GetFrameHeaderSize()) {
     size_t bytes_desired = GetFrameHeaderSize() - current_frame_buffer_.len();
     UpdateCurrentFrameBuffer(&data, &len, bytes_desired);
   }
 
   if (current_frame_buffer_.len() < GetFrameHeaderSize()) {
     // Not enough information to do anything meaningful.
     return original_len - len;
   }
 
   SpdyFrameReader reader(current_frame_buffer_.data(),
                          current_frame_buffer_.len());
   bool is_control_frame = false;
 
-  int control_frame_type_field =
-      SpdyConstants::DataFrameType(protocol_version_);
+  int control_frame_type_field = SpdyConstants::kDataFrameType;
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
   uint32_t length_field = 0;
   bool successful_read = reader.ReadUInt24(&length_field);
   DCHECK(successful_read);
 
   uint8_t control_frame_type_field_uint8;
   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 !=
-                     SpdyConstants::SerializeFrameType(protocol_version_, DATA);
+  is_control_frame = control_frame_type_field != SpdyConstants::kDataFrameType;
 
   current_frame_length_ = length_field + GetFrameHeaderSize();
 
   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();
@@ skipping 66 matching lines @@
     case SETTINGS:
     {
       // Make sure that we have an integral number of 8-byte key/value pairs,
       // Size of each key/value pair in bytes.
       int setting_size = 6;
       if (current_frame_length_ < GetSettingsMinimumSize() ||
           (current_frame_length_ - GetFrameHeaderSize()) % setting_size != 0) {
         DLOG(WARNING) << "Invalid length for SETTINGS frame: "
                       << current_frame_length_;
         set_error(SPDY_INVALID_CONTROL_FRAME_SIZE);
-      } else if (protocol_version_ == HTTP2 &&
-                 current_frame_flags_ & SETTINGS_FLAG_ACK &&
+      } else if (current_frame_flags_ & SETTINGS_FLAG_ACK &&
                  current_frame_length_ > GetSettingsMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME_SIZE);
-      } else if (protocol_version_ == HTTP2 &&
-                 current_frame_flags_ & ~SETTINGS_FLAG_ACK) {
+      } else if (current_frame_flags_ & ~SETTINGS_FLAG_ACK) {
         VLOG(1) << "Undefined frame flags for SETTINGS frame: " << hex
                 << static_cast<int>(current_frame_flags_);
         current_frame_flags_ &= SETTINGS_FLAG_ACK;
       }
       break;
     }
     case PING:
       if (current_frame_length_ != GetPingSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME_SIZE);
       } else {
-        if (protocol_version_ == HTTP2 &&
-            current_frame_flags_ & ~PING_FLAG_ACK) {
+        if (current_frame_flags_ & ~PING_FLAG_ACK) {
           VLOG(1) << "Undefined frame flags for PING frame: " << hex
                   << static_cast<int>(current_frame_flags_);
           current_frame_flags_ &= PING_FLAG_ACK;
         }
       }
       break;
     case GOAWAY:
       {
       // For HTTP/2, optional opaque data may be appended to the
       // GOAWAY frame, thus there is only a minimal length restriction.
-      if (protocol_version_ == HTTP2 &&
-          current_frame_length_ < GetGoAwayMinimumSize()) {
+      if (current_frame_length_ < GetGoAwayMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
         } else if (current_frame_flags_ != 0) {
           VLOG(1) << "Undefined frame flags for GOAWAY frame: " << hex
                   << static_cast<int>(current_frame_flags_);
           current_frame_flags_ = 0;
         }
         break;
       }
     case HEADERS:
       {
         size_t min_size = GetHeadersMinimumSize();
-        if (protocol_version_ == HTTP2 &&
-            (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
+        if (current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
           min_size += 4;
         }
         if (current_frame_length_ < min_size) {
           // TODO(mlavan): check here for HEADERS with no payload?
           // (not allowed in HTTP2)
           set_error(SPDY_INVALID_CONTROL_FRAME);
-        } else if (protocol_version_ == HTTP2 &&
-                   current_frame_flags_ &
-                       ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
-                         HEADERS_FLAG_END_HEADERS | HEADERS_FLAG_PADDED)) {
+        } else if (current_frame_flags_ &
+                   ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
+                     HEADERS_FLAG_END_HEADERS | HEADERS_FLAG_PADDED)) {
           VLOG(1) << "Undefined frame flags for HEADERS frame: " << hex
                   << static_cast<int>(current_frame_flags_);
           current_frame_flags_ &=
               (CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
                HEADERS_FLAG_END_HEADERS | HEADERS_FLAG_PADDED);
         }
       }
       break;
     case WINDOW_UPDATE:
       if (current_frame_length_ != GetWindowUpdateSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME_SIZE);
       } else if (current_frame_flags_ != 0) {
         VLOG(1) << "Undefined frame flags for WINDOW_UPDATE frame: " << hex
                 << static_cast<int>(current_frame_flags_);
         current_frame_flags_ = 0;
       }
       break;
     case BLOCKED:
       if (current_frame_length_ != GetBlockedSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         VLOG(1) << "Undefined frame flags for BLOCKED frame: " << hex
                 << static_cast<int>(current_frame_flags_);
         current_frame_flags_ = 0;
       }
       break;
     case PUSH_PROMISE:
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if (protocol_version_ == HTTP2 &&
-                 current_frame_flags_ &
-                     ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
-                       HEADERS_FLAG_PADDED)) {
+      } else if (current_frame_flags_ &
+                 ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED)) {
         VLOG(1) << "Undefined frame flags for PUSH_PROMISE frame: " << hex
                 << static_cast<int>(current_frame_flags_);
         current_frame_flags_ &=
             (PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED);
       }
       break;
     case CONTINUATION:
       if (current_frame_length_ < GetContinuationMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ & ~HEADERS_FLAG_END_HEADERS) {
@@ skipping 51 matching lines @@
     return;
   }
   // Determine the frame size without variable-length data.
   int32_t frame_size_without_variable_data;
   switch (current_frame_type_) {
     case SETTINGS:
       frame_size_without_variable_data = GetSettingsMinimumSize();
       break;
     case HEADERS:
       frame_size_without_variable_data = GetHeadersMinimumSize();
-      if (protocol_version_ == HTTP2) {
-        if (current_frame_flags_ & HEADERS_FLAG_PADDED) {
-          frame_size_without_variable_data += kPadLengthFieldSize;
-        }
-        if (current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
+      if (current_frame_flags_ & HEADERS_FLAG_PADDED) {
+        frame_size_without_variable_data += kPadLengthFieldSize;
+      }
+      if (current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
         frame_size_without_variable_data +=
-            kPriorityDependencyPayloadSize +
-            kPriorityWeightPayloadSize;
-        }
+            kPriorityDependencyPayloadSize + kPriorityWeightPayloadSize;
       }
       break;
     case PUSH_PROMISE:
       frame_size_without_variable_data = GetPushPromiseMinimumSize();
-      if (protocol_version_ == HTTP2 &&
-          current_frame_flags_ & PUSH_PROMISE_FLAG_PADDED) {
+      if (current_frame_flags_ & PUSH_PROMISE_FLAG_PADDED) {
         frame_size_without_variable_data += kPadLengthFieldSize;
       }
       break;
     case CONTINUATION:
       frame_size_without_variable_data = GetContinuationMinimumSize();
       break;
     default:
       frame_size_without_variable_data = -1;
       break;
   }
@@ skipping 34 matching lines @@
   size_t bytes_to_read = std::min(*len, max_bytes);
   if (bytes_to_read > 0) {
     current_frame_buffer_.CopyFrom(*data, bytes_to_read);
     *data += bytes_to_read;
     *len -= bytes_to_read;
   }
   return bytes_to_read;
 }
 
 size_t SpdyFramer::GetSerializedLength(
-    const SpdyMajorVersion spdy_version,
     const SpdyHeaderBlock* headers) {
   const size_t num_name_value_pairs_size = sizeof(uint32_t);
   const size_t length_of_name_size = num_name_value_pairs_size;
   const size_t length_of_value_size = num_name_value_pairs_size;
 
   size_t total_length = num_name_value_pairs_size;
   for (const auto& header : *headers) {
     // We add space for the length of the name and the length of the value as
     // well as the length of the name and the length of the value.
     total_length += length_of_name_size + header.first.size() +
@@ skipping 20 matching lines @@
     reader.Seek(GetFrameHeaderSize());  // Seek past frame header.
 
     switch (current_frame_type_) {
       case HEADERS:
         {
           bool successful_read = true;
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             return original_len - len;
           }
-          if (protocol_version_ == HTTP2 &&
-              !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
+          if (!(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;
           }
-          if (protocol_version_ == HTTP2 &&
-              current_frame_flags_ & HEADERS_FLAG_PADDED) {
+          if (current_frame_flags_ & HEADERS_FLAG_PADDED) {
             uint8_t pad_payload_len = 0;
             DCHECK_EQ(remaining_padding_payload_length_, 0u);
             successful_read = reader.ReadUInt8(&pad_payload_len);
             DCHECK(successful_read);
             remaining_padding_payload_length_ = pad_payload_len;
           }
           const bool has_priority =
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
           int weight = 0;
           uint32_t parent_stream_id = 0;
           bool exclusive = false;
-          if (protocol_version_ == HTTP2 && has_priority) {
+          if (has_priority) {
             uint32_t stream_dependency;
             successful_read = reader.ReadUInt32(&stream_dependency);
             DCHECK(successful_read);
             UnpackStreamDependencyValues(stream_dependency, &exclusive,
                                          &parent_stream_id);
 
             uint8_t serialized_weight = 0;
             successful_read = reader.ReadUInt8(&serialized_weight);
             if (successful_read) {
               // Per RFC 7540 section 6.3, serialized weight value is actual
@@ skipping 10 matching lines @@
           visitor_->OnHeaders(
               current_frame_stream_id_,
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0, weight,
               parent_stream_id, exclusive,
               (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
               expect_continuation_ == 0);
         }
         break;
       case PUSH_PROMISE:
         {
-          DCHECK_EQ(HTTP2, protocol_version_);
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             return original_len - len;
           }
           bool successful_read = true;
-          if (protocol_version_ == HTTP2 &&
-              current_frame_flags_ & PUSH_PROMISE_FLAG_PADDED) {
+          if (current_frame_flags_ & PUSH_PROMISE_FLAG_PADDED) {
             DCHECK_EQ(remaining_padding_payload_length_, 0u);
             uint8_t pad_payload_len = 0;
             successful_read = reader.ReadUInt8(&pad_payload_len);
             DCHECK(successful_read);
             remaining_padding_payload_length_ = pad_payload_len;
           }
         }
         {
           SpdyStreamId promised_stream_id = kInvalidStream;
           bool successful_read = reader.ReadUInt31(&promised_stream_id);
@@ skipping 63 matching lines @@
     }
     CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
   }
   return original_len - len;
 }
 
 // Does not buffer the control payload. Instead, either passes directly to the
 // visitor or decompresses and then passes directly to the visitor, via
 // IncrementallyDeliverControlFrameHeaderData()
 size_t SpdyFramer::ProcessControlFrameHeaderBlock(const char* data,
-                                                  size_t data_len,
-                                                  bool is_hpack_header_block) {
+                                                  size_t data_len) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_HEADER_BLOCK, state_);
 
   bool processed_successfully = true;
   if (current_frame_type_ != HEADERS && current_frame_type_ != PUSH_PROMISE &&
       current_frame_type_ != CONTINUATION) {
     SPDY_BUG << "Unhandled frame type in ProcessControlFrameHeaderBlock.";
   }
 
   if (remaining_padding_payload_length_ > remaining_data_length_) {
     set_error(SPDY_INVALID_PADDING);
     return data_len;
   }
 
   size_t process_bytes = std::min(
       data_len, remaining_data_length_ - remaining_padding_payload_length_);
-  if (is_hpack_header_block) {
-    if (!GetHpackDecoder()->HandleControlFrameHeadersData(data,
-                                                          process_bytes)) {
-      // TODO(jgraettinger): Finer-grained HPACK error codes.
-      set_error(SPDY_DECOMPRESS_FAILURE);
-      processed_successfully = false;
-    }
-  } else if (process_bytes > 0) {
-    processed_successfully = IncrementallyDeliverControlFrameHeaderData(
-        current_frame_stream_id_, data, process_bytes);
+  if (!GetHpackDecoder()->HandleControlFrameHeadersData(data, process_bytes)) {
+    // TODO(jgraettinger): Finer-grained HPACK error codes.
+    set_error(SPDY_DECOMPRESS_FAILURE);
+    processed_successfully = false;
   }
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_data_length_ == remaining_padding_payload_length_ &&
       processed_successfully) {
     if (expect_continuation_ == 0) {
-      if (is_hpack_header_block) {
-        size_t compressed_len = 0;
-        if (GetHpackDecoder()->HandleControlFrameHeadersComplete(
-                &compressed_len)) {
-          visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
-          if (state_ == SPDY_ERROR) {
-            return data_len;
-          }
-        } else {
-          set_error(SPDY_DECOMPRESS_FAILURE);
-          processed_successfully = false;
-        }
-      } else {
+      size_t compressed_len = 0;
+      if (GetHpackDecoder()->HandleControlFrameHeadersComplete(
+              &compressed_len)) {
         visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
         if (state_ == SPDY_ERROR) {
           return data_len;
         }
+      } else {
+        set_error(SPDY_DECOMPRESS_FAILURE);
+        processed_successfully = false;
       }
     }
     if (processed_successfully) {
       CHANGE_STATE(SPDY_CONSUME_PADDING);
     }
   }
 
   // Handle error.
   if (!processed_successfully) {
     return data_len;
   }
 
   // Return amount processed.
   return process_bytes;
 }
 
 size_t SpdyFramer::ProcessSettingsFrameHeader(const char* data, size_t len) {
   // TODO(birenroy): Remove this state when removing SPDY3. I think it only
   // exists to read the number of settings in the frame for SPDY3. This value
   // is never parsed or used.
   size_t bytes_read = 0;
   if (remaining_control_header_ > 0) {
     bytes_read =
         UpdateCurrentFrameBuffer(&data, &len, remaining_control_header_);
     remaining_control_header_ -= bytes_read;
     remaining_data_length_ -= bytes_read;
   }
   if (remaining_control_header_ == 0) {
-    if (protocol_version_ == HTTP2 &&
-        current_frame_flags_ & SETTINGS_FLAG_ACK) {
+    if (current_frame_flags_ & SETTINGS_FLAG_ACK) {
       visitor_->OnSettingsAck();
       CHANGE_STATE(SPDY_FRAME_COMPLETE);
     } else {
       visitor_->OnSettings(current_frame_flags_ &
                            SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS);
       CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
     }
   }
   return bytes_read;
 }
@@ skipping 55 matching lines @@
   SpdySettingsIds id;
   uint8_t flags = 0;
   uint32_t value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
   id_field = base::NetToHost16(*(reinterpret_cast<const uint16_t*>(data)));
   value = base::NetToHost32(*(reinterpret_cast<const uint32_t*>(data + 2)));
 
   // Validate id.
-  if (!SpdyConstants::IsValidSettingId(protocol_version_, id_field)) {
+  if (!SpdyConstants::IsValidSettingId(id_field)) {
     DLOG(WARNING) << "Unknown SETTINGS ID: " << id_field;
-    // In HTTP2 we ignore unknown settings for extensibility.
+    // Ignore unknown settings for extensibility.
     return true;
   }
-  id = SpdyConstants::ParseSettingId(protocol_version_, id_field);
+  id = SpdyConstants::ParseSettingId(id_field);
 
   // Validation succeeded. Pass on to visitor.
   visitor_->OnSetting(id, flags, value);
   return true;
 }
 
 size_t SpdyFramer::ProcessControlFramePayload(const char* data, size_t len) {
   size_t original_len = len;
   size_t bytes_read = UpdateCurrentFrameBuffer(&data, &len,
                                                remaining_data_length_);
   remaining_data_length_ -= bytes_read;
   if (remaining_data_length_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.data(),
                            current_frame_buffer_.len());
     reader.Seek(GetFrameHeaderSize());  // Skip frame header.
 
     // Use frame-specific handlers.
     switch (current_frame_type_) {
       case PING: {
           SpdyPingId id = 0;
-          bool is_ack = protocol_version_ == HTTP2 &&
-                        (current_frame_flags_ & PING_FLAG_ACK);
+          bool is_ack = current_frame_flags_ & PING_FLAG_ACK;
           bool successful_read = true;
           successful_read = reader.ReadUInt64(&id);
           DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
           visitor_->OnPing(id, is_ack);
         }
         break;
       case WINDOW_UPDATE: {
         uint32_t delta_window_size = 0;
           bool successful_read = true;
           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_EQ(HTTP2, protocol_version_);
           DCHECK(reader.IsDoneReading());
           visitor_->OnBlocked(current_frame_stream_id_);
         }
         break;
       case PRIORITY: {
-          DCHECK_EQ(HTTP2, protocol_version_);
           uint32_t stream_dependency;
           uint32_t parent_stream_id;
           bool exclusive;
           uint8_t serialized_weight;
           bool successful_read = reader.ReadUInt32(&stream_dependency);
           DCHECK(successful_read);
           UnpackStreamDependencyValues(stream_dependency, &exclusive,
                                        &parent_stream_id);
 
           successful_read = reader.ReadUInt8(&serialized_weight);
@@ skipping 41 matching lines @@
                              current_frame_buffer_.len());
       reader.Seek(GetFrameHeaderSize());  // Seek past frame header.
       bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
       DCHECK(successful_read);
 
       // Parse status code.
       SpdyGoAwayStatus status = GOAWAY_OK;
       uint32_t status_raw = GOAWAY_OK;
       successful_read = reader.ReadUInt32(&status_raw);
       DCHECK(successful_read);
-      if (SpdyConstants::IsValidGoAwayStatus(protocol_version_, status_raw)) {
-        status =
-            SpdyConstants::ParseGoAwayStatus(protocol_version_, status_raw);
+      if (SpdyConstants::IsValidGoAwayStatus(status_raw)) {
+        status = SpdyConstants::ParseGoAwayStatus(status_raw);
       } else {
-        if (protocol_version_ == HTTP2) {
-          // Treat unrecognized status codes as INTERNAL_ERROR as
-          // recommended by the HTTP/2 spec.
-          status = GOAWAY_INTERNAL_ERROR;
-        }
+        // Treat unrecognized status codes as INTERNAL_ERROR as
+        // recommended by the HTTP/2 spec.
+        status = GOAWAY_INTERNAL_ERROR;
       }
       // Finished parsing the GOAWAY header, call frame handler.
       visitor_->OnGoAway(current_frame_stream_id_, status);
     }
   }
 
   // Handle remaining data as opaque.
   bool processed_successfully = true;
   if (len > 0) {
     processed_successfully = visitor_->OnGoAwayFrameData(data, len);
@@ skipping 32 matching lines @@
     if (current_frame_buffer_.len() == header_size) {
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.data(),
                              current_frame_buffer_.len());
       reader.Seek(GetFrameHeaderSize());  // Seek past frame header.
 
       SpdyRstStreamStatus status = RST_STREAM_NO_ERROR;
       uint32_t status_raw = status;
       bool successful_read = reader.ReadUInt32(&status_raw);
       DCHECK(successful_read);
-      if (SpdyConstants::IsValidRstStreamStatus(protocol_version_,
-                                                status_raw)) {
-        status =
-            SpdyConstants::ParseRstStreamStatus(protocol_version_, status_raw);
+      if (SpdyConstants::IsValidRstStreamStatus(status_raw)) {
+        status = SpdyConstants::ParseRstStreamStatus(status_raw);
       } else {
-        if (protocol_version_ == HTTP2) {
-          // Treat unrecognized status codes as INTERNAL_ERROR as
-          // recommended by the HTTP/2 spec.
-          status = RST_STREAM_INTERNAL_ERROR;
-        }
+        // Treat unrecognized status codes as INTERNAL_ERROR as
+        // recommended by the HTTP/2 spec.
+        status = RST_STREAM_INTERNAL_ERROR;
       }
       // Finished parsing the RST_STREAM header, call frame handler.
       visitor_->OnRstStream(current_frame_stream_id_, status);
     }
   }
 
   // Handle remaining data as opaque.
   // TODO(jamessynge): Remove support for variable length/opaque trailer.
   bool processed_successfully = true;
   if (len > 0) {
@@ skipping 173 matching lines @@
 
     // Read header name.
     if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
     const char* begin = temp.data();
     const char* end = begin;
     std::advance(end, temp.size());
-    if (protocol_version_ == HTTP2 && std::any_of(begin, end, isupper)) {
+    if (std::any_of(begin, end, isupper)) {
       DVLOG(1) << "Malformed header: Header name " << temp
                << " contains upper-case characters.";
       return false;
     }
     std::string name = temp.as_string();
 
     // Read header value.
     if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
@@ skipping 51 matching lines @@
 
   if (framer_->debug_visitor_ != nullptr) {
     debug_total_size_ += size_without_block;
     debug_total_size_ += encoding->size();
     if (!has_next_frame_) {
       // TODO(birenroy) are these (here and below) still necessary?
       // HTTP2 uses HPACK for header compression. However, continue to
       // use GetSerializedLength() for an apples-to-apples comparision of
       // compression performance between HPACK and SPDY w/ deflate.
       size_t debug_payload_len =
-          framer_->GetSerializedLength(HTTP2, &headers_ir_->header_block());
+          framer_->GetSerializedLength(&headers_ir_->header_block());
       framer_->debug_visitor_->OnSendCompressedFrame(headers_ir_->stream_id(),
                                                      HEADERS, debug_payload_len,
                                                      debug_total_size_);
     }
   }
 
   if (is_first_frame_) {
     is_first_frame_ = false;
     headers_ir_->set_end_headers(!has_next_frame_);
     return framer_->SerializeHeadersGivenEncoding(*headers_ir_, *encoding);
@@ skipping 13 matching lines @@
 
   int num_padding_fields = 0;
   if (data_ir.padded()) {
     flags |= DATA_FLAG_PADDED;
     ++num_padding_fields;
   }
 
   const size_t size_with_padding = num_padding_fields + data_ir.data_len() +
                                    data_ir.padding_payload_len() +
                                    GetDataFrameMinimumSize();
-  SpdyFrameBuilder builder(size_with_padding, protocol_version_);
+  SpdyFrameBuilder builder(size_with_padding);
   builder.BeginNewFrame(*this, DATA, flags, data_ir.stream_id());
   if (data_ir.padded()) {
     builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
   builder.WriteBytes(data_ir.data(), data_ir.data_len());
   if (data_ir.padding_payload_len() > 0) {
     string padding(data_ir.padding_payload_len(), 0);
     builder.WriteBytes(padding.data(), padding.length());
   }
   DCHECK_EQ(size_with_padding, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
     const SpdyDataIR& data_ir) const {
   uint8_t flags = DATA_FLAG_NONE;
   if (data_ir.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
   size_t frame_size = GetDataFrameMinimumSize();
   size_t num_padding_fields = 0;
-  if (protocol_version_ == HTTP2) {
-    if (data_ir.padded()) {
-      flags |= DATA_FLAG_PADDED;
-      ++num_padding_fields;
-    }
+  if (data_ir.padded()) {
+    flags |= DATA_FLAG_PADDED;
+    ++num_padding_fields;
     frame_size += num_padding_fields;
   }
 
-  SpdyFrameBuilder builder(frame_size, protocol_version_);
+  SpdyFrameBuilder builder(frame_size);
   builder.BeginNewFrame(*this, DATA, flags, data_ir.stream_id());
-  if (protocol_version_ == HTTP2) {
-    if (data_ir.padded()) {
-      builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
-    }
-    builder.OverwriteLength(*this, num_padding_fields + data_ir.data_len() +
-                                       data_ir.padding_payload_len());
-  } else {
-    builder.OverwriteLength(*this, data_ir.data_len());
+  if (data_ir.padded()) {
+    builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
+  builder.OverwriteLength(*this, num_padding_fields + data_ir.data_len() +
+                                     data_ir.padding_payload_len());
   DCHECK_EQ(frame_size, 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. This 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.
   size_t expected_length = GetRstStreamMinimumSize();
-  SpdyFrameBuilder builder(expected_length, protocol_version_);
+  SpdyFrameBuilder builder(expected_length);
 
   builder.BeginNewFrame(*this, RST_STREAM, 0, rst_stream.stream_id());
 
-  builder.WriteUInt32(SpdyConstants::SerializeRstStreamStatus(
-      protocol_version_, rst_stream.status()));
+  builder.WriteUInt32(
+      SpdyConstants::SerializeRstStreamStatus(rst_stream.status()));
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeSettings(
     const SpdySettingsIR& settings) const {
   uint8_t flags = 0;
 
   if (settings.is_ack()) {
     flags |= SETTINGS_FLAG_ACK;
   }
   const SpdySettingsIR::ValueMap* values = &(settings.values());
 
   int setting_size = 6;
   // Size, in bytes, of this SETTINGS frame.
   const size_t size = GetSettingsMinimumSize() +
                       (values->size() * setting_size);
-  SpdyFrameBuilder builder(size, protocol_version_);
+  SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this, SETTINGS, flags, 0);
 
   // If this is an ACK, payload should be empty.
-  if (protocol_version_ == HTTP2 && settings.is_ack()) {
+  if (settings.is_ack()) {
     return builder.take();
   }
 
   DCHECK_EQ(GetSettingsMinimumSize(), builder.length());
   for (SpdySettingsIR::ValueMap::const_iterator it = values->begin();
        it != values->end();
        ++it) {
-    int setting_id =
-        SpdyConstants::SerializeSettingId(protocol_version_, it->first);
+    int setting_id = SpdyConstants::SerializeSettingId(it->first);
     DCHECK_GE(setting_id, 0);
     builder.WriteUInt16(static_cast<uint16_t>(setting_id));
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
-  SpdyFrameBuilder builder(GetPingSize(), protocol_version_);
+  SpdyFrameBuilder builder(GetPingSize());
   uint8_t flags = 0;
   if (ping.is_ack()) {
     flags |= PING_FLAG_ACK;
   }
   builder.BeginNewFrame(*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.
   size_t expected_length = GetGoAwayMinimumSize();
-  if (protocol_version_ == HTTP2) {
-    expected_length += goaway.description().size();
-  }
-  SpdyFrameBuilder builder(expected_length, protocol_version_);
+  expected_length += goaway.description().size();
+  SpdyFrameBuilder builder(expected_length);
 
   // Serialize the GOAWAY frame.
   builder.BeginNewFrame(*this, GOAWAY, 0, 0);
 
   // GOAWAY frames specify the last good stream id.
   builder.WriteUInt32(goaway.last_good_stream_id());
 
   // GOAWAY frames also specify the error status code.
-  builder.WriteUInt32(
-      SpdyConstants::SerializeGoAwayStatus(protocol_version_, goaway.status()));
+  builder.WriteUInt32(SpdyConstants::SerializeGoAwayStatus(goaway.status()));
 
-  // In HTTP2, GOAWAY frames may also specify opaque data.
-  if ((protocol_version_ == HTTP2) && (goaway.description().size() > 0)) {
+  // GOAWAY frames may also specify opaque data.
+  if (!goaway.description().empty()) {
     builder.WriteBytes(goaway.description().data(),
                        goaway.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeHeaders(const SpdyHeadersIR& headers) {
   uint8_t flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
-  if (protocol_version_ == HTTP2) {
-    // This will get overwritten if we overflow into a CONTINUATION frame.
-    flags |= HEADERS_FLAG_END_HEADERS;
-    if (headers.has_priority()) {
-      flags |= HEADERS_FLAG_PRIORITY;
-    }
-    if (headers.padded()) {
-      flags |= HEADERS_FLAG_PADDED;
-    }
+  // This will get overwritten if we overflow into a CONTINUATION frame.
+  flags |= HEADERS_FLAG_END_HEADERS;
+  if (headers.has_priority()) {
+    flags |= HEADERS_FLAG_PRIORITY;
+  }
+  if (headers.padded()) {
+    flags |= HEADERS_FLAG_PADDED;
   }
 
   // The size of this frame, including padding (if there is any) and
   // variable-length header block.
   size_t size = GetHeadersMinimumSize();
 
-  if (protocol_version_ == HTTP2 && headers.padded()) {
+  if (headers.padded()) {
     size += kPadLengthFieldSize;
     size += headers.padding_payload_len();
   }
 
   int weight = 0;
   if (headers.has_priority()) {
     weight = ClampHttp2Weight(headers.weight());
     size += 5;
   }
 
   string hpack_encoding;
   if (enable_compression_) {
     GetHpackEncoder()->EncodeHeaderSet(headers.header_block(), &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(headers.header_block(),
                                                          &hpack_encoding);
   }
   size += hpack_encoding.size();
   if (size > kMaxControlFrameSize) {
     size += GetNumberRequiredContinuationFrames(size) *
             GetContinuationMinimumSize();
     flags &= ~HEADERS_FLAG_END_HEADERS;
   }
 
-  SpdyFrameBuilder builder(size, protocol_version_);
+  SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this, HEADERS, flags, headers.stream_id());
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   int padding_payload_len = 0;
   if (headers.padded()) {
     builder.WriteUInt8(headers.padding_payload_len());
     padding_payload_len = headers.padding_payload_len();
   }
   if (headers.has_priority()) {
     builder.WriteUInt32(PackStreamDependencyValues(headers.exclusive(),
                                                    headers.parent_stream_id()));
     // Per RFC 7540 section 6.3, serialized weight value is actual value - 1.
     builder.WriteUInt8(weight - 1);
   }
   WritePayloadWithContinuation(&builder, hpack_encoding, headers.stream_id(),
                                HEADERS, padding_payload_len);
 
   if (debug_visitor_) {
     // HTTP2 uses HPACK for header compression. However, continue to
     // use GetSerializedLength() for an apples-to-apples comparision of
     // compression performance between HPACK and SPDY w/ deflate.
-    const size_t payload_len =
-        GetSerializedLength(protocol_version_, &(headers.header_block()));
+    const size_t payload_len = GetSerializedLength(&(headers.header_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(), protocol_version_);
+  SpdyFrameBuilder builder(GetWindowUpdateSize());
   builder.BeginNewFrame(*this, WINDOW_UPDATE, kNoFlags,
                         window_update.stream_id());
   builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeBlocked(
     const SpdyBlockedIR& blocked) const {
-  DCHECK_EQ(HTTP2, protocol_version_);
-  SpdyFrameBuilder builder(GetBlockedSize(), protocol_version_);
+  SpdyFrameBuilder builder(GetBlockedSize());
   builder.BeginNewFrame(*this, BLOCKED, kNoFlags, blocked.stream_id());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
-  DCHECK_EQ(HTTP2, protocol_version_);
   uint8_t flags = 0;
   // This will get overwritten if we overflow into a CONTINUATION frame.
   flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   if (push_promise.padded()) {
     flags |= PUSH_PROMISE_FLAG_PADDED;
     size += kPadLengthFieldSize;
     size += push_promise.padding_payload_len();
   }
 
   string hpack_encoding;
   if (enable_compression_) {
     GetHpackEncoder()->EncodeHeaderSet(push_promise.header_block(),
                                        &hpack_encoding);
   } else {
     GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
         push_promise.header_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
   if (size > kMaxControlFrameSize) {
     size += GetNumberRequiredContinuationFrames(size) *
             GetContinuationMinimumSize();
     flags &= ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   }
 
-  SpdyFrameBuilder builder(size, protocol_version_);
+  SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this,
                         PUSH_PROMISE,
                         flags,
                         push_promise.stream_id());
   int padding_payload_len = 0;
   if (push_promise.padded()) {
     builder.WriteUInt8(push_promise.padding_payload_len());
     builder.WriteUInt32(push_promise.promised_stream_id());
     DCHECK_EQ(GetPushPromiseMinimumSize() + kPadLengthFieldSize,
               builder.length());
 
     padding_payload_len = push_promise.padding_payload_len();
   } else {
     builder.WriteUInt32(push_promise.promised_stream_id());
     DCHECK_EQ(GetPushPromiseMinimumSize(), builder.length());
   }
 
   WritePayloadWithContinuation(&builder,
                                hpack_encoding,
                                push_promise.stream_id(),
                                PUSH_PROMISE,
                                padding_payload_len);
 
   if (debug_visitor_) {
     // HTTP2 uses HPACK for header compression. However, continue to
     // use GetSerializedLength() for an apples-to-apples comparision of
     // compression performance between HPACK and SPDY w/ deflate.
     const size_t payload_len =
-        GetSerializedLength(protocol_version_, &(push_promise.header_block()));
+        GetSerializedLength(&(push_promise.header_block()));
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
                                           PUSH_PROMISE,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeHeadersGivenEncoding(
     const SpdyHeadersIR& headers,
     const string& encoding) const {
-  DCHECK_EQ(HTTP2, protocol_version_);
-
   size_t frame_size = GetHeaderFrameSizeSansBlock(headers) + encoding.size();
-  SpdyFrameBuilder builder(frame_size, protocol_version_);
+  SpdyFrameBuilder builder(frame_size);
   builder.BeginNewFrame(*this, HEADERS, SerializeHeaderFrameFlags(headers),
                         headers.stream_id());
   DCHECK_EQ(GetFrameHeaderSize(), builder.length());
 
   if (headers.padded()) {
     builder.WriteUInt8(headers.padding_payload_len());
   }
 
   if (headers.has_priority()) {
     int weight = ClampHttp2Weight(headers.weight());
     builder.WriteUInt32(PackStreamDependencyValues(headers.exclusive(),
                                                    headers.parent_stream_id()));
     // Per RFC 7540 section 6.3, serialized weight value is actual value - 1.
     builder.WriteUInt8(weight - 1);
   }
 
   builder.WriteBytes(&encoding[0], encoding.size());
 
   if (headers.padding_payload_len() > 0) {
     string padding(headers.padding_payload_len(), 0);
     builder.WriteBytes(padding.data(), padding.length());
   }
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) const {
-  DCHECK_EQ(HTTP2, protocol_version_);
-
   const string& encoding = continuation.encoding();
   size_t frame_size = GetContinuationMinimumSize() + encoding.size();
-  SpdyFrameBuilder builder(frame_size, protocol_version_);
+  SpdyFrameBuilder builder(frame_size);
   uint8_t flags = continuation.end_headers() ? HEADERS_FLAG_END_HEADERS : 0;
   builder.BeginNewFrame(*this, CONTINUATION, flags, continuation.stream_id());
   DCHECK_EQ(GetFrameHeaderSize(), builder.length());
 
   builder.WriteBytes(&encoding[0], encoding.size());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeAltSvc(const SpdyAltSvcIR& altsvc_ir) {
-  DCHECK_EQ(HTTP2, protocol_version_);
-
   size_t size = GetAltSvcMinimumSize();
   size += altsvc_ir.origin().length();
   string value = SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
       altsvc_ir.altsvc_vector());
   size += value.length();
 
-  SpdyFrameBuilder builder(size, protocol_version_);
+  SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this, ALTSVC, kNoFlags, altsvc_ir.stream_id());
 
   builder.WriteUInt16(altsvc_ir.origin().length());
   builder.WriteBytes(altsvc_ir.origin().data(), altsvc_ir.origin().length());
   builder.WriteBytes(value.data(), value.length());
   DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializePriority(
     const SpdyPriorityIR& priority) const {
-  DCHECK_EQ(HTTP2, protocol_version_);
   size_t size = GetPrioritySize();
 
-  SpdyFrameBuilder builder(size, protocol_version_);
+  SpdyFrameBuilder builder(size);
   builder.BeginNewFrame(*this, PRIORITY, kNoFlags, priority.stream_id());
 
   builder.WriteUInt32(PackStreamDependencyValues(priority.exclusive(),
                                                  priority.parent_stream_id()));
   // Per RFC 7540 section 6.3, serialized weight value is actual value - 1.
   builder.WriteUInt8(priority.weight() - 1);
   DCHECK_EQ(GetPrioritySize(), builder.length());
   return builder.take();
 }
 
@@ skipping 51 matching lines @@
 
 }  // namespace
 
 SpdySerializedFrame SpdyFramer::SerializeFrame(const SpdyFrameIR& frame) {
   FrameSerializationVisitor visitor(this);
   frame.Visit(&visitor);
   return visitor.ReleaseSerializedFrame();
 }
 
 size_t SpdyFramer::GetNumberRequiredContinuationFrames(size_t size) {
-  DCHECK_EQ(HTTP2, protocol_version_);
   DCHECK_GT(size, kMaxControlFrameSize);
   size_t overflow = size - kMaxControlFrameSize;
   size_t payload_size = kMaxControlFrameSize - GetContinuationMinimumSize();
   // This is ceiling(overflow/payload_size) using integer arithmetics.
   return (overflow - 1) / payload_size + 1;
 }
 
 size_t SpdyFramer::GetHeaderFrameSizeSansBlock(
     const SpdyHeadersIR& header_ir) const {
   size_t min_size = GetFrameHeaderSize();
@@ skipping 73 matching lines @@
     builder->BeginNewFrame(*this, CONTINUATION, flags, stream_id);
     // Write payload fragment.
     builder->WriteBytes(
         &hpack_encoding[hpack_encoding.size() - bytes_remaining],
         bytes_to_write);
     bytes_remaining -= bytes_to_write;
   }
 }
 
 HpackEncoder* SpdyFramer::GetHpackEncoder() {
-  DCHECK_EQ(HTTP2, protocol_version_);
   if (hpack_encoder_.get() == nullptr) {
     hpack_encoder_.reset(new HpackEncoder(ObtainHpackHuffmanTable()));
   }
   return hpack_encoder_.get();
 }
 
 HpackDecoderInterface* SpdyFramer::GetHpackDecoder() {
-  DCHECK_EQ(HTTP2, protocol_version_);
   if (hpack_decoder_.get() == nullptr) {
     hpack_decoder_.reset(new HpackDecoder());
   }
   return hpack_decoder_.get();
 }
 
 bool SpdyFramer::IncrementallyDeliverControlFrameHeaderData(
     SpdyStreamId stream_id, const char* data, size_t len) {
   bool read_successfully = true;
   while (read_successfully && len > 0) {
@@ skipping 51 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net