Remove SPDY/2 code.

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 <iterator>
@@ skipping 64 matching lines @@
 void UnpackStreamDependencyValues(uint32_t packed,
                                   bool* exclusive,
                                   SpdyStreamId* parent_stream_id) {
   *exclusive = (packed >> 31) != 0;
   // Zero out the highest-order bit to get the parent stream id.
   *parent_stream_id = packed & 0x7fffffff;
 }
 
 struct DictionaryIds {
   DictionaryIds()
-    : v2_dictionary_id(CalculateDictionaryId(kV2Dictionary, kV2DictionarySize)),
-      v3_dictionary_id(CalculateDictionaryId(kV3Dictionary, kV3DictionarySize))
-  {}
-  const uLong v2_dictionary_id;
+      : v3_dictionary_id(
+            CalculateDictionaryId(kV3Dictionary, kV3DictionarySize)) {}
   const uLong v3_dictionary_id;
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Used to indicate no flags in a SPDY flags field.
 const uint8_t kNoFlags = 0;
 
@@ skipping 31 matching lines @@
   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) {
-  if (version < SPDY3) {
-    ConvertFlagsAndIdForSpdy2(&wire);
-  }
   return SettingsFlagsAndId(base::NetToHost32(wire) >> 24,
                             base::NetToHost32(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8_t flags, uint32_t id)
     : flags_(flags), id_(id & 0x00ffffff) {
   LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large: " << id;
 }
 
 uint32_t SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version) const {
-  uint32_t wire =
-      base::HostToNet32(id_ & 0x00ffffff) | base::HostToNet32(flags_ << 24);
-  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).
-void SettingsFlagsAndId::ConvertFlagsAndIdForSpdy2(uint32_t* val) {
-  uint8_t* wire_array = reinterpret_cast<uint8_t*>(val);
-    std::swap(wire_array[0], wire_array[3]);
-    std::swap(wire_array[1], wire_array[2]);
+  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) {
@@ skipping 71 matching lines @@
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
   // header block.
   size_t size = GetControlFrameHeaderSize();
   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() < SPDY3) {
-    size += 2;
-  }
-
   return size;
 }
 
 size_t SpdyFramer::GetRstStreamMinimumSize() const {
   // Size, in bytes, of a RST_STREAM frame.
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream id) + 4 (status code)
     return GetControlFrameHeaderSize() + 8;
   } else {
@@ skipping 28 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() >= SPDY3) {
-    size += 4;
-  }
+  // 3. GOAWAY frames also contain a status (4 bytes)
+  size += 4;
 
   return size;
 }
 
 size_t SpdyFramer::GetHeadersMinimumSize() const  {
   // Size, in bytes, of a HEADERS frame not including the variable-length
   // header block.
   size_t size = GetControlFrameHeaderSize();
   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() <= SPDY2) {
-    size += 2;
-  }
-
   return size;
 }
 
 size_t SpdyFramer::GetWindowUpdateSize() const {
   // Size, in bytes, of a WINDOW_UPDATE frame.
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream id) + 4 (delta)
     return GetControlFrameHeaderSize() + 8;
   } else {
@@ skipping 844 matching lines @@
     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 =
-      (spdy_version < SPDY3) ? sizeof(uint16_t) : sizeof(uint32_t);
+  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() +
                     length_of_value_size + header.second.size();
   }
   return total_length;
 }
 
 void SpdyFramer::WriteHeaderBlock(SpdyFrameBuilder* frame,
                                   const SpdyMajorVersion spdy_version,
                                   const SpdyHeaderBlock* headers) {
-  if (spdy_version < SPDY3) {
-    frame->WriteUInt16(static_cast<uint16_t>(headers->size()));
-  } else {
-    frame->WriteUInt32(headers->size());
-  }
+  frame->WriteUInt32(headers->size());
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
-    if (spdy_version < SPDY3) {
-      frame->WriteStringPiece16(it->first);
-      frame->WriteStringPiece16(it->second);
-    } else {
-      frame->WriteStringPiece32(it->first);
-      frame->WriteStringPiece32(it->second);
-    }
+    frame->WriteStringPiece32(it->first);
+    frame->WriteStringPiece32(it->second);
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 
 // These constants are used by zlib to differentiate between normal data and
 // cookie data. Cookie data is handled specially by zlib when compressing.
 enum ZDataClass {
@@ skipping 57 matching lines @@
     n >>= 8;
   }
   WriteZ(base::StringPiece(buf, length), clas, out);
 }
 
 // WriteHeaderBlockToZ serialises |headers| to the deflate context |z| in a
 // manner that resists the length of the compressed data from compromising
 // cookie data.
 void SpdyFramer::WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
                                      z_stream* z) const {
-  unsigned length_length = 4;
-  if (protocol_version() < 3)
-    length_length = 2;
-
+  const size_t length_length = 4;
   WriteLengthZ(headers->size(), length_length, kZStandardData, z);
 
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
     WriteLengthZ(it->first.size(), length_length, kZStandardData, z);
     WriteZ(it->first, kZStandardData, z);
 
     if (it->first == "cookie") {
       // We require the cookie values (save for the last) to end with a
       // semicolon and (save for the first) to start with a space. This is
@@ skipping 112 matching lines @@
             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() <= SPDY2) {
-            priority = priority >> 6;
-          } else {
-            priority = priority >> 5;
-          }
+          priority = priority >> 5;
 
           // Seek past unused byte.
           reader.Seek(1);
 
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
@@ skipping 27 matching lines @@
           }
           bool successful_read = true;
           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() <= SPDY2) {
-            // SPDY 2 had two unused bytes here. Seek past them.
-            reader.Seek(2);
-          }
           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;
           }
           if (protocol_version() > SPDY3 &&
               current_frame_flags_ & HEADERS_FLAG_PADDED) {
             uint8_t pad_payload_len = 0;
             DCHECK_EQ(remaining_padding_payload_length_, 0u);
@@ skipping 690 matching lines @@
   return original_len - len;
 }
 
 bool SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
                                           size_t header_length,
                                           SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
   uint32_t num_headers;
-  if (protocol_version() <= SPDY2) {
-    uint16_t temp;
-    if (!reader.ReadUInt16(&temp)) {
-      DVLOG(1) << "Unable to read number of headers.";
-      return false;
-    }
-    num_headers = temp;
-  } else {
-    if (!reader.ReadUInt32(&num_headers)) {
-      DVLOG(1) << "Unable to read number of headers.";
-      return false;
-    }
+  if (!reader.ReadUInt32(&num_headers)) {
+    DVLOG(1) << "Unable to read number of headers.";
+    return false;
   }
 
   // Read each header.
   for (uint32_t index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
-    if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
-                            : !reader.ReadStringPiece32(&temp)) {
+    if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
     std::string name = temp.as_string();
 
     // Read header value.
-    if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
-                            : !reader.ReadStringPiece32(&temp)) {
+    if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
     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 << ").";
@@ skipping 104 matching lines @@
   }
 
   // The size of this frame, including variable-length header block.
   size_t size = GetSynStreamMinimumSize() +
                 GetSerializedLength(syn_stream.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
   builder.WriteUInt32(syn_stream.stream_id());
   builder.WriteUInt32(syn_stream.associated_to_stream_id());
-  builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
+  builder.WriteUInt8(priority << 5);
   builder.WriteUInt8(0);  // Unused byte.
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeHeaderBlock(&builder, syn_stream);
 
   if (debug_visitor_) {
     const size_t payload_len =
         GetSerializedLength(protocol_version(), &(syn_stream.header_block()));
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
@@ skipping 18 matching lines @@
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
     builder.WriteUInt32(syn_reply.stream_id());
   } else {
     builder.BeginNewFrame(*this,
                           HEADERS,
                           flags,
                           syn_reply.stream_id());
   }
-  if (protocol_version() < SPDY3) {
-    builder.WriteUInt16(0);  // Unused.
-  }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   SerializeHeaderBlock(&builder, syn_reply);
 
   if (debug_visitor_) {
     const size_t payload_len =
         GetSerializedLength(protocol_version(), &(syn_reply.header_block()));
     debug_visitor_->OnSendCompressedFrame(syn_reply.stream_id(),
                                           SYN_REPLY,
                                           payload_len,
                                           builder.length());
@@ skipping 119 matching lines @@
   // Serialize the GOAWAY frame.
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, GOAWAY, kNoFlags);
   } else {
     builder.BeginNewFrame(*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.
+  // GOAWAY frames also specify the error status code.
   if (protocol_version() >= SPDY3) {
     // TODO(jgraettinger): Merge back to server-side.
     builder.WriteUInt32(SpdyConstants::SerializeGoAwayStatus(protocol_version(),
                                                              goaway.status()));
   }
 
   // In HTTP2 and up, GOAWAY frames may also specify opaque data.
   if ((protocol_version() > SPDY3) && (goaway.description().size() > 0)) {
     builder.WriteBytes(goaway.description().data(),
                        goaway.description().size());
@@ skipping 60 matching lines @@
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, HEADERS, flags);
     builder.WriteUInt32(headers.stream_id());
   } else {
     builder.BeginNewFrame(*this,
                           HEADERS,
                           flags,
                           headers.stream_id());
   }
-  if (protocol_version() <= SPDY2) {
-    builder.WriteUInt16(0);  // Unused.
-  }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   if (protocol_version() > SPDY3) {
     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(
@@ skipping 342 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 = (protocol_version() <= SPDY2) ?
-        kV2Dictionary : kV3Dictionary;
-    const int dictionary_size = (protocol_version() <= SPDY2) ?
-        kV2DictionarySize : kV3DictionarySize;
+    const char* dictionary = kV3Dictionary;
+    const int dictionary_size = 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 66 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 = (protocol_version() <= SPDY2) ? kV2Dictionary
-                                                             : kV3Dictionary;
-      const int dictionary_size = (protocol_version() <= SPDY2) ?
-          kV2DictionarySize : kV3DictionarySize;
+      const char* dictionary = kV3Dictionary;
+      const int dictionary_size = kV3DictionarySize;
       const DictionaryIds& ids = g_dictionary_ids.Get();
-      const uLong dictionary_id = (protocol_version() <= SPDY2) ?
-          ids.v2_dictionary_id : ids.v3_dictionary_id;
+      const uLong 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 50 matching lines @@
     return kDefaultHeaderTableSizeSetting;
   } else {
     return hpack_encoder_->CurrentHeaderTableSizeSetting();
   }
 }
 
 void SpdyFramer::SerializeHeaderBlockWithoutCompression(
     SpdyFrameBuilder* builder,
     const SpdyHeaderBlock& header_block) const {
   // Serialize number of headers.
-  if (protocol_version() <= SPDY2) {
-    builder->WriteUInt16(static_cast<uint16_t>(header_block.size()));
-  } else {
-    builder->WriteUInt32(header_block.size());
-  }
+  builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
-    if (protocol_version() <= SPDY2) {
-      builder->WriteStringPiece16(header.first);
-      builder->WriteStringPiece16(header.second);
-    } else {
-      builder->WriteStringPiece32(header.first);
-      builder->WriteStringPiece32(header.second);
-    }
+    builder->WriteStringPiece32(header.first);
+    builder->WriteStringPiece32(header.second);
   }
 }
 
 void SpdyFramer::SerializeHeaderBlock(SpdyFrameBuilder* builder,
                                       const SpdyFrameWithHeaderBlockIR& frame) {
   CHECK_GE(SPDY3, protocol_version());
   if (!enable_compression_) {
     return SerializeHeaderBlockWithoutCompression(builder,
                                                   frame.header_block());
   }
@@ skipping 43 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net