Attn: Mike Belshe

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 147 matching lines @@
   // negative, since that would be a flow control violation.
   void DecreaseRecvWindowSize(int delta_window_size);
 
   const BoundNetLog& net_log() const { return net_log_; }
 
   const linked_ptr<spdy::SpdyHeaderBlock>& spdy_headers() const;
   void set_spdy_headers(const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   base::Time GetRequestTime() const;
   void SetRequestTime(base::Time t);
 
+  // TODO(jtl): Can we replace syn_reply_received_ with response_received_?
+  // The following methods are needed when using SCTP without multiple
+  // dictionaries (all SDPY control frames sent on SCTP stream 0), to handle the
+  // case where data arrives ahead of the SYN_REPLY.
+  bool syn_reply_received() { return syn_reply_received_; }
+  void set_syn_reply_received() { syn_reply_received_ = true; }
+  bool metrics_started() { return metrics_started_; }
+  void set_metrics_started() { metrics_started_ = true; }
+  bool close_pending() { return close_pending_; }
+  void set_close_pending() { close_pending_ = true; }
+
+  // Returns true if the underlying socket's transport protocol is SCTP.
+  bool using_sctp();
+
+  // Returns true if the underlying socket's transport protocol is SCTP and SPDY
+  // control frames are being sent on SCTP stream 0.
+  bool using_sctp_control_stream();
+
   // Called by the SpdySession when a response (e.g. a SYN_STREAM or SYN_REPLY)
   // has been received for this stream. Returns a status code.
   int OnResponseReceived(const spdy::SpdyHeaderBlock& response);
 
   // Called by the SpdySession when late-bound headers are received for a
   // stream. Returns a status code.
   int OnHeaders(const spdy::SpdyHeaderBlock& headers);
 
   // Called by the SpdySession when response data has been received for this
   // stream.  This callback may be called multiple times as data arrives
@@ skipping 115 matching lines @@
   // The request to send.
   linked_ptr<spdy::SpdyHeaderBlock> request_;
 
   // The time at which the request was made that resulted in this response.
   // For cached responses, this time could be "far" in the past.
   base::Time request_time_;
 
   linked_ptr<spdy::SpdyHeaderBlock> response_;
   base::Time response_time_;
 
+  // When using SCTP without multiple dictionaries, control frames are sent on
+  // a control stream (SCTP stream 0).  In the even of loss, data frames may
+  // arrive prior to the SYN_REPLY.  We need to delay processing of data frames
+  // until the SYN_REPLY has been received
+  bool syn_reply_received_;
+  // When DATA can be received prior to the SYN_REPLY, we need to be able to
+  // start metrics on either the SYN_REPLY or the first DATA frame.  We also
+  // need to know if it's already been started to avoid starting it a second
+  // time.
+  bool metrics_started_;
+  // If all data has arrived prior to the SYN_REPLY, we need to postpone closing
+  // the stream until the SYN_REPLY arrives.
+  bool close_pending_;
+
   State io_state_;
 
   // Since we buffer the response, we also buffer the response status.
   // Not valid until the stream is closed.
   int response_status_;
 
   bool cancelled_;
   bool has_upload_data_;
 
   BoundNetLog net_log_;
 
   base::TimeTicks send_time_;
   base::TimeTicks recv_first_byte_time_;
   base::TimeTicks recv_last_byte_time_;
   int send_bytes_;
   int recv_bytes_;
   // Data received before delegate is attached.
   std::vector<scoped_refptr<IOBufferWithSize> > pending_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_