Land recent SPDY changes (through 70021377)

net/spdy/spdy_protocol.h

 // 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.
 
 // This file contains some protocol structures for use with SPDY 2 and 3
 // The SPDY 2 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
@@ skipping 37 matching lines @@
 
 // Initial window size for a Spdy stream in bytes.
 const int32 kSpdyStreamInitialWindowSize = 64 * 1024;  // 64 KBytes
 
 // Initial window size for a Spdy session in bytes.
 const int32 kSpdySessionInitialWindowSize = 64 * 1024;  // 64 KBytes
 
 // Maximum window size for a Spdy stream or session.
 const int32 kSpdyMaximumWindowSize = 0x7FFFFFFF;  // Max signed 32bit int
 
+// Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
+const int32 kPaddingSizePerFrame = 256;
+
 // SPDY 2 dictionary.
 // This is just a hacked dictionary to use for shrinking HTTP-like headers.
 const char kV2Dictionary[] =
   "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-"
   "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi"
   "f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser"
   "-agent10010120020120220320420520630030130230330430530630740040140240340440"
   "5406407408409410411412413414415416417500501502503504505accept-rangesageeta"
   "glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic"
   "ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran"
@@ skipping 197 matching lines @@
 const char kHttp2ConnectionHeaderPrefix[] = {
   0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54,  // PRI * HT
   0x54, 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x0d, 0x0a,  // TP/2.0..
   0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a, 0x0d, 0x0a   // ..SM....
 };
 const int kHttp2ConnectionHeaderPrefixSize =
     arraysize(kHttp2ConnectionHeaderPrefix);
 
 // Types of SPDY frames.
 enum SpdyFrameType {
-  DATA = 0,
-  SYN_STREAM = 1,
-  FIRST_CONTROL_TYPE = SYN_STREAM,
+  DATA,
+  SYN_STREAM,
   SYN_REPLY,
   RST_STREAM,
   SETTINGS,
-  NOOP,  // Because it is valid in SPDY/2, kept for identifiability/enum order.
   PING,
   GOAWAY,
   HEADERS,
   WINDOW_UPDATE,
-  CREDENTIAL,  // No longer valid.  Kept for identifiability/enum order.
+  CREDENTIAL = 10,  // No longer valid.  Kept for identifiability.
   BLOCKED,
   PUSH_PROMISE,
   CONTINUATION,
   ALTSVC,
-  PRIORITY,
-  LAST_CONTROL_TYPE = PRIORITY
+  PRIORITY
 };
 
 // Flags on data packets.
 enum SpdyDataFlags {
   DATA_FLAG_NONE = 0x00,
   DATA_FLAG_FIN = 0x01,
   DATA_FLAG_END_SEGMENT = 0x02,
-  DATA_FLAG_PAD_LOW = 0x08,
-  DATA_FLAG_PAD_HIGH = 0x10,
+  DATA_FLAG_PADDED = 0x08,
   DATA_FLAG_COMPRESSED = 0x20,
 };
 
 // Flags on control packets
 enum SpdyControlFlags {
   CONTROL_FLAG_NONE = 0x00,
   CONTROL_FLAG_FIN = 0x01,
   CONTROL_FLAG_UNIDIRECTIONAL = 0x02,
 };
 
 enum SpdyPingFlags {
   PING_FLAG_ACK = 0x01,
 };
 
 // Used by HEADERS, PUSH_PROMISE, and CONTINUATION.
 enum SpdyHeadersFlags {
   HEADERS_FLAG_END_SEGMENT = 0x02,
   HEADERS_FLAG_END_HEADERS = 0x04,
-  HEADERS_FLAG_PAD_LOW = 0x08,
-  HEADERS_FLAG_PAD_HIGH = 0x10,
+  HEADERS_FLAG_PADDED = 0x08,
   HEADERS_FLAG_PRIORITY = 0x20,
 };
 
 enum SpdyPushPromiseFlags {
   PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04,
+  PUSH_PROMISE_FLAG_PADDED = 0x08,
 };
 
 // Flags on the SETTINGS control frame.
 enum SpdySettingsControlFlags {
   SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS = 0x01,
 };
 
 enum Http2SettingsControlFlags {
   SETTINGS_FLAG_ACK = 0x01,
 };
@@ skipping 17 matching lines @@
   // 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,
   // HPACK header table maximum size.
   SETTINGS_HEADER_TABLE_SIZE = 0x8,
   // Whether or not server push (PUSH_PROMISE) is enabled.
   SETTINGS_ENABLE_PUSH = 0x9,
-  // Whether or not to enable GZip compression of DATA frames.
-  SETTINGS_COMPRESS_DATA = 0xa,
 };
 
 // Status codes for RST_STREAM frames.
 enum SpdyRstStreamStatus {
   RST_STREAM_INVALID = 0,
   RST_STREAM_PROTOCOL_ERROR = 1,
   RST_STREAM_INVALID_STREAM = 2,
   RST_STREAM_STREAM_CLOSED = 2,  // Equivalent to INVALID_STREAM
   RST_STREAM_REFUSED_STREAM = 3,
   RST_STREAM_UNSUPPORTED_VERSION = 4,
@@ skipping 57 matching lines @@
   // use IsValidFrameType() to verify validity of frame type fields.
   static SpdyFrameType ParseFrameType(SpdyMajorVersion version,
                                       int frame_type_field);
 
   // Serializes a given frame type to the on-the-wire enumeration value for the
   // given protocol version.
   // Returns -1 on failure (I.E. Invalid frame type for the given version).
   static int SerializeFrameType(SpdyMajorVersion version,
                                 SpdyFrameType frame_type);
 
+  // Returns the frame type for non-control (i.e. data) frames
+  // in the given SPDY version.
+  static int DataFrameType(SpdyMajorVersion version);
+
   // Returns true if a given on-the-wire enumeration of a setting id is valid
   // for a given protocol version, false otherwise.
   static bool IsValidSettingId(SpdyMajorVersion version, int setting_id_field);
 
   // Parses a setting id from an on-the-wire enumeration of a given protocol
   // version.
   // Behavior is undefined for invalid setting id fields; consumers should first
   // use IsValidSettingId() to verify validity of setting id fields.
   static SpdySettingsIds ParseSettingId(SpdyMajorVersion version,
                                         int setting_id_field);
@@ skipping 50 matching lines @@
   static size_t GetControlFrameHeaderSize(SpdyMajorVersion version);
 
   static size_t GetPrefixLength(SpdyFrameType type, SpdyMajorVersion version);
 
   static size_t GetFrameMaximumSize(SpdyMajorVersion version);
 
   // Returns the size of a header block size field. Valid only for SPDY
   // versions <= 3.
   static size_t GetSizeOfSizeField(SpdyMajorVersion version);
 
+  // Returns the size (in bytes) of a wire setting ID and value.
+  static size_t GetSettingSize(SpdyMajorVersion version);
+
   static SpdyMajorVersion ParseMajorVersion(int version_number);
 
   static int SerializeMajorVersion(SpdyMajorVersion version);
 
   static std::string GetVersionString(SpdyMajorVersion version);
 };
 
 class SpdyFrame;
 typedef SpdyFrame SpdySerializedFrame;
 
@@ skipping 92 matching lines @@
   // Performs deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data);
 
   // Use in conjunction with SetDataShallow() for shallow-copy on data.
   explicit SpdyDataIR(SpdyStreamId stream_id);
 
   virtual ~SpdyDataIR();
 
   base::StringPiece data() const { return data_; }
 
-  bool pad_low() const { return pad_low_; }
-
-  bool pad_high() const { return pad_high_; }
+  bool padded() const { return padded_; }
 
   int padding_payload_len() const { return padding_payload_len_; }
 
   void set_padding_len(int padding_len) {
-    // The padding_len should be in (0, 65535 + 2].
-    // Note that SpdyFramer::GetDataFrameMaximumPayload() enforces the overall
-    // payload size later so we actually can't pad more than 16375 bytes.
     DCHECK_GT(padding_len, 0);
-    DCHECK_LT(padding_len, 65537);
-
-    if (padding_len <= 256) {
-      pad_low_ = true;
-      --padding_len;
-    } else {
-      pad_low_ = pad_high_ = true;
-      padding_len -= 2;
-    }
-    padding_payload_len_ = padding_len;
+    DCHECK_LE(padding_len, kPaddingSizePerFrame);
+    padded_ = true;
+    // The pad field takes one octet on the wire.
+    padding_payload_len_ = padding_len - 1;
   }
 
   // Deep-copy of data (keep private copy).
   void SetDataDeep(const base::StringPiece& data) {
     data_store_.reset(new std::string(data.data(), data.length()));
     data_ = *(data_store_.get());
   }
 
   // Shallow-copy of data (do not keep private copy).
   void SetDataShallow(const base::StringPiece& data) {
     data_store_.reset();
     data_ = data;
   }
 
   virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
 
  private:
   // Used to store data that this SpdyDataIR should own.
   scoped_ptr<std::string> data_store_;
   base::StringPiece data_;
 
-  bool pad_low_;
-  bool pad_high_;
+  bool padded_;
   // padding_payload_len_ = desired padding length - len(padding length field).
   int padding_payload_len_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyDataIR);
 };
 
 class NET_EXPORT_PRIVATE SpdySynStreamIR
     : public SpdyFrameWithNameValueBlockIR {
  public:
   explicit SpdySynStreamIR(SpdyStreamId stream_id)
@@ skipping 275 matching lines @@
 
  private:
   uint32 max_age_;
   uint16 port_;
   SpdyProtocolId protocol_id_;
   std::string host_;
   std::string origin_;
   DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
 };
 
+class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
+ public:
+  explicit SpdyPriorityIR(SpdyStreamId stream_id);
+  explicit SpdyPriorityIR(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive);
+  SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
+  void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
+  uint8 weight() const { return weight_; }
+  void set_weight(uint8 weight) { weight_ = weight; }
+  bool exclusive() const { return exclusive_; }
+  void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
+
+  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+
+ private:
+  SpdyStreamId parent_stream_id_;
+  uint8 weight_;
+  bool exclusive_;
+  DISALLOW_COPY_AND_ASSIGN(SpdyPriorityIR);
+};
+
 // -------------------------------------------------------------------------
 // Wrapper classes for various SPDY frames.
 
 // All Spdy Frame types derive from this SpdyFrame class.
 class SpdyFrame {
  public:
   // Create a SpdyFrame using a pre-created buffer.
   // If |owns_buffer| is true, this class takes ownership of the buffer
   // and will delete it on cleanup.  The buffer must have been created using
   // new char[].
@@ skipping 41 matching lines @@
   virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) = 0;
   virtual void VisitSettings(const SpdySettingsIR& settings) = 0;
   virtual void VisitPing(const SpdyPingIR& ping) = 0;
   virtual void VisitGoAway(const SpdyGoAwayIR& goaway) = 0;
   virtual void VisitHeaders(const SpdyHeadersIR& headers) = 0;
   virtual void VisitWindowUpdate(const SpdyWindowUpdateIR& window_update) = 0;
   virtual void VisitBlocked(const SpdyBlockedIR& blocked) = 0;
   virtual void VisitPushPromise(const SpdyPushPromiseIR& push_promise) = 0;
   virtual void VisitContinuation(const SpdyContinuationIR& continuation) = 0;
   virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) = 0;
+  virtual void VisitPriority(const SpdyPriorityIR& priority) = 0;
   virtual void VisitData(const SpdyDataIR& data) = 0;
 
  protected:
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_