SPDY: Use SpdyMajorVersion rather than ints for SPDY version number.

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 63 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(int version,
-                                                      uint32 wire) {
-  if (version < 3) {
+SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(
+    SpdyMajorVersion version, uint32 wire) {
+  if (version < SPDY3) {
     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: " << id;
 }
 
-uint32 SettingsFlagsAndId::GetWireFormat(int version) const {
+uint32 SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version)
+    const {
   uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
-  if (version < 3) {
+  if (version < SPDY3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
 // SPDY 2 had a bug in it with respect to byte ordering of id/flags field.
 // This method is used to preserve buggy behavior and works on both
 // little-endian and big-endian hosts.
 // This method is also bidirectional (can be used to translate SPDY 2 to SPDY 3
 // as well as vice versa).
@@ skipping 137 matching lines @@
 
 size_t SpdyFramer::GetGoAwayMinimumSize() const {
   // Size, in bytes, of this GOAWAY frame. Calculated as:
   // 1. Control frame header size
   size_t size = GetControlFrameHeaderSize();
 
   // 2. Last good stream id (4 bytes)
   size += 4;
 
   // 3. SPDY 3+ GOAWAY frames also contain a status (4 bytes)
-  if (protocol_version() >= 3) {
+  if (protocol_version() >= SPDY3) {
     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();
@@ skipping 18 matching lines @@
     // control frame header + 4 (stream id) + 4 (delta)
     return GetControlFrameHeaderSize() + 8;
   } else {
     // Calculated as:
     // frame prefix + 4 (delta)
     return GetControlFrameHeaderSize() + 4;
   }
 }
 
 size_t SpdyFramer::GetBlockedSize() const {
-  DCHECK_LE(4, protocol_version());
+  DCHECK_LT(SPDY3, protocol_version());
   // Size, in bytes, of a BLOCKED frame.
   // The BLOCKED frame has no payload beyond the control frame header.
   return GetControlFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetPushPromiseMinimumSize() const {
-  DCHECK_LE(4, protocol_version());
+  DCHECK_LT(SPDY3, protocol_version());
   // Size, in bytes, of a PUSH_PROMISE frame, sans the embedded header block.
   // Calculated as frame prefix + 4 (promised stream id).
   return GetControlFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetContinuationMinimumSize() const  {
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetControlFrameHeaderSize();
 }
@@ skipping 316 matching lines @@
 
   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() <= 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 &&
+        version >= SpdyConstants::SerializeMajorVersion(SPDY_MIN_VERSION) &&
+        version <= SpdyConstants::SerializeMajorVersion(SPDY_MAX_VERSION)) {
+      version = SpdyConstants::ParseMajorVersion(version);
+    }
 
     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);
@@ skipping 100 matching lines @@
         if (current_frame_flags_ & DATA_FLAG_FIN) {
           visitor_->OnStreamFrameData(
               current_frame_stream_id_, NULL, 0, true);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
     }
   } 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
+    DVLOG(1) << "Unsupported SPDY version "
+             << 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) {
@@ skipping 147 matching lines @@
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (protocol_version() <= SPDY3 && current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_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()) {
+      if (current_frame_length_ < GetContinuationMinimumSize() ||
+          protocol_version() <= SPDY3) {
         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 95 matching lines @@
     memcpy(current_frame_buffer_.get() + current_frame_buffer_length_,
            *data,
            bytes_to_read);
     current_frame_buffer_length_ += bytes_to_read;
     *data += bytes_to_read;
     *len -= bytes_to_read;
   }
   return bytes_to_read;
 }
 
-size_t SpdyFramer::GetSerializedLength(const int spdy_version,
-                                       const SpdyHeaderBlock* headers) {
+size_t SpdyFramer::GetSerializedLength(
+    const SpdyMajorVersion spdy_version,
+    const SpdyHeaderBlock* headers) {
   const size_t num_name_value_pairs_size
-      = (spdy_version < 3) ? sizeof(uint16) : sizeof(uint32);
+      = (spdy_version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
   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 (SpdyHeaderBlock::const_iterator it = headers->begin();
        it != headers->end();
        ++it) {
     // 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 + it->first.size() +
                     length_of_value_size + it->second.size();
   }
   return total_length;
 }
 
 void SpdyFramer::WriteHeaderBlock(SpdyFrameBuilder* frame,
-                                  const int spdy_version,
+                                  const SpdyMajorVersion spdy_version,
                                   const SpdyHeaderBlock* headers) {
-  if (spdy_version < 3) {
+  if (spdy_version < SPDY3) {
     frame->WriteUInt16(headers->size());  // Number of headers.
   } else {
     frame->WriteUInt32(headers->size());  // Number of headers.
   }
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
-    if (spdy_version < 3) {
+    if (spdy_version < SPDY3) {
       frame->WriteString(it->first);
       frame->WriteString(it->second);
     } else {
       frame->WriteStringPiece32(it->first);
       frame->WriteStringPiece32(it->second);
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
@@ skipping 775 matching lines @@
 }
 
 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) {
+    if (current_frame_flags_ & DATA_FLAG_PAD_LOW) {
       pad_low = true;
       ++remaining_padding_length_fields_;
     }
-    if (current_frame_flags_ & net::DATA_FLAG_PAD_HIGH) {
+    if (current_frame_flags_ & 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;
     }
   }
 
@@ skipping 787 matching lines @@
     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);
 }
 
 size_t SpdyFramer::GetNumberRequiredContinuationFrames(size_t size) {
   const size_t kMaxControlFrameSize = GetControlFrameBufferMaxSize();
-  DCHECK_GT(protocol_version(), net::SPDY3);
+  DCHECK_GT(protocol_version(), SPDY3);
   DCHECK_GT(size, kMaxControlFrameSize);
   size_t overflow = size - kMaxControlFrameSize;
   return overflow / (kMaxControlFrameSize - GetContinuationMinimumSize()) + 1;
 }
 
 void SpdyFramer::WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                               const string& hpack_encoding,
                                               SpdyStreamId stream_id,
                                               SpdyFrameType type) {
   const size_t kMaxControlFrameSize = GetControlFrameBufferMaxSize();
@@ skipping 289 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