Land recent SPDY changes (through 67282679)

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 269 matching lines @@
   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.
   BLOCKED,
   PUSH_PROMISE,
   CONTINUATION,
-  LAST_CONTROL_TYPE = CONTINUATION
+  ALTSVC,
+  PRIORITY,
+  LAST_CONTROL_TYPE = PRIORITY
 };
 
 // Flags on data packets.
 enum SpdyDataFlags {
-DATA_FLAG_NONE = 0x00,
+  DATA_FLAG_NONE = 0x00,
   DATA_FLAG_FIN = 0x01,
   DATA_FLAG_END_SEGMENT = 0x02,
-  DATA_FLAG_PAD_LOW = 0x10,
-  DATA_FLAG_PAD_HIGH = 0x20
+  DATA_FLAG_PAD_LOW = 0x08,
+  DATA_FLAG_PAD_HIGH = 0x10,
+  DATA_FLAG_COMPRESSED = 0x20,
 };
 
 // Flags on control packets
 enum SpdyControlFlags {
-  CONTROL_FLAG_NONE = 0,
-  CONTROL_FLAG_FIN = 1,
-  CONTROL_FLAG_UNIDIRECTIONAL = 2
+  CONTROL_FLAG_NONE = 0x00,
+  CONTROL_FLAG_FIN = 0x01,
+  CONTROL_FLAG_UNIDIRECTIONAL = 0x02,
 };
 
 enum SpdyPingFlags {
-  PING_FLAG_ACK = 0x1,
+  PING_FLAG_ACK = 0x01,
 };
 
+// Used by HEADERS, PUSH_PROMISE, and CONTINUATION.
 enum SpdyHeadersFlags {
-  HEADERS_FLAG_END_HEADERS = 0x4,
-  HEADERS_FLAG_PRIORITY = 0x8
+  HEADERS_FLAG_END_SEGMENT = 0x02,
+  HEADERS_FLAG_END_HEADERS = 0x04,
+  HEADERS_FLAG_PAD_LOW = 0x08,
+  HEADERS_FLAG_PAD_HIGH = 0x10,
+  HEADERS_FLAG_PRIORITY = 0x20,
 };
 
 enum SpdyPushPromiseFlags {
-  PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x4
+  PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04,
 };
 
 // Flags on the SETTINGS control frame.
 enum SpdySettingsControlFlags {
-  SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS = 0x1
+  SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS = 0x01,
 };
 
 enum Http2SettingsControlFlags {
-  SETTINGS_FLAG_ACK = 0x1,
+  SETTINGS_FLAG_ACK = 0x01,
 };
 
 // Flags for settings within a SETTINGS frame.
 enum SpdySettingsFlags {
-  SETTINGS_FLAG_NONE = 0x0,
-  SETTINGS_FLAG_PLEASE_PERSIST = 0x1,
-  SETTINGS_FLAG_PERSISTED = 0x2
+  SETTINGS_FLAG_NONE = 0x00,
+  SETTINGS_FLAG_PLEASE_PERSIST = 0x01,
+  SETTINGS_FLAG_PERSISTED = 0x02,
 };
 
 // List of known settings. Avoid changing these enum values, as persisted
 // settings are keyed on them, and they are also exposed in net-internals.
 enum SpdySettingsIds {
   SETTINGS_UPLOAD_BANDWIDTH = 0x1,
   SETTINGS_DOWNLOAD_BANDWIDTH = 0x2,
   // Network round trip time in milliseconds.
   SETTINGS_ROUND_TRIP_TIME = 0x3,
   // The maximum number of simultaneous live streams in each direction.
   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,
   // 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 34 matching lines @@
 
 // A SPDY priority is a number between 0 and 7 (inclusive).
 // SPDY priority range is version-dependent. For SPDY 2 and below, priority is a
 // number between 0 and 3.
 typedef uint8 SpdyPriority;
 
 typedef std::map<std::string, std::string> SpdyNameValueBlock;
 
 typedef uint64 SpdyPingId;
 
+typedef std::string SpdyProtocolId;
+
 // TODO(hkhalil): Add direct testing for this? It won't increase coverage any,
 // but is good to do anyway.
 class NET_EXPORT_PRIVATE SpdyConstants {
  public:
   // Returns true if a given on-the-wire enumeration of a frame type is valid
   // for a given protocol version, false otherwise.
   static bool IsValidFrameType(SpdyMajorVersion version, int frame_type_field);
 
   // Parses a frame type from an on-the-wire enumeration of a given protocol
   // version.
@@ skipping 487 matching lines @@
   virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
 
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) {end_headers_ = end_headers;}
 
  private:
   bool end_headers_;
   DISALLOW_COPY_AND_ASSIGN(SpdyContinuationIR);
 };
 
+class NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
+ public:
+  explicit SpdyAltSvcIR(SpdyStreamId stream_id);
+
+  uint32 max_age() const { return max_age_; }
+  uint16 port() const { return port_; }
+  SpdyProtocolId protocol_id() const {
+    return protocol_id_;
+  }
+  std::string host() const { return host_; }
+  std::string origin() const { return origin_; }
+
+  void set_max_age(uint32 max_age) { max_age_ = max_age; }
+  void set_port(uint16 port) { port_ = port; }
+  void set_protocol_id(SpdyProtocolId protocol_id) {
+    protocol_id_ = protocol_id;
+  }
+  void set_host(std::string host) {
+    host_ = host;
+  }
+  void set_origin(std::string origin) {
+    origin_ = origin;
+  }
+
+  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+
+ private:
+  uint32 max_age_;
+  uint16 port_;
+  SpdyProtocolId protocol_id_;
+  std::string host_;
+  std::string origin_;
+  DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
+};
+
 // -------------------------------------------------------------------------
 // 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 40 matching lines @@
   virtual void VisitSynReply(const SpdySynReplyIR& syn_reply) = 0;
   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 VisitData(const SpdyDataIR& data) = 0;
 
  protected:
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_