SpdyFramer hooks for parsing and handling PRIORITY frames.

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 1771 matching lines @@
         }
         break;
       case BLOCKED: {
           DCHECK_LT(SPDY3, protocol_version());
           DCHECK(reader.IsDoneReading());
           visitor_->OnBlocked(current_frame_stream_id_);
         }
         break;
       case PRIORITY: {
           DCHECK_LT(SPDY3, protocol_version());
-          // TODO(hkhalil): Process PRIORITY frames rather than ignore them.
-          reader.Seek(5);
+          uint32 parent_stream_id;
+          uint8 weight;
+          bool exclusive;
+          bool successful_read = true;
+          successful_read = reader.ReadUInt32(&parent_stream_id);
+          DCHECK(successful_read);
+          // Exclusivity is indicated by a single bit flag.
+          exclusive = (parent_stream_id >> 31) != 0;
+          // Zero out the highest-order bit to get the parent stream id.
+          parent_stream_id &= 0x7fffffff;
+          successful_read = reader.ReadUInt8(&weight);
+          DCHECK(successful_read);
           DCHECK(reader.IsDoneReading());
+          visitor_->OnPriority(
+              current_frame_stream_id_, parent_stream_id, weight, exclusive);
         }
         break;
       default:
         // Unreachable.
         LOG(FATAL) << "Unhandled control frame " << current_frame_type_;
     }
 
     CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
   }
   return original_len - len;
@@ skipping 1007 matching lines @@
   builder.WriteUInt8(altsvc.protocol_id().length());
   builder.WriteBytes(altsvc.protocol_id().data(),
                      altsvc.protocol_id().length());
   builder.WriteUInt8(altsvc.host().length());
   builder.WriteBytes(altsvc.host().data(), altsvc.host().length());
   builder.WriteBytes(altsvc.origin().data(), altsvc.origin().length());
   DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
   return builder.take();
 }
 
+SpdyFrame* SpdyFramer::SerializePriority(const SpdyPriorityIR& priority) {
+  DCHECK_LT(SPDY3, protocol_version());
+  size_t size = GetPrioritySize();
+
+  SpdyFrameBuilder builder(size, protocol_version());
+  builder.BeginNewFrame(*this, PRIORITY, kNoFlags, priority.stream_id());
+
+  // Make sure the highest-order bit in the parent stream id is zeroed out.
+  uint32 parent_stream_id = priority.parent_stream_id() & 0x7fffffff;
+  uint32 exclusive = priority.exclusive() ? 0x80000000 : 0;
+  // Set the one-bit exclusivity flag.
+  uint32 flag_and_parent_id = parent_stream_id | exclusive;
+  builder.WriteUInt32(flag_and_parent_id);
+  builder.WriteUInt8(priority.weight());
+  DCHECK_EQ(GetPrioritySize(), builder.length());
+  return builder.take();
+}
+
 namespace {
 
 class FrameSerializationVisitor : public SpdyFrameVisitor {
  public:
   explicit FrameSerializationVisitor(SpdyFramer* framer) : framer_(framer) {}
   virtual ~FrameSerializationVisitor() {}
 
   SpdySerializedFrame* ReleaseSerializedFrame() { return frame_.release(); }
 
   virtual void VisitData(const SpdyDataIR& data) OVERRIDE {
@@ skipping 31 matching lines @@
       const SpdyPushPromiseIR& push_promise) OVERRIDE {
     frame_.reset(framer_->SerializePushPromise(push_promise));
   }
   virtual void VisitContinuation(
       const SpdyContinuationIR& continuation) OVERRIDE {
     frame_.reset(framer_->SerializeContinuation(continuation));
   }
   virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) OVERRIDE {
     frame_.reset(framer_->SerializeAltSvc(altsvc));
   }
+  virtual void VisitPriority(const SpdyPriorityIR& priority) OVERRIDE {
+    frame_.reset(framer_->SerializePriority(priority));
+  }
 
  private:
   SpdyFramer* framer_;
   scoped_ptr<SpdySerializedFrame> frame_;
 };
 
 }  // namespace
 
 SpdySerializedFrame* SpdyFramer::SerializeFrame(const SpdyFrameIR& frame) {
   FrameSerializationVisitor visitor(this);
@@ skipping 342 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