Land recent SPDY changes (through 67282679)

net/spdy/spdy_framer.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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <list>
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_piece.h"
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
 #include "net/spdy/hpack_decoder.h"
 #include "net/spdy/hpack_encoder.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
 
 // TODO(akalin): Remove support for CREDENTIAL frames.
 
 typedef struct z_stream_s z_stream;  // Forward declaration for zlib.
@@ skipping 67 matching lines @@
 
   // The amount of the buffer that is filled with valid data.
   size_t setting_buf_len;
 
   // The ID of the last setting that was processed in the current SETTINGS
   // frame. Used for detecting out-of-order or duplicate keys within a settings
   // frame. Set to -1 before first key/value pair is processed.
   int last_setting_id;
 };
 
+// Scratch space necessary for processing ALTSVC frames.
+struct NET_EXPORT_PRIVATE SpdyAltSvcScratch {
+  SpdyAltSvcScratch();
+  ~SpdyAltSvcScratch();
+
+  void Reset() {
+    max_age = 0;
+    port = 0;
+    pid_len = 0;
+    host_len = 0;
+    origin_len = 0;
+    pid_buf_len = 0;
+    host_buf_len = 0;
+    origin_buf_len = 0;
+    protocol_id.reset();
+    host.reset();
+    origin.reset();
+  }
+
+  uint32 max_age;
+  uint16 port;
+  uint8 pid_len;
+  uint8 host_len;
+  size_t origin_len;
+  size_t pid_buf_len;
+  size_t host_buf_len;
+  size_t origin_buf_len;
+  scoped_ptr<char[]> protocol_id;
+  scoped_ptr<char[]> host;
+  scoped_ptr<char[]> origin;
+};
+
 // SpdyFramerVisitorInterface is a set of callbacks for the SpdyFramer.
 // Implement this interface to receive event callbacks as frames are
 // decoded from the framer.
 //
 // Control frames that contain SPDY header blocks (SYN_STREAM, SYN_REPLY,
 // HEADER, and PUSH_PROMISE) are processed in fashion that allows the
 // decompressed header block to be delivered in chunks to the visitor.
 // The following steps are followed:
 //   1. OnSynStream, OnSynReply, OnHeaders, or OnPushPromise is called.
 //   2. Repeated: OnControlFrameHeaderData is called with chunks of the
@@ skipping 121 matching lines @@
   // Note that header block data is not included. See
   // OnControlFrameHeaderData().
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
                              bool end) = 0;
 
   // Called when a CONTINUATION frame is received.
   // Note that header block data is not included. See
   // OnControlFrameHeaderData().
   virtual void OnContinuation(SpdyStreamId stream_id, bool end) = 0;
+
+  // Called when an ALTSVC frame has been parsed.
+  virtual void OnAltSvc(SpdyStreamId stream_id,
+                        uint32 max_age,
+                        uint16 port,
+                        base::StringPiece protocol_id,
+                        base::StringPiece host,
+                        base::StringPiece origin) {}
 };
 
 // Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
 // SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
 // order to extract debug/internal information about the SpdyFramer as it
 // operates.
 //
 // Most SPDY implementations need not bother with this interface at all.
 class NET_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
  public:
@@ skipping 29 matching lines @@
     SPDY_CONTROL_FRAME_PAYLOAD,
     SPDY_READ_PADDING_LENGTH,
     SPDY_CONSUME_PADDING,
     SPDY_IGNORE_REMAINING_PAYLOAD,
     SPDY_FORWARD_STREAM_FRAME,
     SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK,
     SPDY_CONTROL_FRAME_HEADER_BLOCK,
     SPDY_GOAWAY_FRAME_PAYLOAD,
     SPDY_RST_STREAM_FRAME_PAYLOAD,
     SPDY_SETTINGS_FRAME_PAYLOAD,
+    SPDY_ALTSVC_FRAME_PAYLOAD,
   };
 
   // SPDY error codes.
   enum SpdyError {
     SPDY_NO_ERROR,
     SPDY_INVALID_CONTROL_FRAME,        // Control frame is mal-formatted.
     SPDY_CONTROL_PAYLOAD_TOO_LARGE,    // Control frame payload was too large.
     SPDY_ZLIB_INIT_FAILURE,            // The Zlib library could not initialize.
     SPDY_UNSUPPORTED_VERSION,          // Control frame has unsupported version.
     SPDY_DECOMPRESS_FAILURE,           // There was an error decompressing.
@@ skipping 120 matching lines @@
       const SpdyPushPromiseIR& push_promise);
 
   // Serializes a CONTINUATION frame. The CONTINUATION frame is used
   // to continue a sequence of header block fragments.
   // TODO(jgraettinger): This implementation is incorrect. The continuation
   // frame continues a previously-begun HPACK encoding; it doesn't begin a
   // new one. Figure out whether it makes sense to keep SerializeContinuation().
   SpdySerializedFrame* SerializeContinuation(
       const SpdyContinuationIR& continuation);
 
+  // Serializes an ALTSVC frame. The ALTSVC frame advertises the
+  // availability of an alternative service to the client.
+  SpdySerializedFrame* SerializeAltSvc(const SpdyAltSvcIR& altsvc);
+
   // Serialize a frame of unknown type.
   SpdySerializedFrame* SerializeFrame(const SpdyFrameIR& frame);
 
   // NOTES about frame compression.
   // We want spdy to compress headers across the entire session.  As long as
   // the session is over TCP, frames are sent serially.  The client & server
   // can each compress frames in the same order and then compress them in that
   // order, and the remote can do the reverse.  However, we ultimately want
   // the creation of frames to be less sensitive to order so that they can be
   // placed over a UDP based protocol and yet still benefit from some
@@ skipping 25 matching lines @@
   size_t GetSynReplyMinimumSize() const;
   size_t GetRstStreamMinimumSize() const;
   size_t GetSettingsMinimumSize() const;
   size_t GetPingSize() const;
   size_t GetGoAwayMinimumSize() const;
   size_t GetHeadersMinimumSize() const;
   size_t GetWindowUpdateSize() const;
   size_t GetBlockedSize() const;
   size_t GetPushPromiseMinimumSize() const;
   size_t GetContinuationMinimumSize() const;
+  size_t GetAltSvcMinimumSize() const;
+  size_t GetPrioritySize() const;
 
   // Returns the minimum size a frame can be (data or control).
   size_t GetFrameMinimumSize() const;
 
   // Returns the maximum size a frame can be (data or control).
   size_t GetFrameMaximumSize() const;
 
   // Returns the maximum size that a control frame can be.
   size_t GetControlFrameMaximumSize() const;
 
@@ skipping 74 matching lines @@
   // whether data is treated as HPACK- vs SPDY3-encoded.
   size_t ProcessControlFrameHeaderBlock(const char* data,
                                         size_t len,
                                         bool is_hpack_header_block);
   size_t ProcessFramePaddingLength(const char* data, size_t len);
   size_t ProcessFramePadding(const char* data, size_t len);
   size_t ProcessDataFramePayload(const char* data, size_t len);
   size_t ProcessGoAwayFramePayload(const char* data, size_t len);
   size_t ProcessRstStreamFramePayload(const char* data, size_t len);
   size_t ProcessSettingsFramePayload(const char* data, size_t len);
+  size_t ProcessAltSvcFramePayload(const char* data, size_t len);
   size_t ProcessIgnoredControlFramePayload(/*const char* data,*/ size_t len);
 
   // TODO(jgraettinger): To be removed with migration to
   // SpdyHeadersHandlerInterface.
   // Serializes the last-processed header block of |hpack_decoder_| as
   // a SPDY3 format block, and delivers it to the visitor via reentrant
   // call to ProcessControlFrameHeaderBlock().
   void DeliverHpackBlockAsSpdy3Block();
 
   // Helpers for above internal breakouts from ProcessInput.
   void ProcessControlFrameHeader(uint16 control_frame_type_field);
   // Always passed exactly 1 setting's worth of data.
   bool ProcessSetting(const char* data);
 
   // Retrieve serialized length of SpdyHeaderBlock. If compression is enabled, a
   // maximum estimate is returned.
   size_t GetSerializedLength(const SpdyHeaderBlock& headers);
 
   // Get (and lazily initialize) the ZLib state.
   z_stream* GetHeaderCompressor();
   z_stream* GetHeaderDecompressor();
 
+  // Get (and lazily initialize) the HPACK state.
+  HpackEncoder* GetHpackEncoder();
+  HpackDecoder* GetHpackDecoder();
+
   size_t GetNumberRequiredContinuationFrames(size_t size);
 
   void WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                     const std::string& hpack_encoding,
                                     SpdyStreamId stream_id,
                                     SpdyFrameType type);
 
  private:
   // Deliver the given control frame's uncompressed headers block to the
   // visitor in chunks. Returns true if the visitor has accepted all of the
@@ skipping 84 matching lines @@
   uint32 current_frame_length_;
 
   // The stream ID field of the frame currently being read, if applicable.
   SpdyStreamId current_frame_stream_id_;
 
   // Scratch space for handling SETTINGS frames.
   // TODO(hkhalil): Unify memory for this scratch space with
   // current_frame_buffer_.
   SpdySettingsScratch settings_scratch_;
 
+  SpdyAltSvcScratch altsvc_scratch_;
+
   bool enable_compression_;  // Controls all compression
   // SPDY header compressors.
   scoped_ptr<z_stream> header_compressor_;
   scoped_ptr<z_stream> header_decompressor_;
 
   scoped_ptr<HpackEncoder> hpack_encoder_;
   scoped_ptr<HpackDecoder> hpack_decoder_;
 
   SpdyFramerVisitorInterface* visitor_;
   SpdyFramerDebugVisitorInterface* debug_visitor_;
@@ skipping 27 matching lines @@
   // If a HEADERS frame is followed by a CONTINUATION frame, the FIN/END_STREAM
   // flag is still carried in the HEADERS frame. If it's set, flip this so that
   // we know to terminate the stream when the entire header block has been
   // processed.
   bool end_stream_when_done_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_