HTTP2 draft 14 support

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 25 matching lines @@
       }
 
       // 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;
       }
 
-      // BLOCKED is the last valid frame.
-      if (frame_type_field > SerializeFrameType(version, BLOCKED)) {
+      // CONTINUATION is the last valid frame.
+      if (frame_type_field > SerializeFrameType(version, CONTINUATION)) {
         return false;
       }
 
       return true;
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return false;
 }
 
@@ skipping 98 matching lines @@
         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:
           LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;
           return -1;
       }
   }
 
@@ skipping 34 matching lines @@
 
       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;
       }
 
-      // INITIAL_WINDOW_SIZE is the last valid setting id.
+      // MAX_HEADER_LIST_SIZE is the last valid setting id.
       if (setting_id_field >
-          SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_SIZE)) {
+          SerializeSettingId(version, SETTINGS_MAX_HEADER_LIST_SIZE)) {
         return false;
       }
 
       return true;
   }
 
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return false;
 }
 
@@ skipping 23 matching lines @@
     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:
+          return SETTINGS_MAX_FRAME_SIZE;
+        case 6:
+          return SETTINGS_MAX_HEADER_LIST_SIZE;
       }
       break;
   }
 
   LOG(DFATAL) << "Unhandled setting ID " << setting_id_field;
   return SETTINGS_UPLOAD_BANDWIDTH;
 }
 
 int SpdyConstants::SerializeSettingId(SpdyMajorVersion version,
                                        SpdySettingsIds id) {
@@ skipping 23 matching lines @@
     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:
+          return 5;
+        case SETTINGS_MAX_HEADER_LIST_SIZE:
+          return 6;
         default:
           LOG(DFATAL) << "Serializing unhandled setting id " << id;
           return -1;
       }
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,
@@ skipping 363 matching lines @@
           return 12;
         default:
           LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;
           return -1;
       }
   }
   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
   return -1;
 }
 
-size_t SpdyConstants::GetDataFrameMinimumSize() {
-  return 8;
+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 8;
+      return 9;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,
                                       SpdyMajorVersion version) {
   if (type != DATA) {
      return GetControlFrameHeaderSize(version);
   } else {
-     return GetDataFrameMinimumSize();
+     return GetDataFrameMinimumSize(version);
   }
 }
 
 size_t SpdyConstants::GetFrameMaximumSize(SpdyMajorVersion version) {
   if (version < SPDY4) {
     // 24-bit length field plus eight-byte frame header.
     return ((1<<24) - 1) + 8;
   } else {
-    // 14-bit length field.
-    return (1<<14) - 1;
+    // 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) : sizeof(uint32);
 }
 
 size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
   return version <= SPDY3 ? 8 : 6;
 }
@@ skipping 97 matching lines @@
       parent_stream_id_(parent_stream_id),
       weight_(weight),
       exclusive_(exclusive) {
 }
 
 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriority(*this);
 }
 
 }  // namespace net