Updated spdy_framer.cc with the latest code.

net/spdy/spdy_protocol.h

 // Copyright (c) 2011 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.
 
 // This file contains some protocol structures for use with Spdy.
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
 #pragma once
 
@@ skipping 173 matching lines @@
 // Flags for settings within a SETTINGS frame.
 enum SpdySettingsFlags {
   SETTINGS_FLAG_PLEASE_PERSIST = 0x1,
   SETTINGS_FLAG_PERSISTED = 0x2
 };
 
 // List of known settings.
 enum SpdySettingsIds {
   SETTINGS_UPLOAD_BANDWIDTH = 0x1,
   SETTINGS_DOWNLOAD_BANDWIDTH = 0x2,
+  // Network round trip time in milliseconds.
   SETTINGS_ROUND_TRIP_TIME = 0x3,
   SETTINGS_MAX_CONCURRENT_STREAMS = 0x4,
+  // TCP congestion window in packets.
   SETTINGS_CURRENT_CWND = 0x5,
   // Downstream byte retransmission rate in percentage.
   SETTINGS_DOWNLOAD_RETRANS_RATE = 0x6,
   // Initial window size in bytes
   SETTINGS_INITIAL_WINDOW_SIZE = 0x7
 };
 
 // Status codes, as used in control frames (primarily RST_STREAM).
 enum SpdyStatusCodes {
   INVALID = 0,
@@ skipping 65 matching lines @@
   SpdyStreamId stream_id_;
   uint32 status_;
 };
 
 // A SETTINGS Control Frame structure.
 struct SpdySettingsControlFrameBlock : SpdyFrameBlock {
   uint32 num_entries_;
   // Variable data here.
 };
 
+// A NOOP Control Frame structure.
+struct SpdyNoopControlFrameBlock : SpdyFrameBlock {
+};
+
+// A PING Control Frame structure.
+struct SpdyPingControlFrameBlock : SpdyFrameBlock {
+  uint32 unique_id_;
+};
+
 // A GOAWAY Control Frame structure.
 struct SpdyGoAwayControlFrameBlock : SpdyFrameBlock {
   SpdyStreamId last_accepted_stream_id_;
 };
 
 // A HEADERS Control Frame structure.
 struct SpdyHeadersControlFrameBlock : SpdyFrameBlock {
   SpdyStreamId stream_id_;
   uint16 unused_;
 };
 
 // A WINDOW_UPDATE Control Frame structure
 struct SpdyWindowUpdateControlFrameBlock : SpdyFrameBlock {
   SpdyStreamId stream_id_;
   uint32 delta_window_size_;
 };
 
 // A structure for the 8 bit flags and 24 bit ID fields.
 union SettingsFlagsAndId {
+  // Sets both flags and id to the value for flags-and-id as sent over the wire
   SettingsFlagsAndId(uint32 val) : id_(val) {}
   uint8 flags() const { return flags_[0]; }
   void set_flags(uint8 flags) { flags_[0] = flags; }
   uint32 id() const { return (ntohl(id_) & kSettingsIdMask); }
   void set_id(uint32 id) {
     DCHECK_EQ(0u, (id & ~kSettingsIdMask));
     id_ = htonl((flags() << 24) | (id & kSettingsIdMask));
   }
 
   uint8 flags_[4];  // 8 bits
@@ skipping 133 matching lines @@
     uint16 type = ntohs(block()->control_.type_);
     DCHECK(type >= SYN_STREAM && type < NUM_CONTROL_FRAME_TYPES);
     return static_cast<SpdyControlType>(type);
   }
 
   void set_type(SpdyControlType type) {
     DCHECK(type >= SYN_STREAM && type < NUM_CONTROL_FRAME_TYPES);
     mutable_block()->control_.type_ = htons(type);
   }
 
+  // Returns true if this control frame is of a type that has a header block,
+  // otherwise it returns false.
+  bool has_header_block() const {
+    return type() == SYN_STREAM || type() == SYN_REPLY || type() == HEADERS;
+  }
+
   // Returns the size of the SpdyFrameBlock structure.
   // Note: this is not the size of the SpdyControlFrame class.
   static size_t size() { return sizeof(SpdyFrameBlock); }
 
+  // The size of the 'Number of Name/Value pairs' field in a Name/Value block.
+  static const size_t kNumNameValuePairsSize = 2;
+
+  // The size of the 'Length of a name' field in a Name/Value block.
+  static const size_t kLengthOfNameSize = 2;
+
+  // The size of the 'Length of a value' field in a Name/Value block.
+  static const size_t kLengthOfValueSize = 2;
+
  private:
   const struct SpdyFrameBlock* block() const {
     return frame_;
   }
   struct SpdyFrameBlock* mutable_block() {
     return frame_;
   }
   DISALLOW_COPY_AND_ASSIGN(SpdyControlFrame);
 };
 
@@ skipping 93 matching lines @@
 
   SpdyStreamId stream_id() const {
     return ntohl(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
     mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
   }
 
   SpdyStatusCodes status() const {
-    return static_cast<SpdyStatusCodes>(ntohl(block()->status_));
+    SpdyStatusCodes status =
+        static_cast<SpdyStatusCodes>(ntohl(block()->status_));
+    if (status < INVALID || status >= NUM_STATUS_CODES) {
+      status = INVALID;
+    }
+    return status;
   }
   void set_status(SpdyStatusCodes status) {
     mutable_block()->status_ = htonl(static_cast<uint32>(status));
   }
 
   // Returns the size of the SpdyRstStreamControlFrameBlock structure.
   // Note: this is not the size of the SpdyRstStreamControlFrame class.
   static size_t size() { return sizeof(SpdyRstStreamControlFrameBlock); }
 
  private:
@@ skipping 35 matching lines @@
  private:
   const struct SpdySettingsControlFrameBlock* block() const {
     return static_cast<SpdySettingsControlFrameBlock*>(frame_);
   }
   struct SpdySettingsControlFrameBlock* mutable_block() {
     return static_cast<SpdySettingsControlFrameBlock*>(frame_);
   }
   DISALLOW_COPY_AND_ASSIGN(SpdySettingsControlFrame);
 };
 
+class SpdyNoOpControlFrame : public SpdyControlFrame {
+ public:
+  SpdyNoOpControlFrame() : SpdyControlFrame(size()) {}
+  SpdyNoOpControlFrame(char* data, bool owns_buffer)
+      : SpdyControlFrame(data, owns_buffer) {}
+
+  static size_t size() { return sizeof(SpdyNoopControlFrameBlock); }
+};
+
+class SpdyPingControlFrame : public SpdyControlFrame {
+ public:
+  SpdyPingControlFrame() : SpdyControlFrame(size()) {}
+  SpdyPingControlFrame(char* data, bool owns_buffer)
+      : SpdyControlFrame(data, owns_buffer) {}
+
+  uint32 unique_id() const {
+    return ntohl(block()->unique_id_);
+  }
+
+  void set_unique_id(uint32 unique_id) {
+    mutable_block()->unique_id_ = htonl(unique_id);
+  }
+
+  static size_t size() { return sizeof(SpdyPingControlFrameBlock); }
+
+ private:
+  const struct SpdyPingControlFrameBlock* block() const {
+    return static_cast<SpdyPingControlFrameBlock*>(frame_);
+  }
+  struct SpdyPingControlFrameBlock* mutable_block() {
+    return static_cast<SpdyPingControlFrameBlock*>(frame_);
+  }
+};
+
 class SpdyGoAwayControlFrame : public SpdyControlFrame {
  public:
   SpdyGoAwayControlFrame() : SpdyControlFrame(size()) {}
   SpdyGoAwayControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId last_accepted_stream_id() const {
     return ntohl(block()->last_accepted_stream_id_) & kStreamIdMask;
   }
 
@@ skipping 85 matching lines @@
   struct SpdyWindowUpdateControlFrameBlock* mutable_block() {
     return static_cast<SpdyWindowUpdateControlFrameBlock*>(frame_);
   }
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateControlFrame);
 };
 
 }  // namespace spdy
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_