Remove SPDY/2 code.

net/spdy/spdy_protocol.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_protocol.h"
 
 namespace net {
 
 bool SpdyConstants::IsValidFrameType(SpdyMajorVersion version,
                                      int frame_type_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       // SYN_STREAM is the first valid frame.
       if (frame_type_field < SerializeFrameType(version, SYN_STREAM)) {
         return false;
       }
 
       // WINDOW_UPDATE is the last valid frame.
       if (frame_type_field > SerializeFrameType(version, WINDOW_UPDATE)) {
         return false;
       }
@@ skipping 19 matching lines @@
       return true;
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return false;
 }
 
 SpdyFrameType SpdyConstants::ParseFrameType(SpdyMajorVersion version,
                                             int frame_type_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (frame_type_field) {
         case 1:
           return SYN_STREAM;
         case 2:
           return SYN_REPLY;
         case 3:
           return RST_STREAM;
         case 4:
           return SETTINGS;
@@ skipping 37 matching lines @@
       break;
   }
 
   LOG(DFATAL) << "Unhandled frame type " << frame_type_field;
   return DATA;
 }
 
 int SpdyConstants::SerializeFrameType(SpdyMajorVersion version,
                                       SpdyFrameType frame_type) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (frame_type) {
         case SYN_STREAM:
           return 1;
         case SYN_REPLY:
           return 2;
         case RST_STREAM:
           return 3;
         case SETTINGS:
           return 4;
@@ skipping 41 matching lines @@
           return -1;
       }
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 int SpdyConstants::DataFrameType(SpdyMajorVersion version) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       return 0;
     case HTTP2:
       return SerializeFrameType(version, DATA);
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return 0;
 }
 
 bool SpdyConstants::IsValidSettingId(SpdyMajorVersion version,
                                      int setting_id_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       // UPLOAD_BANDWIDTH is the first valid setting id.
       if (setting_id_field <
           SerializeSettingId(version, SETTINGS_UPLOAD_BANDWIDTH)) {
         return false;
       }
 
       // INITIAL_WINDOW_SIZE is the last valid setting id.
       if (setting_id_field >
           SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_SIZE)) {
@@ skipping 17 matching lines @@
       return true;
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return false;
 }
 
 SpdySettingsIds SpdyConstants::ParseSettingId(SpdyMajorVersion version,
                                               int setting_id_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (setting_id_field) {
         case 1:
           return SETTINGS_UPLOAD_BANDWIDTH;
         case 2:
           return SETTINGS_DOWNLOAD_BANDWIDTH;
         case 3:
           return SETTINGS_ROUND_TRIP_TIME;
         case 4:
           return SETTINGS_MAX_CONCURRENT_STREAMS;
@@ skipping 23 matching lines @@
       break;
   }
 
   LOG(DFATAL) << "Unhandled setting ID " << setting_id_field;
   return SETTINGS_UPLOAD_BANDWIDTH;
 }
 
 int SpdyConstants::SerializeSettingId(SpdyMajorVersion version,
                                        SpdySettingsIds id) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (id) {
         case SETTINGS_UPLOAD_BANDWIDTH:
           return 1;
         case SETTINGS_DOWNLOAD_BANDWIDTH:
           return 2;
         case SETTINGS_ROUND_TRIP_TIME:
           return 3;
         case SETTINGS_MAX_CONCURRENT_STREAMS:
           return 4;
@@ skipping 26 matching lines @@
           return -1;
       }
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,
                                            int rst_stream_status_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       // PROTOCOL_ERROR is the valid first status code.
       if (rst_stream_status_field <
           SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_ERROR)) {
         return false;
       }
 
       // FRAME_TOO_LARGE is the valid last status code.
       if (rst_stream_status_field >
           SerializeRstStreamStatus(version, RST_STREAM_FRAME_TOO_LARGE)) {
@@ skipping 28 matching lines @@
       return true;
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return false;
 }
 
 SpdyRstStreamStatus SpdyConstants::ParseRstStreamStatus(
     SpdyMajorVersion version,
     int rst_stream_status_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (rst_stream_status_field) {
         case 1:
           return RST_STREAM_PROTOCOL_ERROR;
         case 2:
           return RST_STREAM_INVALID_STREAM;
         case 3:
           return RST_STREAM_REFUSED_STREAM;
         case 4:
           return RST_STREAM_UNSUPPORTED_VERSION;
@@ skipping 40 matching lines @@
   }
 
   LOG(DFATAL) << "Invalid RST_STREAM status " << rst_stream_status_field;
   return RST_STREAM_PROTOCOL_ERROR;
 }
 
 int SpdyConstants::SerializeRstStreamStatus(
     SpdyMajorVersion version,
     SpdyRstStreamStatus rst_stream_status) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (rst_stream_status) {
         case RST_STREAM_PROTOCOL_ERROR:
           return 1;
         case RST_STREAM_INVALID_STREAM:
           return 2;
         case RST_STREAM_REFUSED_STREAM:
           return 3;
         case RST_STREAM_UNSUPPORTED_VERSION:
           return 4;
@@ skipping 44 matching lines @@
           return -1;
       }
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 bool SpdyConstants::IsValidGoAwayStatus(SpdyMajorVersion version,
                                         int goaway_status_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       // GOAWAY_OK is the first valid status.
       if (goaway_status_field < SerializeGoAwayStatus(version, GOAWAY_OK)) {
         return false;
       }
 
       // GOAWAY_INTERNAL_ERROR is the last valid status.
       if (goaway_status_field > SerializeGoAwayStatus(version,
                                                       GOAWAY_INTERNAL_ERROR)) {
         return false;
@@ skipping 15 matching lines @@
 
       return true;
   }
   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
   return false;
 }
 
 SpdyGoAwayStatus SpdyConstants::ParseGoAwayStatus(SpdyMajorVersion version,
                                                   int goaway_status_field) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       switch (goaway_status_field) {
         case 0:
           return GOAWAY_OK;
         case 1:
           return GOAWAY_PROTOCOL_ERROR;
         case 2:
           return GOAWAY_INTERNAL_ERROR;
       }
       break;
@@ skipping 31 matching lines @@
       break;
   }
 
   LOG(DFATAL) << "Unhandled GOAWAY status " << goaway_status_field;
   return GOAWAY_PROTOCOL_ERROR;
 }
 
 int SpdyConstants::SerializeGoAwayStatus(SpdyMajorVersion version,
                                          SpdyGoAwayStatus status) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       // TODO(jgraettinger): Merge this back to server-side.
       switch (status) {
         case GOAWAY_NO_ERROR:
           return 0;
         case GOAWAY_PROTOCOL_ERROR:
         case GOAWAY_INTERNAL_ERROR:
         case GOAWAY_FLOW_CONTROL_ERROR:
         case GOAWAY_SETTINGS_TIMEOUT:
         case GOAWAY_STREAM_CLOSED:
@@ skipping 44 matching lines @@
           LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;
           return -1;
       }
   }
   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
   return -1;
 }
 
 size_t SpdyConstants::GetDataFrameMinimumSize(SpdyMajorVersion version) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       return 8;
     case HTTP2:
       return 9;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetControlFrameHeaderSize(SpdyMajorVersion version) {
   switch (version) {
-    case SPDY2:
     case SPDY3:
       return 8;
     case HTTP2:
       return 9;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,
@@ skipping 11 matching lines @@
     return ((1<<24) - 1) + 8;
   } else {
     // Max payload of 2^14 plus nine-byte frame header.
     // TODO(mlavan): In HTTP/2 this is actually not a constant;
     // payload size can be set using the MAX_FRAME_SIZE setting to
     // anything between 1 << 14 and (1 << 24) - 1
     return (1 << 14) + 9;
   }
 }
 
-size_t SpdyConstants::GetSizeOfSizeField(SpdyMajorVersion version) {
-  return (version < SPDY3) ? sizeof(uint16_t) : sizeof(uint32_t);
+size_t SpdyConstants::GetSizeOfSizeField() {
+  return sizeof(uint32_t);
 }
 
 size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
   return version <= SPDY3 ? 8 : 6;
 }
 
 int32_t SpdyConstants::GetInitialStreamWindowSize(SpdyMajorVersion version) {
   return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);
 }
 
 int32_t SpdyConstants::GetInitialSessionWindowSize(SpdyMajorVersion version) {
   return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);
 }
 
 SpdyMajorVersion SpdyConstants::ParseMajorVersion(int version_number) {
   switch (version_number) {
-    case 2:
-      return SPDY2;
     case 3:
       return SPDY3;
     case 4:
       return HTTP2;
     default:
       LOG(DFATAL) << "Unsupported SPDY version number: " << version_number;
       return SPDY3;
   }
 }
 
 int SpdyConstants::SerializeMajorVersion(SpdyMajorVersion version) {
   switch (version) {
-    case SPDY2:
-      return 2;
     case SPDY3:
       return 3;
     case HTTP2:
       return 4;
     default:
       LOG(DFATAL) << "Unsupported SPDY major version: " << version;
       return -1;
   }
 }
 
 std::string SpdyConstants::GetVersionString(SpdyMajorVersion version) {
   switch (version) {
-    case SPDY2:
-      return "spdy/2";
     case SPDY3:
       return "spdy/3";
     case HTTP2:
       return "h2";
     default:
       LOG(DFATAL) << "Unsupported SPDY major version: " << version;
       return "spdy/3";
   }
 }
 
@@ skipping 93 matching lines @@
 
 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitAltSvc(*this);
 }
 
 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriority(*this);
 }
 
 }  // namespace net