Update from https://crrev.com/312398

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 {
 
 SpdyFrameWithNameValueBlockIR::SpdyFrameWithNameValueBlockIR(
     SpdyStreamId stream_id) : SpdyFrameWithFinIR(stream_id) {}
@@ skipping 24 matching lines @@
         return false;
       }
 
       // WINDOW_UPDATE is the last valid frame.
       if (frame_type_field > SerializeFrameType(version, WINDOW_UPDATE)) {
         return false;
       }
 
       return true;
     case SPDY4:
-    case SPDY5:
       // Check for recognized extensions.
       if (frame_type_field == SerializeFrameType(version, ALTSVC) ||
           frame_type_field == SerializeFrameType(version, BLOCKED)) {
         return true;
       }
 
       // DATA is the first valid frame.
       if (frame_type_field < SerializeFrameType(version, DATA)) {
         return false;
       }
@@ skipping 28 matching lines @@
           return PING;
         case 7:
           return GOAWAY;
         case 8:
           return HEADERS;
         case 9:
           return WINDOW_UPDATE;
       }
       break;
     case SPDY4:
-    case SPDY5:
       switch (frame_type_field) {
         case 0:
           return DATA;
         case 1:
           return HEADERS;
         case 2:
           return PRIORITY;
         case 3:
           return RST_STREAM;
         case 4:
@@ skipping 40 matching lines @@
           return 7;
         case HEADERS:
           return 8;
         case WINDOW_UPDATE:
           return 9;
         default:
           LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;
           return -1;
       }
     case SPDY4:
-    case SPDY5:
       switch (frame_type) {
         case DATA:
           return 0;
         case HEADERS:
           return 1;
         case PRIORITY:
           return 2;
         case RST_STREAM:
           return 3;
         case SETTINGS:
@@ skipping 22 matching lines @@
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 int SpdyConstants::DataFrameType(SpdyMajorVersion version) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       return 0;
     case SPDY4:
-    case SPDY5:
       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)) {
         return false;
       }
 
       return true;
     case SPDY4:
-    case SPDY5:
       // HEADER_TABLE_SIZE is the first valid setting id.
       if (setting_id_field <
           SerializeSettingId(version, 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)) {
         return false;
@@ skipping 22 matching lines @@
           return SETTINGS_MAX_CONCURRENT_STREAMS;
         case 5:
           return SETTINGS_CURRENT_CWND;
         case 6:
           return SETTINGS_DOWNLOAD_RETRANS_RATE;
         case 7:
           return SETTINGS_INITIAL_WINDOW_SIZE;
       }
       break;
     case SPDY4:
-    case SPDY5:
       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:
@@ skipping 26 matching lines @@
           return 5;
         case SETTINGS_DOWNLOAD_RETRANS_RATE:
           return 6;
         case SETTINGS_INITIAL_WINDOW_SIZE:
           return 7;
         default:
           LOG(DFATAL) << "Serializing unhandled setting id " << id;
           return -1;
       }
     case SPDY4:
-    case SPDY5:
       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:
@@ skipping 21 matching lines @@
       }
 
       // FRAME_TOO_LARGE is the valid last status code.
       if (rst_stream_status_field >
           SerializeRstStreamStatus(version, RST_STREAM_FRAME_TOO_LARGE)) {
         return false;
       }
 
       return true;
     case SPDY4:
-    case SPDY5:
       // NO_ERROR is the first valid status code.
       if (rst_stream_status_field <
           SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_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 ==
@@ skipping 41 matching lines @@
           return RST_STREAM_STREAM_IN_USE;
         case 9:
           return RST_STREAM_STREAM_ALREADY_CLOSED;
         case 10:
           return RST_STREAM_INVALID_CREDENTIALS;
         case 11:
           return RST_STREAM_FRAME_TOO_LARGE;
       }
       break;
     case SPDY4:
-    case SPDY5:
       switch (rst_stream_status_field) {
         case 1:
           return RST_STREAM_PROTOCOL_ERROR;
         case 2:
           return RST_STREAM_INTERNAL_ERROR;
         case 3:
           return RST_STREAM_FLOW_CONTROL_ERROR;
         case 5:
           return RST_STREAM_STREAM_CLOSED;
         case 6:
@@ skipping 46 matching lines @@
         case RST_STREAM_INVALID_CREDENTIALS:
           return 10;
         case RST_STREAM_FRAME_TOO_LARGE:
           return 11;
         default:
           LOG(DFATAL) << "Unhandled RST_STREAM status "
                       << rst_stream_status;
           return -1;
       }
     case SPDY4:
-    case SPDY5:
       switch (rst_stream_status) {
         case RST_STREAM_PROTOCOL_ERROR:
           return 1;
         case RST_STREAM_INTERNAL_ERROR:
           return 2;
         case RST_STREAM_FLOW_CONTROL_ERROR:
           return 3;
         case RST_STREAM_STREAM_CLOSED:
           return 5;
         case RST_STREAM_FRAME_SIZE_ERROR:
@@ skipping 31 matching lines @@
       }
 
       // GOAWAY_INTERNAL_ERROR is the last valid status.
       if (goaway_status_field > SerializeGoAwayStatus(version,
                                                       GOAWAY_INTERNAL_ERROR)) {
         return false;
       }
 
       return true;
     case SPDY4:
-    case SPDY5:
       // GOAWAY_NO_ERROR is the first valid status.
       if (goaway_status_field < SerializeGoAwayStatus(version,
                                                       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)) {
         return false;
@@ skipping 13 matching lines @@
       switch (goaway_status_field) {
         case 0:
           return GOAWAY_OK;
         case 1:
           return GOAWAY_PROTOCOL_ERROR;
         case 2:
           return GOAWAY_INTERNAL_ERROR;
       }
       break;
     case SPDY4:
-    case SPDY5:
       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 25 matching lines @@
 }
 
 SpdyMajorVersion SpdyConstants::ParseMajorVersion(int version_number) {
   switch (version_number) {
     case 2:
       return SPDY2;
     case 3:
       return SPDY3;
     case 4:
       return SPDY4;
-    case 5:
-      return SPDY5;
     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 SPDY4:
       return 4;
-    case SPDY5:
-      return 5;
     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 SPDY4:
-      return "spdy/4";
-    case SPDY5:
-      return "spdy/5";
+      return "h2-14";
     default:
       LOG(DFATAL) << "Unsupported SPDY major version: " << version;
       return "spdy/3";
   }
 }
 
 int SpdyConstants::SerializeGoAwayStatus(SpdyMajorVersion version,
                                          SpdyGoAwayStatus status) {
   switch (version) {
     case SPDY2:
@@ skipping 14 matching lines @@
         case GOAWAY_CONNECT_ERROR:
         case GOAWAY_ENHANCE_YOUR_CALM:
         case GOAWAY_INADEQUATE_SECURITY:
         case GOAWAY_HTTP_1_1_REQUIRED:
           return 1;  // PROTOCOL_ERROR.
         default:
           LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;
           return -1;
       }
     case SPDY4:
-    case SPDY5:
       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 24 matching lines @@
   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
   return -1;
 }
 
 size_t SpdyConstants::GetDataFrameMinimumSize(SpdyMajorVersion version) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       return 8;
     case SPDY4:
-    case SPDY5:
       return 9;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetControlFrameHeaderSize(SpdyMajorVersion version) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       return 8;
     case SPDY4:
-    case SPDY5:
       return 9;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,
                                       SpdyMajorVersion version) {
   if (type != DATA) {
      return GetControlFrameHeaderSize(version);
@@ skipping 16 matching lines @@
 }
 
 size_t SpdyConstants::GetSizeOfSizeField(SpdyMajorVersion version) {
   return (version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
 }
 
 size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
   return version <= SPDY3 ? 8 : 6;
 }
 
+int32 SpdyConstants::GetInitialStreamWindowSize(SpdyMajorVersion version) {
+  return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);
+}
+
+int32 SpdyConstants::GetInitialSessionWindowSize(SpdyMajorVersion version) {
+  return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);
+}
+
 void SpdyDataIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitData(*this);
 }
 
 void SpdySynStreamIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSynStream(*this);
 }
 
 void SpdySynReplyIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSynReply(*this);
@@ skipping 86 matching lines @@
       parent_stream_id_(parent_stream_id),
       weight_(weight),
       exclusive_(exclusive) {
 }
 
 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriority(*this);
 }
 
 }  // namespace net