SpdyFramer hooks for parsing and handling PRIORITY frames.

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 173 matching lines @@
       scoped_ptr<SpdyFrame> frame(framer.SerializePushPromise(push_promise));
       ResetBuffer();
       memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
     virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
       LOG(FATAL);
     }
 
+    virtual void OnPriority(SpdyStreamId stream_id,
+                            SpdyStreamId parent_stream_id,
+                            uint8 weight,
+                            bool exclusive) OVERRIDE {
+      // Do nothing.
+    }
+
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id,
                                 uint32 delta_window_size) OVERRIDE {
       LOG(FATAL);
     }
 
@@ skipping 16 matching lines @@
 };
 
 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
                         public SpdyFramerDebugVisitorInterface {
  public:
   // This is larger than our max frame size because header blocks that
   // are too long can spill over into CONTINUATION frames.
   static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
 
   explicit TestSpdyVisitor(SpdyMajorVersion version)
-    : framer_(version),
-      use_compression_(false),
-      error_count_(0),
-      syn_frame_count_(0),
-      syn_reply_frame_count_(0),
-      headers_frame_count_(0),
-      push_promise_frame_count_(0),
-      goaway_count_(0),
-      setting_count_(0),
-      settings_ack_sent_(0),
-      settings_ack_received_(0),
-      continuation_count_(0),
-      altsvc_count_(0),
-      test_altsvc_ir_(0),
-      last_window_update_stream_(0),
-      last_window_update_delta_(0),
-      last_push_promise_stream_(0),
-      last_push_promise_promised_stream_(0),
-      data_bytes_(0),
-      fin_frame_count_(0),
-      fin_opaque_data_(),
-      fin_flag_count_(0),
-      zero_length_data_frame_count_(0),
-      control_frame_header_data_count_(0),
-      zero_length_control_frame_header_data_count_(0),
-      data_frame_count_(0),
-      last_payload_len_(0),
-      last_frame_len_(0),
-      header_buffer_(new char[kDefaultHeaderBufferSize]),
-      header_buffer_length_(0),
-      header_buffer_size_(kDefaultHeaderBufferSize),
-      header_stream_id_(-1),
-      header_control_type_(DATA),
-      header_buffer_valid_(false) {
-  }
+      : framer_(version),
+        use_compression_(false),
+        error_count_(0),
+        syn_frame_count_(0),
+        syn_reply_frame_count_(0),
+        headers_frame_count_(0),
+        push_promise_frame_count_(0),
+        goaway_count_(0),
+        setting_count_(0),
+        settings_ack_sent_(0),
+        settings_ack_received_(0),
+        continuation_count_(0),
+        altsvc_count_(0),
+        priority_count_(0),
+        test_altsvc_ir_(0),
+        last_window_update_stream_(0),
+        last_window_update_delta_(0),
+        last_push_promise_stream_(0),
+        last_push_promise_promised_stream_(0),
+        data_bytes_(0),
+        fin_frame_count_(0),
+        fin_opaque_data_(),
+        fin_flag_count_(0),
+        zero_length_data_frame_count_(0),
+        control_frame_header_data_count_(0),
+        zero_length_control_frame_header_data_count_(0),
+        data_frame_count_(0),
+        last_payload_len_(0),
+        last_frame_len_(0),
+        header_buffer_(new char[kDefaultHeaderBufferSize]),
+        header_buffer_length_(0),
+        header_buffer_size_(kDefaultHeaderBufferSize),
+        header_stream_id_(-1),
+        header_control_type_(DATA),
+        header_buffer_valid_(false) {}
 
   virtual void OnError(SpdyFramer* f) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
     ++error_count_;
   }
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
                                  bool fin) OVERRIDE {
@@ skipping 157 matching lines @@
   }
 
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
                                      size_t frame_len) OVERRIDE {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
+  virtual void OnPriority(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive) OVERRIDE {
+    ++priority_count_;
+  }
+
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
                                         size_t frame_len) OVERRIDE {
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
@@ skipping 48 matching lines @@
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
   int push_promise_frame_count_;
   int goaway_count_;
   int setting_count_;
   int settings_ack_sent_;
   int settings_ack_received_;
   int continuation_count_;
   int altsvc_count_;
+  int priority_count_;
   SpdyAltSvcIR test_altsvc_ir_;
   SpdyStreamId last_window_update_stream_;
   uint32 last_window_update_delta_;
   SpdyStreamId last_push_promise_stream_;
   SpdyStreamId last_push_promise_promised_stream_;
   int data_bytes_;
   int fin_frame_count_;  // The count of RST_STREAM type frames received.
   std::string fin_opaque_data_;
   int fin_flag_count_;  // The count of frames with the FIN flag set.
   int zero_length_data_frame_count_;  // The count of zero-length data frames.
@@ skipping 2496 matching lines @@
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_max_age(5);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("pid1");
   altsvc_ir.set_host("host");
   altsvc_ir.set_origin("origin");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
+TEST_P(SpdyFramerTest, CreatePriority) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+
+  SpdyFramer framer(spdy_version_);
+
+  const char kDescription[] = "PRIORITY frame";
+  const char kType = static_cast<unsigned char>(
+      SpdyConstants::SerializeFrameType(spdy_version_, PRIORITY));
+  const unsigned char kFrameData[] = {
+      0x00, 0x05, kType, 0x00,
+      0x00, 0x00, 0x00, 0x02,  // Stream ID = 2
+      0x80, 0x00, 0x00,  0x01,  // Exclusive dependency, parent stream ID = 1
+      0x10,                     // Weight = 16
+  };
+  SpdyPriorityIR priority_ir(2, 1, 16, true);
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(priority_ir));
+  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+}
+
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
   SpdyHeaderBlock headers = syn_stream.name_value_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 2339 matching lines @@
   EXPECT_EQ(443u, visitor.test_altsvc_ir_.port());
   EXPECT_EQ("protocolid", visitor.test_altsvc_ir_.protocol_id());
   EXPECT_EQ("hostname", visitor.test_altsvc_ir_.host());
 }
 
 // Tests handling of PRIORITY frames.
 TEST_P(SpdyFramerTest, ReadPriority) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
+  SpdyFramer framer(spdy_version_);
+  SpdyPriorityIR priority(3, 1, 99, false);
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializePriority(priority));
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  framer.set_visitor(&visitor);
+  EXPECT_CALL(visitor, OnPriority(3, 1, 99, false));
+  framer.ProcessInput(frame->data(), frame->size());
 
-  const unsigned char kFrameData[] = {
-    0x00, 0x05, 0x02, 0x00,  // PRIORITY frame
-    0x00, 0x00, 0x00, 0x03,  // stream ID 3
-    0x00, 0x00, 0x00, 0x01,  // dependent on stream id 1
-    0x00                     // weight 0
-  };
-
-  TestSpdyVisitor visitor(spdy_version_);
-  visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
-
-  EXPECT_EQ(SpdyFramer::SPDY_RESET, visitor.framer_.state());
-  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, visitor.framer_.error_code())
-      << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
+  // TODO(mlavan): once we actually maintain a priority tree,
+  // check that state is adjusted correctly.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
@@ skipping 37 matching lines @@
   EXPECT_EQ(4u, framer.MapWeightToPriority(109));
   EXPECT_EQ(4u, framer.MapWeightToPriority(74));
   EXPECT_EQ(5u, framer.MapWeightToPriority(73));
   EXPECT_EQ(5u, framer.MapWeightToPriority(37));
   EXPECT_EQ(6u, framer.MapWeightToPriority(36));
   EXPECT_EQ(6u, framer.MapWeightToPriority(1));
   EXPECT_EQ(7u, framer.MapWeightToPriority(0));
 }
 
 }  // namespace net