Attn: Mike Belshe

net/spdy/spdy_framer.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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 #pragma once
 
 #ifdef _WIN32
 #include <winsock2.h>
@@ skipping 56 matching lines @@
 
   // Called when data is received.
   // |stream_id| The stream receiving data.
   // |data| A buffer containing the data received.
   // |len| The length of the data buffer.
   // When the other side has finished sending data on this stream,
   // this method will be called with a zero-length buffer.
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len) = 0;
+
+  // Returns true if the underlying socket's transport protocol is SCTP.
+  virtual bool using_sctp() { return false; }

[Mike Belshe, 2011/04/06 18:32:53]

const functions

+
+  // Returns true if the underlying socker transport protocol if SCTP and SPDY
+  // control frames are send on SCTP stream 0.
+  virtual bool using_sctp_control_stream() { return false; }

[Mike Belshe, 2011/04/06 18:32:53]

const

+
+  // Maps a SPDY stream number to an SCTP stream ID.
+  virtual uint16 MapSpdyToSctp(uint32 stream_id) { return 0; }

[Mike Belshe, 2011/04/06 18:32:53]

const

 };
 
 class SpdyFramer {
  public:
   // SPDY states.
   // TODO(mbelshe): Can we move these into the implementation
   //                and avoid exposing through the header.  (Needed for test)
   enum SpdyState {
     SPDY_ERROR,
     SPDY_DONE,
@@ skipping 152 matching lines @@
   // On failure, returns NULL.
   SpdyFrame* DecompressFrame(const SpdyFrame& frame);
 
   // Create a copy of a frame.
   // Returned frame must be freed with "delete".
   SpdyFrame* DuplicateFrame(const SpdyFrame& frame);
 
   // Returns true if a frame could be compressed.
   bool IsCompressible(const SpdyFrame& frame) const;
 
+  // Returns true if underlying socket transport protocol is SCTP.
+  bool using_sctp() {
+    if (visitor_)
+      return visitor_->using_sctp();
+    else
+      // TODO(jtl): return sctp_enabled() here?
+      return false;
+  }
+
+  // Returns true if the underlying socker transport protocol if SCTP and SPDY
+  // control frames are send on SCTP stream 0.
+  bool using_sctp_control_stream() {
+    if (visitor_)
+      return visitor_->using_sctp_control_stream();
+    else
+      // TODO(jtl): return sctp_enabled() here?
+      return false;
+  }
+
+  // Maps a SPDY stream number of an SCTP stream ID.
+  uint16 MapSpdyToSctp(uint32 stream_id) {
+    return visitor_->MapSpdyToSctp(stream_id);
+  }
+
   // For debugging.
   static const char* StateToString(int state);
   static const char* ErrorCodeToString(int error_code);
   static void set_protocol_version(int version) { spdy_version_= version; }
   static int protocol_version() { return spdy_version_; }
 
   // Export the compression dictionary
   static const char kDictionary[];
   static const int kDictionarySize;
 
@@ skipping 34 matching lines @@
   typedef std::map<SpdyStreamId, z_stream*> CompressorMap;
 
   // Internal breakout from ProcessInput.  Returns the number of bytes
   // consumed from the data.
   size_t ProcessCommonHeader(const char* data, size_t len);
   void ProcessControlFrameHeader();
   size_t ProcessControlFramePayload(const char* data, size_t len);
   size_t ProcessDataFramePayload(const char* data, size_t len);
 
   // Get (and lazily initialize) the ZLib state.
-  z_stream* GetHeaderCompressor();
-  z_stream* GetHeaderDecompressor();
+  z_stream* GetHeaderCompressor(int index);
+  z_stream* GetHeaderDecompressor(int index);
   z_stream* GetStreamCompressor(SpdyStreamId id);
   z_stream* GetStreamDecompressor(SpdyStreamId id);
 
+  uint16 GetDictionaryIndex(const SpdyControlFrame& control_frame);
+
   // Compression helpers
   SpdyControlFrame* CompressControlFrame(const SpdyControlFrame& frame);
   SpdyDataFrame* CompressDataFrame(const SpdyDataFrame& frame);
   SpdyControlFrame* DecompressControlFrame(const SpdyControlFrame& frame);
   SpdyDataFrame* DecompressDataFrame(const SpdyDataFrame& frame);
   SpdyFrame* CompressFrameWithZStream(const SpdyFrame& frame,
                                       z_stream* compressor);
   SpdyFrame* DecompressFrameWithZStream(const SpdyFrame& frame,
                                         z_stream* decompressor);
   void CleanupCompressorForStream(SpdyStreamId id);
   void CleanupDecompressorForStream(SpdyStreamId id);
   void CleanupStreamCompressorsAndDecompressors();
+  void CleanupHeaderCompressorsAndDecompressors();
 
   // Not used (yet)
   size_t BytesSafeToRead() const;
 
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyError error);
 
   // Expands the control frame buffer to accomodate a particular payload size.
   void ExpandControlFrameBuffer(size_t size);
 
   // 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;
 
   int num_stream_compressors() const { return stream_compressors_.size(); }
   int num_stream_decompressors() const { return stream_decompressors_.size(); }
 
   SpdyState state_;
   SpdyError error_code_;
   size_t remaining_payload_;
   size_t remaining_control_payload_;
 
   char* current_frame_buffer_;
   size_t current_frame_len_;  // Number of bytes read into the current_frame_.
   size_t current_frame_capacity_;
 
   bool enable_compression_;  // Controls all compression
-  // SPDY header compressors.
-  scoped_ptr<z_stream> header_compressor_;
-  scoped_ptr<z_stream> header_decompressor_;
+
+  // SPDY header compressors (possbily per-stream when using SCTP).
+  CompressorMap header_compressors_;
+  CompressorMap header_decompressors_;
 
   // Per-stream data compressors.
   CompressorMap stream_compressors_;
   CompressorMap stream_decompressors_;
 
   SpdyFramerVisitorInterface* visitor_;
 
   static bool compression_default_;
   static int spdy_version_;
 };
 
 }  // namespace spdy
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_