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 29 matching lines @@
   const uLong v3_dictionary_id;
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Used to indicate no flags in a SPDY flags field.
 const uint8 kNoFlags = 0;
 
+// Wire sizes of priority payloads.
+const size_t kPriorityDependencyPayloadSize = 4;
+const size_t kPriorityWeightPayloadSize = 1;
+
 }  // namespace
 
 const SpdyStreamId SpdyFramer::kInvalidStream = -1;
 const size_t SpdyFramer::kHeaderDataChunkMaxSize = 1024;
 // largest control frame, which is SYN_STREAM. See GetSynStreamMinimumSize() for
 // calculation details.
 const size_t SpdyFramer::kControlFrameBufferSize = 18;
 
 #ifdef DEBUG_SPDY_STATE_CHANGES
 #define CHANGE_STATE(newstate)                                  \
@@ skipping 116 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;
+    return GetControlFrameHeaderSize() +
+        kPriorityDependencyPayloadSize +
+        kPriorityWeightPayloadSize;
   }
 }
 
 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 117 matching lines @@
   // (optional) Origin fields, all of which can vary in length.
   // Note that this gives a lower bound on the frame size rather than a true
   // minimum; the actual frame should always be larger than this.
   // Calculated as frame prefix + 4 (max-age) + 2 (port) + 1 (reserved byte)
   // + 1 (pid_len) + 1 (host_len).
   return GetControlFrameHeaderSize() + 9;
 }
 
 size_t SpdyFramer::GetPrioritySize() const {
   // Size, in bytes, of a PRIORITY frame.
-  // Calculated as frame prefix + 4 (stream dependency) + 1 (weight)
-  return GetControlFrameHeaderSize() + 5;
+  return GetControlFrameHeaderSize() +
+      kPriorityDependencyPayloadSize +
+      kPriorityWeightPayloadSize;
 }
 
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return std::min(GetDataFrameMinimumSize(), GetControlFrameHeaderSize());
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
   return SpdyConstants::GetFrameMaximumSize(protocol_version());
 }
 
@@ skipping 702 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 +=
+            kPriorityDependencyPayloadSize +
+            kPriorityWeightPayloadSize;
       }
       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(kPriorityDependencyPayloadSize);
+            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