Remove enum SpdyMajorVersion.

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"
 
 #include "base/memory/ptr_util.h"
 #include "net/spdy/spdy_bug_tracker.h"
 
 namespace net {
@@ skipping 27 matching lines @@
   const float kSteps = 255.9f / 7.f;
   return static_cast<int>(kSteps * (7.f - priority)) + 1;
 }
 
 SpdyPriority Http2WeightToSpdy3Priority(int weight) {
   weight = ClampHttp2Weight(weight);
   const float kSteps = 255.9f / 7.f;
   return static_cast<SpdyPriority>(7.f - (weight - 1) / kSteps);
 }
 
-bool SpdyConstants::IsValidFrameType(SpdyMajorVersion version,
-                                     int frame_type_field) {
+bool SpdyConstants::IsValidFrameType(int frame_type_field) {
   // Check for recognized extensions.
-  if (frame_type_field == SerializeFrameType(version, ALTSVC) ||
-      frame_type_field == SerializeFrameType(version, BLOCKED)) {
+  if (frame_type_field == SerializeFrameType(ALTSVC) ||
+      frame_type_field == SerializeFrameType(BLOCKED)) {
     return true;
   }
 
   // DATA is the first valid frame.
-  if (frame_type_field < SerializeFrameType(version, DATA)) {
+  if (frame_type_field < SerializeFrameType(DATA)) {
     return false;
   }
 
   // CONTINUATION is the last valid frame.
-  if (frame_type_field > SerializeFrameType(version, CONTINUATION)) {
+  if (frame_type_field > SerializeFrameType(CONTINUATION)) {
     return false;
   }
 
   return true;
 }
 
-SpdyFrameType SpdyConstants::ParseFrameType(SpdyMajorVersion /*version*/,
-                                            int frame_type_field) {
+SpdyFrameType SpdyConstants::ParseFrameType(int frame_type_field) {
   switch (frame_type_field) {
     case 0:
       return DATA;
     case 1:
       return HEADERS;
     case 2:
       return PRIORITY;
     case 3:
       return RST_STREAM;
     case 4:
@@ skipping 10 matching lines @@
       return CONTINUATION;
     case 10:
       return ALTSVC;
     case 11:
       return BLOCKED;
   }
   SPDY_BUG << "Unhandled frame type " << frame_type_field;
   return DATA;
 }
 
-int SpdyConstants::SerializeFrameType(SpdyMajorVersion /*version*/,
-                                      SpdyFrameType frame_type) {
+int SpdyConstants::SerializeFrameType(SpdyFrameType frame_type) {
   switch (frame_type) {
     case DATA:
-      return 0;
+      return kDataFrameType;
     case HEADERS:
       return 1;
     case PRIORITY:
       return 2;
     case RST_STREAM:
       return 3;
     case SETTINGS:
       return 4;
     case PUSH_PROMISE:
       return 5;
     case PING:
       return 6;
     case GOAWAY:
       return 7;
     case WINDOW_UPDATE:
       return 8;
     case CONTINUATION:
       return 9;
     // ALTSVC and BLOCKED are extensions.
     case ALTSVC:
       return 10;
     case BLOCKED:
       return 11;
     default:
       SPDY_BUG << "Serializing unhandled frame type " << frame_type;
       return -1;
   }
 }
 
-int SpdyConstants::DataFrameType(SpdyMajorVersion version) {
-  return SerializeFrameType(version, DATA);
-}
-
 bool SpdyConstants::IsValidHTTP2FrameStreamId(
     SpdyStreamId current_frame_stream_id,
     SpdyFrameType frame_type_field) {
   if (current_frame_stream_id == 0) {
     switch (frame_type_field) {
       case DATA:
       case HEADERS:
       case PRIORITY:
       case RST_STREAM:
       case CONTINUATION:
       case PUSH_PROMISE:
         // These frame types must specify a stream
         return false;
       default:
         return true;
     }
   } else {
     switch (frame_type_field) {
       case GOAWAY:
       case SETTINGS:
       case PING:
         // These frame types must not specify a stream
         return false;
       default:
         return true;
     }
   }
 }
 
-bool SpdyConstants::IsValidSettingId(SpdyMajorVersion version,
-                                     int setting_id_field) {
+bool SpdyConstants::IsValidSettingId(int setting_id_field) {
   // HEADER_TABLE_SIZE is the first valid setting id.
-  if (setting_id_field <
-      SerializeSettingId(version, SETTINGS_HEADER_TABLE_SIZE)) {
+  if (setting_id_field < SerializeSettingId(SETTINGS_HEADER_TABLE_SIZE)) {
     return false;
   }
 
   // MAX_HEADER_LIST_SIZE is the last valid setting id.
-  if (setting_id_field >
-      SerializeSettingId(version, SETTINGS_MAX_HEADER_LIST_SIZE)) {
+  if (setting_id_field > SerializeSettingId(SETTINGS_MAX_HEADER_LIST_SIZE)) {
     return false;
   }
 
   return true;
 }
 
-SpdySettingsIds SpdyConstants::ParseSettingId(SpdyMajorVersion /*version*/,
-                                              int setting_id_field) {
+SpdySettingsIds SpdyConstants::ParseSettingId(int setting_id_field) {
   switch (setting_id_field) {
     case 1:
       return SETTINGS_HEADER_TABLE_SIZE;
     case 2:
       return SETTINGS_ENABLE_PUSH;
     case 3:
       return SETTINGS_MAX_CONCURRENT_STREAMS;
     case 4:
       return SETTINGS_INITIAL_WINDOW_SIZE;
     case 5:
       return SETTINGS_MAX_FRAME_SIZE;
     case 6:
       return SETTINGS_MAX_HEADER_LIST_SIZE;
   }
   SPDY_BUG << "Unhandled setting ID " << setting_id_field;
   return SETTINGS_UPLOAD_BANDWIDTH;
 }
 
-int SpdyConstants::SerializeSettingId(SpdyMajorVersion /*version*/,
-                                      SpdySettingsIds id) {
+int SpdyConstants::SerializeSettingId(SpdySettingsIds id) {
   switch (id) {
     case SETTINGS_HEADER_TABLE_SIZE:
       return 1;
     case SETTINGS_ENABLE_PUSH:
       return 2;
     case SETTINGS_MAX_CONCURRENT_STREAMS:
       return 3;
     case SETTINGS_INITIAL_WINDOW_SIZE:
       return 4;
     case SETTINGS_MAX_FRAME_SIZE:
       return 5;
     case SETTINGS_MAX_HEADER_LIST_SIZE:
       return 6;
     default:
       SPDY_BUG << "Serializing unhandled setting id " << id;
       return -1;
   }
 }
 
-bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,
-                                           int rst_stream_status_field) {
+bool SpdyConstants::IsValidRstStreamStatus(int rst_stream_status_field) {
   // NO_ERROR is the first valid status code.
-  if (rst_stream_status_field <
-      SerializeRstStreamStatus(version, RST_STREAM_NO_ERROR)) {
+  if (rst_stream_status_field < SerializeRstStreamStatus(RST_STREAM_NO_ERROR)) {
     return false;
   }
 
   // TODO(hkhalil): Omit COMPRESSION_ERROR and SETTINGS_TIMEOUT
   /*
   // This works because GOAWAY and RST_STREAM share a namespace.
   if (rst_stream_status_field ==
   SerializeGoAwayStatus(version, GOAWAY_COMPRESSION_ERROR) ||
   rst_stream_status_field ==
   SerializeGoAwayStatus(version, GOAWAY_SETTINGS_TIMEOUT)) {
   return false;
   }
   */
 
   // HTTP_1_1_REQUIRED is the last valid status code.
   if (rst_stream_status_field >
-      SerializeRstStreamStatus(version, RST_STREAM_HTTP_1_1_REQUIRED)) {
+      SerializeRstStreamStatus(RST_STREAM_HTTP_1_1_REQUIRED)) {
     return false;
   }
 
   return true;
 }
 
 SpdyRstStreamStatus SpdyConstants::ParseRstStreamStatus(
-    SpdyMajorVersion /*version*/,
     int rst_stream_status_field) {
   switch (rst_stream_status_field) {
     case 0:
       return RST_STREAM_NO_ERROR;
     case 1:
       return RST_STREAM_PROTOCOL_ERROR;
     case 2:
       return RST_STREAM_INTERNAL_ERROR;
     case 3:
       return RST_STREAM_FLOW_CONTROL_ERROR;
@@ skipping 13 matching lines @@
       return RST_STREAM_INADEQUATE_SECURITY;
     case 13:
       return RST_STREAM_HTTP_1_1_REQUIRED;
   }
 
   SPDY_BUG << "Invalid RST_STREAM status " << rst_stream_status_field;
   return RST_STREAM_PROTOCOL_ERROR;
 }
 
 int SpdyConstants::SerializeRstStreamStatus(
-    SpdyMajorVersion /*version*/,
     SpdyRstStreamStatus rst_stream_status) {
   switch (rst_stream_status) {
     case RST_STREAM_NO_ERROR:
       return 0;
     case RST_STREAM_PROTOCOL_ERROR:
       return 1;
     case RST_STREAM_INTERNAL_ERROR:
       return 2;
     case RST_STREAM_FLOW_CONTROL_ERROR:
       return 3;
@@ skipping 12 matching lines @@
     case RST_STREAM_INADEQUATE_SECURITY:
       return 12;
     case RST_STREAM_HTTP_1_1_REQUIRED:
       return 13;
     default:
       SPDY_BUG << "Unhandled RST_STREAM status " << rst_stream_status;
       return -1;
   }
 }
 
-bool SpdyConstants::IsValidGoAwayStatus(SpdyMajorVersion version,
-                                        int goaway_status_field) {
+bool SpdyConstants::IsValidGoAwayStatus(int goaway_status_field) {
   // GOAWAY_NO_ERROR is the first valid status.
-  if (goaway_status_field < SerializeGoAwayStatus(version, GOAWAY_NO_ERROR)) {
+  if (goaway_status_field < SerializeGoAwayStatus(GOAWAY_NO_ERROR)) {
     return false;
   }
 
   // GOAWAY_HTTP_1_1_REQUIRED is the last valid status.
-  if (goaway_status_field >
-      SerializeGoAwayStatus(version, GOAWAY_HTTP_1_1_REQUIRED)) {
+  if (goaway_status_field > SerializeGoAwayStatus(GOAWAY_HTTP_1_1_REQUIRED)) {
     return false;
   }
 
   return true;
 }
 
-SpdyGoAwayStatus SpdyConstants::ParseGoAwayStatus(SpdyMajorVersion /*version*/,
-                                                  int goaway_status_field) {
+SpdyGoAwayStatus SpdyConstants::ParseGoAwayStatus(int goaway_status_field) {
   switch (goaway_status_field) {
     case 0:
       return GOAWAY_NO_ERROR;
     case 1:
       return GOAWAY_PROTOCOL_ERROR;
     case 2:
       return GOAWAY_INTERNAL_ERROR;
     case 3:
       return GOAWAY_FLOW_CONTROL_ERROR;
     case 4:
@@ skipping 15 matching lines @@
     case 12:
       return GOAWAY_INADEQUATE_SECURITY;
     case 13:
       return GOAWAY_HTTP_1_1_REQUIRED;
   }
 
   SPDY_BUG << "Unhandled GOAWAY status " << goaway_status_field;
   return GOAWAY_PROTOCOL_ERROR;
 }
 
-int SpdyConstants::SerializeGoAwayStatus(SpdyMajorVersion /*version*/,
-                                         SpdyGoAwayStatus status) {
+int SpdyConstants::SerializeGoAwayStatus(SpdyGoAwayStatus status) {
   switch (status) {
     case GOAWAY_NO_ERROR:
       return 0;
     case GOAWAY_PROTOCOL_ERROR:
       return 1;
     case GOAWAY_INTERNAL_ERROR:
       return 2;
     case GOAWAY_FLOW_CONTROL_ERROR:
       return 3;
     case GOAWAY_SETTINGS_TIMEOUT:
@@ skipping 15 matching lines @@
     case GOAWAY_INADEQUATE_SECURITY:
       return 12;
     case GOAWAY_HTTP_1_1_REQUIRED:
       return 13;
     default:
       SPDY_BUG << "Serializing unhandled GOAWAY status " << status;
       return -1;
   }
 }
 
-size_t SpdyConstants::GetFrameHeaderSize(SpdyMajorVersion /*version*/) {
-  return 9;
-}
+const int SpdyConstants::kDataFrameType = 0;
 
-size_t SpdyConstants::GetDataFrameMinimumSize(SpdyMajorVersion version) {
-  return GetFrameHeaderSize(version);
-}
+const size_t SpdyConstants::kFrameHeaderSize = 9;
 
-size_t SpdyConstants::GetMaxFrameSizeLimit(SpdyMajorVersion version) {
-  return kSpdyMaxFrameSizeLimit + GetFrameHeaderSize(version);
-}
+const size_t SpdyConstants::kDataFrameMinimumSize = kFrameHeaderSize;
 
-size_t SpdyConstants::GetSizeOfSizeField() {
-  return sizeof(uint32_t);
-}
+const size_t SpdyConstants::kMaxFrameSizeLimit =
+    kSpdyMaxFrameSizeLimit + kFrameHeaderSize;
 
-size_t SpdyConstants::GetPerHeaderOverhead(SpdyMajorVersion version) {
-  return (version == net::HTTP2) ? 32 : 0;
-}
+const size_t SpdyConstants::kSizeOfSizeField = sizeof(uint32_t);
 
-size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
-  return 6;
-}
+const size_t SpdyConstants::kPerHeaderOverhead = 32;
 
-int32_t SpdyConstants::GetInitialStreamWindowSize(SpdyMajorVersion version) {
-  return 64 * 1024 - 1;
-}
+const int32_t SpdyConstants::kInitialStreamWindowSize = 64 * 1024 - 1;
 
-int32_t SpdyConstants::GetInitialSessionWindowSize(SpdyMajorVersion version) {
-  return 64 * 1024 - 1;
-}
+const int32_t SpdyConstants::kInitialSessionWindowSize = 64 * 1024 - 1;
 
-std::string SpdyConstants::GetVersionString(SpdyMajorVersion version) {
-  switch (version) {
-    case HTTP2:
-      return "h2";
-    default:
-      SPDY_BUG << "Unsupported SPDY major version: " << version;
-      return "h2";
-  }
-}
+const char SpdyConstants::kHttp2Npn[] = "h2";
 
 SpdyFrameWithHeaderBlockIR::SpdyFrameWithHeaderBlockIR(
     SpdyStreamId stream_id,
     SpdyHeaderBlock header_block)
     : SpdyFrameWithFinIR(stream_id), header_block_(std::move(header_block)) {}
 
 SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() {}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, base::StringPiece data)
     : SpdyFrameWithFinIR(stream_id),
@@ skipping 120 matching lines @@
 
 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitAltSvc(*this);
 }
 
 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriority(*this);
 }
 
 }  // namespace net