SPDY4: Turn SYN_STREAM and SYN_REPLY into HEADERS.

net/spdy/spdy_framer.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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 161 matching lines @@
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
   // name-value block.
   if (spdy_version_ < 4) {
     // Calculated as:
     // control frame header + 2 * 4 (stream IDs) + 1 (priority) + 1 (slot)
     return GetControlFrameHeaderSize() + 10;
   } else {
     // Calculated as:
-    // frame prefix + 4 (associated stream ID) + 1 (priority) + 1 (slot)
-    return GetControlFrameHeaderSize() + 6;
+    // frame prefix + 4 (priority)
+    return GetControlFrameHeaderSize() + 4;
   }
 }
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
   // name-value block.
   size_t size = GetControlFrameHeaderSize();
   if (spdy_version_ < 4) {
     // Calculated as:
     // control frame header + 4 (stream IDs)
@@ skipping 482 matching lines @@
 
   if (current_frame_type_ == NOOP) {
     DVLOG(1) << "NOOP control frame found. Ignoring.";
     CHANGE_STATE(SPDY_AUTO_RESET);
     return;
   }
 
   // Do some sanity checking on the control frame sizes and flags.
   switch (current_frame_type_) {
     case SYN_STREAM:
+      DCHECK_GT(4, spdy_version_);
       if (current_frame_length_ < GetSynStreamMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ &
                  ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SYN_REPLY:
       if (current_frame_length_ < GetSynReplyMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 31 matching lines @@
     case GOAWAY:
       {
         if (current_frame_length_ != GetGoAwaySize()) {
           set_error(SPDY_INVALID_CONTROL_FRAME);
         } else if (current_frame_flags_ != 0) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
         }
         break;
       }
     case HEADERS:
-      if (current_frame_length_ < GetHeadersMinimumSize()) {
-        set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if (current_frame_flags_ & ~CONTROL_FLAG_FIN) {
-        set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
+      {
+        size_t min_size = GetHeadersMinimumSize();
+        if (spdy_version_ > 3 &&
+            (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
+          min_size += 4;
+        }
+        if (current_frame_length_ < min_size) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+        } else if (spdy_version_ < 4 &&
+                   current_frame_flags_ & ~CONTROL_FLAG_FIN) {
+          set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
+        } else if (spdy_version_ > 3 && current_frame_flags_ &
+                   ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY)) {
+          set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
+        }
       }
       break;
     case WINDOW_UPDATE:
       if (current_frame_length_ != GetWindowUpdateSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CREDENTIAL:
@@ skipping 57 matching lines @@
       break;
     case SYN_REPLY:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynReplyMinimumSize();
       break;
     case SETTINGS:
       frame_size_without_variable_data = GetSettingsMinimumSize();
       break;
     case HEADERS:
       frame_size_without_variable_data = GetHeadersMinimumSize();
+      if (spdy_version_ > 3 && current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
+        frame_size_without_variable_data += 4;  // priority
+      }
       break;
     case PUSH_PROMISE:
       frame_size_without_variable_data = GetPushPromiseMinimumSize();
       break;
     default:
       frame_size_without_variable_data = -1;
       break;
   }
 
   if ((frame_size_without_variable_data == -1) &&
@@ skipping 242 matching lines @@
   z->avail_in = 0;
   int rv = deflate(z, Z_SYNC_FLUSH);
   DCHECK_EQ(Z_OK, rv);
   z->clas = kZStandardData;
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 size_t SpdyFramer::ProcessControlFrameBeforeHeaderBlock(const char* data,
                                                         size_t len) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK, state_);
-  size_t original_len = len;
+  const size_t original_len = len;
 
   if (remaining_control_header_ > 0) {
     size_t bytes_read = UpdateCurrentFrameBuffer(&data, &len,
                                                  remaining_control_header_);
     remaining_control_header_ -= bytes_read;
     remaining_data_length_ -= bytes_read;
   }
 
   if (remaining_control_header_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.get(),
                            current_frame_buffer_length_);
     reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
 
     switch (current_frame_type_) {
       case SYN_STREAM:
         {
+          DCHECK_GT(4, spdy_version_);
           bool successful_read = true;
           if (spdy_version_ < 4) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
 
@@ skipping 38 matching lines @@
         break;
       case SETTINGS:
         visitor_->OnSettings(current_frame_flags_ &
                              SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS);
         CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
         break;
       case SYN_REPLY:
       case HEADERS:
         // SYN_REPLY and HEADERS are the same, save for the visitor call.
         {
+          if (spdy_version_ > 3) {
+            DCHECK_EQ(HEADERS, current_frame_type_);
+          }
           bool successful_read = true;
           if (spdy_version_ < 4) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           if (protocol_version() < 3) {
             // SPDY 2 had two unused bytes here. Seek past them.
             reader.Seek(2);
           }
+          const bool has_priority =
+              (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
+          uint32 priority = 0;
+          if (protocol_version() > 3 && has_priority) {
+            successful_read = reader.ReadUInt31(&priority);
+            DCHECK(successful_read);
+          }
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
+            // SPDY 4 reports HEADERS with PRIORITY as SYN_STREAM.
+            SpdyFrameType reported_type = current_frame_type_;
+            if (protocol_version() > 3 && has_priority) {
+              reported_type = SYN_STREAM;
+            }
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
-                current_frame_type_,
+                reported_type,
                 current_frame_length_);
           }
           if (current_frame_type_ == SYN_REPLY) {
             visitor_->OnSynReply(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
+          } else if (spdy_version_ > 3 &&
+              current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
+            // SPDY 4+ is missing SYN_STREAM. Simulate it so that API changes
+            // can be made independent of wire changes.
+            visitor_->OnSynStream(
+                current_frame_stream_id_,
+                0,  // associated_to_stream_id
+                priority,
+                0,  // TODO(hkhalil): handle slot for SPDY 4+?
+                current_frame_flags_ & CONTROL_FLAG_FIN,
+                false);  // unidirectional
           } else {
             visitor_->OnHeaders(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
           }
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case PUSH_PROMISE:
         {
@@ skipping 467 matching lines @@
   return SerializeSynStream(syn_stream);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (syn_stream.unidirectional()) {
+    // TODO(hkhalil): invalid for HTTP2.
     flags |= CONTROL_FLAG_UNIDIRECTIONAL;
   }
+  if (spdy_version_ >= 4) {
+    flags |= HEADERS_FLAG_PRIORITY;
+  }
+
+  // Sanitize priority.
+  uint8 priority = syn_stream.priority();
+  if (priority > GetLowestPriority()) {
+    DLOG(DFATAL) << "Priority out-of-bounds.";
+    priority = GetLowestPriority();
+  }
 
   // The size of this frame, including variable-length name-value block.
   const size_t size = GetSynStreamMinimumSize()
       + GetSerializedLength(syn_stream.name_value_block());
 
   SpdyFrameBuilder builder(size);
   if (spdy_version_ < 4) {
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
     builder.WriteUInt32(syn_stream.stream_id());
+    builder.WriteUInt32(syn_stream.associated_to_stream_id());
+    builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
+    builder.WriteUInt8(syn_stream.slot());
   } else {
     builder.WriteFramePrefix(*this,
-                             SYN_STREAM,
+                             HEADERS,
                              flags,
                              syn_stream.stream_id());
+    builder.WriteUInt32(priority);
   }
-  builder.WriteUInt32(syn_stream.associated_to_stream_id());
-  uint8 priority = syn_stream.priority();
-  if (priority > GetLowestPriority()) {
-    DLOG(DFATAL) << "Priority out-of-bounds.";
-    priority = GetLowestPriority();
-  }
-  builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
-  builder.WriteUInt8(syn_stream.slot());
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_stream);
 
   if (debug_visitor_) {
     const size_t payload_len = GetSerializedLength(
         protocol_version(), &(syn_stream.name_value_block()));
+    // SPDY 4 reports this compression as a SYN_STREAM compression.
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateSynReply(
@@ skipping 20 matching lines @@
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynReplyMinimumSize()
       + GetSerializedLength(syn_reply.name_value_block());
 
   SpdyFrameBuilder builder(size);
   if (spdy_version_ < 4) {
     builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
     builder.WriteUInt32(syn_reply.stream_id());
   } else {
     builder.WriteFramePrefix(*this,
-                             SYN_REPLY,
+                             HEADERS,
                              flags,
                              syn_reply.stream_id());
   }
   if (protocol_version() < 3) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_reply);
 
   if (debug_visitor_) {
@@ skipping 601 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net