Refactor in preparation for SPDY 4, part 1.

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 <string>
@@ skipping 26 matching lines @@
 class SpdyFramer;
 class SpdyFrameBuilder;
 class SpdyFramerTest;
 
 namespace test {
 
 class TestSpdyVisitor;
 
 }  // namespace test
 
+// A datastructure for holding a set of headers from either a
+// SYN_STREAM or SYN_REPLY frame.
+typedef std::map<std::string, std::string> SpdyHeaderBlock;
+
 // A datastructure for holding the ID and flag fields for SETTINGS.
 // Conveniently handles converstion to/from wire format.
 class NET_EXPORT_PRIVATE SettingsFlagsAndId {
  public:
   static SettingsFlagsAndId FromWireFormat(int version, uint32 wire);
 
   SettingsFlagsAndId() : flags_(0), id_(0) {}
 
   // TODO(hkhalil): restrict to enums instead of free-form ints.
   SettingsFlagsAndId(uint8 flags, uint32 id);
 
   uint32 GetWireFormat(int version) const;
 
   uint32 id() const { return id_; }
   uint8 flags() const { return flags_; }
 
  private:
   static void ConvertFlagsAndIdForSpdy2(uint32* val);
 
   uint8 flags_;
   uint32 id_;
 };
 
 // SettingsMap has unique (flags, value) pair for given SpdySettingsIds ID.
 typedef std::pair<SpdySettingsFlags, uint32> SettingsFlagsAndValue;
 typedef std::map<SpdySettingsIds, SettingsFlagsAndValue> SettingsMap;
 
 // A datastrcture for holding the contents of a CREDENTIAL frame.
+// TODO(hkhalil): Remove, use SpdyCredentialIR instead.
 struct NET_EXPORT_PRIVATE SpdyCredential {
   SpdyCredential();
   ~SpdyCredential();
 
   uint16 slot;
   std::vector<std::string> certs;
   std::string proof;
 };
 
 // Scratch space necessary for processing SETTINGS frames.
@@ skipping 207 matching lines @@
   // through OnControlFrameHeaderData. (It is exposed here for unit test
   // purposes.)
   static const size_t kHeaderDataChunkMaxSize;
 
   // Serializes a SpdyHeaderBlock.
   static void WriteHeaderBlock(SpdyFrameBuilder* frame,
                                const int spdy_version,
                                const SpdyHeaderBlock* headers);
 
   // Retrieve serialized length of SpdyHeaderBlock.
+  // TODO(hkhalil): Change to const reference instead of const pointer.
   static size_t GetSerializedLength(const int spdy_version,
                                     const SpdyHeaderBlock* headers);
 
   // Create a new Framer, provided a SPDY version.
   explicit SpdyFramer(int version);
   virtual ~SpdyFramer();
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
@@ skipping 41 matching lines @@
   //    To mark this frame as the last frame, enable CONTROL_FLAG_FIN.
   // |compressed| specifies whether the frame should be compressed.
   // |headers| is the header block to include in the frame.
   SpdySynStreamControlFrame* CreateSynStream(SpdyStreamId stream_id,
                                              SpdyStreamId associated_stream_id,
                                              SpdyPriority priority,
                                              uint8 credential_slot,
                                              SpdyControlFlags flags,
                                              bool compressed,
                                              const SpdyHeaderBlock* headers);
+  SpdySerializedFrame* SerializeSynStream(const SpdySynStreamIR& syn_stream);
 
   // Create a SpdySynReplyControlFrame.
   // |stream_id| is the stream for this frame.
   // |flags| is the flags to use with the data.
   //    To mark this frame as the last frame, enable CONTROL_FLAG_FIN.
   // |compressed| specifies whether the frame should be compressed.
   // |headers| is the header block to include in the frame.
   SpdySynReplyControlFrame* CreateSynReply(SpdyStreamId stream_id,
                                            SpdyControlFlags flags,
                                            bool compressed,
                                            const SpdyHeaderBlock* headers);
+  SpdySerializedFrame* SerializeSynReply(const SpdySynReplyIR& syn_reply);
 
   SpdyRstStreamControlFrame* CreateRstStream(SpdyStreamId stream_id,
                                              SpdyRstStreamStatus status) const;
+  SpdySerializedFrame* SerializeRstStream(
+      const SpdyRstStreamIR& rst_stream) const;
 
   // Creates an instance of SpdySettingsControlFrame. The SETTINGS frame is
   // used to communicate name/value pairs relevant to the communication channel.
   SpdySettingsControlFrame* CreateSettings(const SettingsMap& values) const;
+  SpdySerializedFrame* SerializeSettings(const SpdySettingsIR& settings) const;
 
   // Creates an instance of SpdyPingControlFrame. The unique_id is used to
   // identify the ping request/response.
   SpdyPingControlFrame* CreatePingFrame(uint32 unique_id) const;
+  SpdySerializedFrame* SerializePing(const SpdyPingIR& ping) const;
 
   // Creates an instance of SpdyGoAwayControlFrame. The GOAWAY frame is used
   // prior to the shutting down of the TCP connection, and includes the
   // stream_id of the last stream the sender of the frame is willing to process
   // to completion.
   SpdyGoAwayControlFrame* CreateGoAway(SpdyStreamId last_accepted_stream_id,
                                        SpdyGoAwayStatus status) const;
+  SpdySerializedFrame* SerializeGoAway(const SpdyGoAwayIR& goaway) const;
 
   // Creates an instance of SpdyHeadersControlFrame. The HEADERS frame is used
   // for sending additional headers outside of a SYN_STREAM/SYN_REPLY. The
   // arguments are the same as for CreateSynReply.
   SpdyHeadersControlFrame* CreateHeaders(SpdyStreamId stream_id,
                                          SpdyControlFlags flags,
                                          bool compressed,
                                          const SpdyHeaderBlock* headers);
+  SpdySerializedFrame* SerializeHeaders(const SpdyHeadersIR& headers);
 
   // Creates an instance of SpdyWindowUpdateControlFrame. The WINDOW_UPDATE
   // frame is used to implement per stream flow control in SPDY.
   SpdyWindowUpdateControlFrame* CreateWindowUpdate(
       SpdyStreamId stream_id,
       uint32 delta_window_size) const;
+  SpdySerializedFrame* SerializeWindowUpdate(
+      const SpdyWindowUpdateIR& window_update) const;
 
   // Creates an instance of SpdyCredentialControlFrame.  The CREDENTIAL
   // frame is used to send a client certificate to the server when
   // request more than one origin are sent over the same SPDY session.
   SpdyCredentialControlFrame* CreateCredentialFrame(
       const SpdyCredential& credential) const;
+  SpdySerializedFrame* SerializeCredential(
+      const SpdyCredentialIR& credential) const;
 
   // Given a SpdySettingsControlFrame, extract the settings.
   // Returns true on successful parse, false otherwise.
   static bool ParseSettings(const SpdySettingsControlFrame* frame,
                             SettingsMap* settings);
 
   // Given a SpdyCredentialControlFrame's payload, extract the credential.
   // Returns true on successful parse, false otherwise.
   // TODO(hkhalil): Implement CREDENTIAL frame parsing in SpdyFramer
   // and eliminate this method.
   static bool ParseCredentialData(const char* data, size_t len,
                                   SpdyCredential* credential);
 
   // Create a data frame.
   // |stream_id| is the stream  for this frame
   // |data| is the data to be included in the frame.
   // |len| is the length of the data
   // |flags| is the flags to use with the data.
   //    To mark this frame as the last data frame, enable DATA_FLAG_FIN.
   SpdyDataFrame* CreateDataFrame(SpdyStreamId stream_id, const char* data,
                                  uint32 len, SpdyDataFlags flags) const;
+  SpdySerializedFrame* SerializeData(const SpdyDataIR& data) const;
 
   // 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
   // compression.  We don't know of any good compression protocol which does
   // not build its state in a serial (stream based) manner....  For now, we're
@@ skipping 17 matching lines @@
   // type. This is useful for validating frame blocks.
   static size_t GetMinimumControlFrameSize(int version, SpdyControlType type);
 
   // Get the stream ID for the given control frame (SYN_STREAM, SYN_REPLY, and
   // HEADERS). If the control frame is NULL or of another type, this
   // function returns kInvalidStream.
   static SpdyStreamId GetControlFrameStreamId(
       const SpdyControlFrame* control_frame);
 
   // For ease of testing and experimentation we can tweak compression on/off.
-  void set_enable_compression(bool value);
+  void set_enable_compression(bool value) {
+    enable_compression_ = value;
+  }
 
   // Used only in log messages.
   void set_display_protocol(const std::string& protocol) {
     display_protocol_ = protocol;
   }
 
   // For debugging.
   static const char* StateToString(int state);
   static const char* ErrorCodeToString(int error_code);
   static const char* StatusCodeToString(int status_code);
@@ skipping 72 matching lines @@
   // data (pointer and length). Returns the number of bytes
   // read, and:
   //   *data is advanced the number of bytes read.
   //   *len is reduced by the number of bytes read.
   size_t UpdateCurrentFrameBuffer(const char** data, size_t* len,
                                   size_t max_bytes);
 
   void WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
                            z_stream* out) const;
 
+  void SerializeNameValueBlock(
+      SpdyFrameBuilder* builder,
+      const SpdyFrameWithNameValueBlockIR& frame) const;
+
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyError error);
 
   // Given a frame, breakdown the variable payload length, the static header
   // header length, and variable payload pointer.
   bool GetFrameBoundaries(const SpdyFrame& frame, int* payload_length,
                           int* header_length, const char** payload) const;
 
   // Returns a new SpdyControlFrame with the compressed payload of |frame|.
   SpdyControlFrame* CompressControlFrame(const SpdyControlFrame& frame,
@@ skipping 61 matching lines @@
   // starts with HTTP.  If it does, we likely have an HTTP response.   This
   // isn't guaranteed though: we could have gotten a settings frame and then
   // corrupt data that just looks like HTTP, but deterministic checking requires
   // a lot more state.
   bool probable_http_response_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_