Land recent SPDY changes (through 70021377)

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) {}
 
 SpdyFrameWithNameValueBlockIR::~SpdyFrameWithNameValueBlockIR() {}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data)
     : SpdyFrameWithFinIR(stream_id),
-      pad_low_(false),
-      pad_high_(false),
+      padded_(false),
       padding_payload_len_(0) {
   SetDataDeep(data);
 }
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id)
     : SpdyFrameWithFinIR(stream_id),
-      pad_low_(false),
-      pad_high_(false),
+      padded_(false),
       padding_payload_len_(0) {}
 
 SpdyDataIR::~SpdyDataIR() {}
 
 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;
       }
 
-      // The valid range is non-contiguous.
-      if (frame_type_field == NOOP) {
-        return false;
-      }
-
       return true;
     case SPDY4:
     case SPDY5:
       // 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)) {
@@ skipping 122 matching lines @@
         default:
           LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;
           return -1;
       }
   }
 
   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;
       }
 
-      // COMPRESS_DATA is the last valid setting id.
+      // INITIAL_WINDOW_SIZE is the last valid setting id.
       if (setting_id_field >
-          SerializeSettingId(version, SETTINGS_COMPRESS_DATA)) {
+          SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_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_COMPRESS_DATA;
       }
       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_COMPRESS_DATA:
-          return 5;
         default:
           LOG(DFATAL) << "Serializing unhandled setting id " << id;
           return -1;
       }
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,
@@ skipping 402 matching lines @@
   } else {
     // 14-bit length field.
     return (1<<14) - 1;
   }
 }
 
 size_t SpdyConstants::GetSizeOfSizeField(SpdyMajorVersion version) {
   return (version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
 }
 
+size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
+  return version <= SPDY3 ? 8 : 6;
+}
+
 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 67 matching lines @@
 
 SpdyAltSvcIR::SpdyAltSvcIR(SpdyStreamId stream_id)
     : SpdyFrameWithStreamIdIR(stream_id),
       max_age_(0),
       port_(0) {}
 
 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitAltSvc(*this);
 }
 
+SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id)
+    : SpdyFrameWithStreamIdIR(stream_id) {
+}
+
+SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id,
+                               SpdyStreamId parent_stream_id,
+                               uint8 weight,
+                               bool exclusive)
+    : SpdyFrameWithStreamIdIR(stream_id),
+      parent_stream_id_(parent_stream_id),
+      weight_(weight),
+      exclusive_(exclusive) {
+}
+
+void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
+  return visitor->VisitPriority(*this);
+}
+
 }  // namespace net