Initial support for HTTP/2 dependencies and weights

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.
 
 #include "net/spdy/spdy_framer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 166 matching lines @@
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
   // name-value block.
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 2 * 4 (stream IDs) + 1 (priority)
     // + 1 (unused, was credential slot)
     return GetControlFrameHeaderSize() + 10;
   } else {
     // Calculated as:
-    // frame prefix + 4 (priority)
-    return GetControlFrameHeaderSize() + 4;
+    // frame prefix + 5 (priority)
+    return GetControlFrameHeaderSize() + 5;

[Ryan Hamilton, 2014/05/19 22:56:41]

I'm not terribly in love with the magic number here. Any chance you can extract
this to a constant? Perhaps that's not super important, though I do think it'd
be a bit more readable.

Perhaps it should be 2 constants, actually... one for weight size, and one for
dependency size?

[Johnny, 2014/05/19 23:27:17]

Done. Though, now this particularly calls attention to all of the /other/ places
that should do this in spdy_framer.cc :)

   }
 }
 
 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 (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream IDs)
@@ skipping 841 matching lines @@
       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 (protocol_version() > SPDY3 &&
           current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
-        frame_size_without_variable_data += 4;  // priority
+        frame_size_without_variable_data += 5;  // priority
       }
       break;
     case PUSH_PROMISE:
       frame_size_without_variable_data = GetPushPromiseMinimumSize();
       break;
     case CONTINUATION:
       frame_size_without_variable_data = GetContinuationMinimumSize();
       break;
     default:
       frame_size_without_variable_data = -1;
@@ skipping 346 matching lines @@
           if (protocol_version() > SPDY3 &&
              !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
              current_frame_type_ == HEADERS) {
             expect_continuation_ = current_frame_stream_id_;
             end_stream_when_done_ = current_frame_flags_ & CONTROL_FLAG_FIN;
           }
           const bool has_priority =
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
           uint32 priority = 0;
           if (protocol_version() > SPDY3 && has_priority) {
-            successful_read = reader.ReadUInt31(&priority);
-            DCHECK(successful_read);
+            // TODO(jgraettinger): Process dependency rather than ignoring it.
+            reader.Seek(4);
+            uint8 weight = 0;
+            successful_read = reader.ReadUInt8(&weight);
+            if (successful_read) {
+              priority = MapWeightToPriority(weight);
+            }
           }
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             // SPDY 4 reports HEADERS with PRIORITY as SYN_STREAM.
             SpdyFrameType reported_type = current_frame_type_;
             if (protocol_version() > SPDY3 && has_priority) {
               reported_type = SYN_STREAM;
             }
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
@@ skipping 940 matching lines @@
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
     builder.WriteUInt32(syn_stream.stream_id());
     builder.WriteUInt32(syn_stream.associated_to_stream_id());
     builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
     builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
   } else {
     builder.BeginNewFrame(*this,
                           HEADERS,
                           flags,
                           syn_stream.stream_id());
-    builder.WriteUInt32(priority);
+    // TODO(jgraettinger): Plumb priorities and stream dependencies.
+    builder.WriteUInt32(0);  // Non-exclusive bit and root stream ID.
+    builder.WriteUInt8(MapPriorityToWeight(priority));
   }
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_stream);
   }
 
   if (debug_visitor_) {
     const size_t payload_len = protocol_version() > SPDY3 ?
@@ skipping 267 matching lines @@
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, HEADERS, flags);
     builder.WriteUInt32(headers.stream_id());
   } else {
     builder.BeginNewFrame(*this,
                           HEADERS,
                           flags,
                           headers.stream_id());
     if (headers.has_priority()) {
-      builder.WriteUInt32(priority);
+      // TODO(jgraettinger): Plumb priorities and stream dependencies.
+      builder.WriteUInt32(0);  // Non-exclusive bit and root stream ID.
+      builder.WriteUInt8(MapPriorityToWeight(priority));
     }
   }
   if (protocol_version() <= SPDY2) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   if (protocol_version() > SPDY3) {
     WritePayloadWithContinuation(&builder,
                                  hpack_encoding,
@@ skipping 370 matching lines @@
 }
 
 HpackDecoder* SpdyFramer::GetHpackDecoder() {
   DCHECK_LT(SPDY3, spdy_version_);
   if (hpack_decoder_.get() == NULL) {
     hpack_decoder_.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
   }
   return hpack_decoder_.get();
 }
 
+uint8 SpdyFramer::MapPriorityToWeight(SpdyPriority priority) {
+  const float kSteps = 255.9f / 7.f;
+  return static_cast<uint8>(kSteps * (7.f - priority));
+}
+
+SpdyPriority SpdyFramer::MapWeightToPriority(uint8 weight) {
+  const float kSteps = 255.9f / 7.f;
+  return static_cast<SpdyPriority>(7.f - weight / kSteps);
+}
+
 // Incrementally decompress the control frame's header block, feeding the
 // result to the visitor in chunks. Continue this until the visitor
 // indicates that it cannot process any more data, or (more commonly) we
 // run out of data to deliver.
 bool SpdyFramer::IncrementallyDecompressControlFrameHeaderData(
     SpdyStreamId stream_id,
     const char* data,
     size_t len) {
   // Get a decompressor or set error.
   z_stream* decomp = GetHeaderDecompressor();
@@ skipping 166 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