[SPDY] Incorporate latest framing changes from HTTP2 into SPDY 4 as SPDY 4a2.

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 149 matching lines @@
   return 8;
 }
 
 // Size, in bytes, of the control frame header.
 size_t SpdyFramer::GetControlFrameHeaderSize() const {
   switch (protocol_version()) {
     case 2:
     case 3:
       return 8;
     case 4:
-      return 4;
+      return 8;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
-  // name-value block. Calculated as:
-  // control frame header + 2 * 4 (stream IDs) + 1 (priority) + 1 (slot)
-  return GetControlFrameHeaderSize() + 10;
+  // 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;
+  }
 }
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
-  // name-value block. Calculated as:
-  // control frame header + 4 (stream ID)
-  size_t size = GetControlFrameHeaderSize() + 4;
+  // name-value block.
+  size_t size = GetControlFrameHeaderSize();
+  if (spdy_version_ < 4) {
+    // Calculated as:
+    // control frame header + 4 (stream IDs)
+    size += 4;
+  }
 
   // In SPDY 2, there were 2 unused bytes before payload.
   if (protocol_version() < 3) {
     size += 2;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetRstStreamSize() const {
-  // Size, in bytes, of a RST_STREAM frame. Calculated as:
-  // control frame header + 4 (stream id) + 4 (status code)
-  return GetControlFrameHeaderSize() + 8;
+  // Size, in bytes, of a RST_STREAM frame.
+  if (spdy_version_ < 4) {
+    // Calculated as:
+    // control frame header + 4 (stream id) + 4 (status code)
+    return GetControlFrameHeaderSize() + 8;
+  } else {
+    // Calculated as:
+    // frame prefix + 4 (status code)
+    return GetControlFrameHeaderSize() + 4;
+  }
 }
 
 size_t SpdyFramer::GetSettingsMinimumSize() const {
   // Size, in bytes, of a SETTINGS frame not including the IDs and values
   // from the variable-length value block. Calculated as:
   // control frame header + 4 (number of ID/value pairs)
   return GetControlFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetPingSize() const {
   // Size, in bytes, of this PING frame. Calculated as:
   // control frame header + 4 (id)
   return GetControlFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetGoAwaySize() const {
   // Size, in bytes, of this GOAWAY frame. Calculated as:
   // control frame header + 4 (last good stream id)
   size_t size = GetControlFrameHeaderSize() + 4;
 
   // SPDY 3+ GOAWAY frames also contain a status.
   if (protocol_version() >= 3) {
     size += 4;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetHeadersMinimumSize() const  {
-  // Size, in bytes, of a HEADERS frame not including the variable-length
-  // name-value block. Calculated as:
-  // control frame header + 4 (stream ID)
-  size_t size = GetControlFrameHeaderSize() + 4;
+  // 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)
+    size += 4;
+  }
 
   // In SPDY 2, there were 2 unused bytes before payload.
   if (protocol_version() < 3) {
     size += 2;
   }
 
   return size;
 }
 
 size_t SpdyFramer::GetWindowUpdateSize() const {
-  // Size, in bytes, of this WINDOW_UPDATE frame. Calculated as:
-  // control frame header + 4 (stream id) + 4 (delta)
-  return GetControlFrameHeaderSize() + 8;
+  // Size, in bytes, of a WINDOW_UPDATE frame.
+  if (spdy_version_ < 4) {
+    // Calculated as:
+    // control frame header + 4 (stream id) + 4 (delta)
+    return GetControlFrameHeaderSize() + 8;
+  } else {
+    // Calculated as:
+    // frame prefix + 4 (delta)
+    return GetControlFrameHeaderSize() + 4;
+  }
 }
 
 size_t SpdyFramer::GetCredentialMinimumSize() const {
   // Size, in bytes, of a CREDENTIAL frame sans variable-length certificate list
   // and proof. Calculated as:
   // control frame header + 2 (slot)
   return GetControlFrameHeaderSize() + 2;
 }
 
 size_t SpdyFramer::GetFrameMinimumSize() const {
@@ skipping 278 matching lines @@
 
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     uint32 length_field = 0;
     successful_read = reader->ReadUInt24(&length_field);
     DCHECK(successful_read);
     remaining_data_length_ = length_field;
     current_frame_length_ = remaining_data_length_ + reader->GetBytesConsumed();
   } else {
-    // TODO(hkhalil): Avoid re-reading fields as possible for DATA frames?
     version = protocol_version();
     uint16 length_field = 0;
     bool successful_read = reader->ReadUInt16(&length_field);
     DCHECK(successful_read);
     current_frame_length_ = length_field;
 
     uint8 control_frame_type_field_uint8 = DATA;
     successful_read = reader->ReadUInt8(&control_frame_type_field_uint8);
     DCHECK(successful_read);
     // We check control_frame_type_field's validity in
     // ProcessControlFrameHeader().
     control_frame_type_field = control_frame_type_field_uint8;
     is_control_frame = (control_frame_type_field != DATA);
 
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
-    if (!is_control_frame) {
-      // We may not have the entirety of the DATA frame header.
-      if (current_frame_buffer_length_ < GetDataFrameMinimumSize()) {
-        size_t bytes_desired =
-            GetDataFrameMinimumSize() - current_frame_buffer_length_;
-        UpdateCurrentFrameBuffer(&data, &len, bytes_desired);
-        if (current_frame_buffer_length_ < GetDataFrameMinimumSize()) {
-          return original_len - len;
-        }
-      }
-      // Construct a new SpdyFrameReader aware of the new frame length.
-      reader.reset(new SpdyFrameReader(current_frame_buffer_.get(),
-                                       current_frame_buffer_length_));
-      reader->Seek(GetControlFrameHeaderSize());
-      successful_read = reader->ReadUInt31(&current_frame_stream_id_);
-      DCHECK(successful_read);
-    }
+    successful_read = reader->ReadUInt31(&current_frame_stream_id_);
+    DCHECK(successful_read);
+
     remaining_data_length_ = current_frame_length_ - reader->GetBytesConsumed();
   }
   DCHECK_EQ(is_control_frame ? GetControlFrameHeaderSize()
                              : GetDataFrameMinimumSize(),
             reader->GetBytesConsumed());
   DCHECK_EQ(current_frame_length_,
             remaining_data_length_ + reader->GetBytesConsumed());
 
   // This is just a sanity check for help debugging early frame errors.
   if (remaining_data_length_ > 1000000u) {
@@ skipping 445 matching lines @@
   }
 
   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:
         {
-          bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-          DCHECK(successful_read);
+          bool successful_read = true;
+          if (spdy_version_ < 4) {
+            successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+            DCHECK(successful_read);
+          }
 
           SpdyStreamId associated_to_stream_id = kInvalidStream;
           successful_read = reader.ReadUInt31(&associated_to_stream_id);
           DCHECK(successful_read);
 
           SpdyPriority priority = 0;
           successful_read = reader.ReadUInt8(&priority);
           DCHECK(successful_read);
           if (protocol_version() < 3) {
             priority = priority >> 6;
@@ skipping 18 matching lines @@
               slot,
               (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
               (current_frame_flags_ & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case SYN_REPLY:
       case HEADERS:
         // SYN_REPLY and HEADERS are the same, save for the visitor call.
         {
-          bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-          DCHECK(successful_read);
+          bool successful_read = true;
+          if (spdy_version_ < 4) {
+            successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+            DCHECK(successful_read);
+          }
           if (protocol_version() < 3) {
             // SPDY 2 had two unused bytes here. Seek past them.
             reader.Seek(2);
           }
           DCHECK(reader.IsDoneReading());
           if (current_frame_type_ == SYN_REPLY) {
             visitor_->OnSynReply(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
           } else {
@@ skipping 184 matching lines @@
         case PING: {
             SpdyPingId id = 0;
             bool successful_read = reader.ReadUInt32(&id);
             DCHECK(successful_read);
             DCHECK(reader.IsDoneReading());
             visitor_->OnPing(id);
           }
           break;
         case WINDOW_UPDATE: {
             uint32 delta_window_size = 0;
-            bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-            DCHECK(successful_read);
-            successful_read = reader.ReadUInt31(&delta_window_size);
+            bool successful_read = true;
+            if (spdy_version_ < 4) {
+              successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+              DCHECK(successful_read);
+            }
+            successful_read = reader.ReadUInt32(&delta_window_size);
             DCHECK(successful_read);
             DCHECK(reader.IsDoneReading());
             visitor_->OnWindowUpdate(current_frame_stream_id_,
                                      delta_window_size);
           }
           break;
         case RST_STREAM: {
-            bool successful_read = reader.ReadUInt32(&current_frame_stream_id_);
-            DCHECK(successful_read);
+            bool successful_read = true;
+            if (spdy_version_ < 4) {
+              successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+              DCHECK(successful_read);
+            }
             SpdyRstStreamStatus status = RST_STREAM_INVALID;
             uint32 status_raw = status;
             successful_read = reader.ReadUInt32(&status_raw);
             DCHECK(successful_read);
             if (status_raw > RST_STREAM_INVALID &&
                 status_raw < RST_STREAM_NUM_STATUS_CODES) {
               status = static_cast<SpdyRstStreamStatus>(status_raw);
             } else {
               // TODO(hkhalil): Probably best to OnError here, depending on
               // our interpretation of the spec. Keeping with existing liberal
@@ skipping 191 matching lines @@
   }
   if (syn_stream.unidirectional()) {
     flags |= CONTROL_FLAG_UNIDIRECTIONAL;
   }
 
   // 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);
-  builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
-  builder.WriteUInt32(syn_stream.stream_id());
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
+    builder.WriteUInt32(syn_stream.stream_id());
+  } else {
+    builder.WriteFramePrefix(*this,
+                             SYN_STREAM,
+                             flags,
+                             syn_stream.stream_id());
+  }
   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);
@@ skipping 26 matching lines @@
   uint8 flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynReplyMinimumSize()
       + GetSerializedLength(syn_reply.name_value_block());
 
   SpdyFrameBuilder builder(size);
-  builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
-  builder.WriteUInt32(syn_reply.stream_id());
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
+    builder.WriteUInt32(syn_reply.stream_id());
+  } else {
+    builder.WriteFramePrefix(*this,
+                             SYN_REPLY,
+                             flags,
+                             syn_reply.stream_id());
+  }
   if (protocol_version() < 3) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_reply);
 
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateRstStream(
     SpdyStreamId stream_id,
     SpdyRstStreamStatus status) const {
   SpdyRstStreamIR rst_stream(stream_id, status);
   return SerializeRstStream(rst_stream);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
   SpdyFrameBuilder builder(GetRstStreamSize());
-  builder.WriteControlFrameHeader(*this, RST_STREAM, 0);
-  builder.WriteUInt32(rst_stream.stream_id());
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, RST_STREAM, 0);
+    builder.WriteUInt32(rst_stream.stream_id());
+  } else {
+    builder.WriteFramePrefix(*this,
+                             RST_STREAM,
+                             0,
+                             rst_stream.stream_id());
+  }
   builder.WriteUInt32(rst_stream.status());
   DCHECK_EQ(GetRstStreamSize(), builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateSettings(
     const SettingsMap& values) const {
   SpdySettingsIR settings;
   for (SettingsMap::const_iterator it = values.begin();
        it != values.end();
@@ skipping 11 matching lines @@
   uint8 flags = 0;
   if (settings.clear_settings()) {
     flags |= SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
   }
   const SpdySettingsIR::ValueMap* values = &(settings.values());
 
   // Size, in bytes, of this SETTINGS frame.
   const size_t size = GetSettingsMinimumSize() + (values->size() * 8);
 
   SpdyFrameBuilder builder(size);
-  builder.WriteControlFrameHeader(*this, SETTINGS, flags);
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, SETTINGS, flags);
+  } else {
+    builder.WriteFramePrefix(*this, SETTINGS, flags, 0);
+  }
   builder.WriteUInt32(values->size());
   DCHECK_EQ(GetSettingsMinimumSize(), builder.length());
   for (SpdySettingsIR::ValueMap::const_iterator it = values->begin();
        it != values->end();
        ++it) {
     uint8 setting_flags = 0;
     if (it->second.persist_value) {
       setting_flags |= SETTINGS_FLAG_PLEASE_PERSIST;
     }
     if (it->second.persisted) {
       setting_flags |= SETTINGS_FLAG_PERSISTED;
     }
     SettingsFlagsAndId flags_and_id(setting_flags, it->first);
     uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
     builder.WriteBytes(&id_and_flags_wire, 4);
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreatePingFrame(uint32 unique_id) const {
   SpdyPingIR ping(unique_id);
   return SerializePing(ping);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
   SpdyFrameBuilder builder(GetPingSize());
-  builder.WriteControlFrameHeader(*this, PING, 0);
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, PING, kNoFlags);
+  } else {
+    builder.WriteFramePrefix(*this, PING, 0, 0);
+  }
   builder.WriteUInt32(ping.id());
   DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
     SpdyGoAwayStatus status) const {
   SpdyGoAwayIR goaway(last_accepted_stream_id, status);
   return SerializeGoAway(goaway);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeGoAway(
     const SpdyGoAwayIR& goaway) const {
   SpdyFrameBuilder builder(GetGoAwaySize());
-  builder.WriteControlFrameHeader(*this, GOAWAY, 0);
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, GOAWAY, kNoFlags);
+  } else {
+    builder.WriteFramePrefix(*this, GOAWAY, 0, 0);
+  }
   builder.WriteUInt32(goaway.last_good_stream_id());
   if (protocol_version() >= 3) {
     builder.WriteUInt32(goaway.status());
   }
   DCHECK_EQ(GetGoAwaySize(), builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
@@ skipping 18 matching lines @@
   uint8 flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetHeadersMinimumSize()
       + GetSerializedLength(headers.name_value_block());
 
   SpdyFrameBuilder builder(size);
-  builder.WriteControlFrameHeader(*this, HEADERS, flags);
-  builder.WriteUInt32(headers.stream_id());
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, HEADERS, flags);
+    builder.WriteUInt32(headers.stream_id());
+  } else {
+    builder.WriteFramePrefix(*this,
+                             HEADERS,
+                             flags,
+                             headers.stream_id());
+  }
   if (protocol_version() < 3) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   SerializeNameValueBlock(&builder, headers);
 
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::CreateWindowUpdate(
     SpdyStreamId stream_id,
     uint32 delta_window_size) const {
   SpdyWindowUpdateIR window_update(stream_id, delta_window_size);
   return SerializeWindowUpdate(window_update);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeWindowUpdate(
     const SpdyWindowUpdateIR& window_update) const {
   SpdyFrameBuilder builder(GetWindowUpdateSize());
-  builder.WriteControlFrameHeader(*this, WINDOW_UPDATE, kNoFlags);
-  builder.WriteUInt32(window_update.stream_id());
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, WINDOW_UPDATE, kNoFlags);
+    builder.WriteUInt32(window_update.stream_id());
+  } else {
+    builder.WriteFramePrefix(*this,
+                             WINDOW_UPDATE,
+                             kNoFlags,
+                             window_update.stream_id());
+  }
   builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 // TODO(hkhalil): Gut with SpdyCredential removal.
 SpdyFrame* SpdyFramer::CreateCredentialFrame(
     const SpdyCredential& credential) const {
   SpdyCredentialIR credential_ir(credential.slot);
   credential_ir.set_proof(credential.proof);
@@ skipping 10 matching lines @@
   size_t size = GetCredentialMinimumSize();
   size += 4 + credential.proof().length();  // Room for proof.
   for (SpdyCredentialIR::CertificateList::const_iterator it =
        credential.certificates()->begin();
        it != credential.certificates()->end();
        ++it) {
     size += 4 + it->length();  // Room for certificate.
   }
 
   SpdyFrameBuilder builder(size);
-  builder.WriteControlFrameHeader(*this, CREDENTIAL, 0);
+  if (spdy_version_ < 4) {
+    builder.WriteControlFrameHeader(*this, CREDENTIAL, kNoFlags);
+  } else {
+    builder.WriteFramePrefix(*this, CREDENTIAL, kNoFlags, 0);
+  }
   builder.WriteUInt16(credential.slot());
   DCHECK_EQ(GetCredentialMinimumSize(), builder.length());
   builder.WriteStringPiece32(credential.proof());
   for (SpdyCredentialIR::CertificateList::const_iterator it =
        credential.certificates()->begin();
        it != credential.certificates()->end();
        ++it) {
     builder.WriteStringPiece32(*it);
   }
   DCHECK_EQ(size, builder.length());
@@ skipping 299 matching lines @@
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 
   if (debug_visitor_ != NULL) {
     debug_visitor_->OnCompressedHeaderBlock(uncompressed_len, compressed_size);
   }
 }
 
 }  // namespace net