[SPDY] Add a SpdyStreamType enum and use it for SpdyStream

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/bandwidth_metrics.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 #include "net/socket/ssl_client_socket.h"
+#include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_session.h"
 #include "net/ssl/server_bound_cert_service.h"
 #include "net/ssl/ssl_client_cert_type.h"
 
 namespace net {
 
 class AddressList;
 class IPEndPoint;
 class SSLCertRequestInfo;
 class SSLInfo;
+class SpdySession;
+
+enum SpdyStreamType {
+  // The most general type of stream; there are no restrictions on
+  // when data can be sent and received.
+  SPDY_BIDIRECTIONAL_STREAM,
+  // A stream where the client sends a request with possibly a body,
+  // and the server then sends a response with a body.
+  SPDY_REQUEST_RESPONSE_STREAM,
+  // A server-initiated stream where the server just sends a response
+  // with a body and the client does not send anything.
+  SPDY_PUSH_STREAM
+};
 
 // Returned by some SpdyStream::Delegate functions to indicate whether
 // there's more data to send.
 enum SpdySendStatus {
   MORE_DATA_TO_SEND,
   NO_MORE_DATA_TO_SEND
 };
 
 // The SpdyStream is used by the SpdySession to represent each stream known
 // on the SpdySession.  This class provides interfaces for SpdySession to use.
 // Streams can be created either by the client or by the server.  When they
 // are initiated by the client, both the SpdySession and client object (such as
 // a SpdyNetworkTransaction) will maintain a reference to the stream.  When
 // initiated by the server, only the SpdySession will maintain any reference,
 // until such a time as a client object requests a stream for the path.
 class NET_EXPORT_PRIVATE SpdyStream {
  public:
   // Delegate handles protocol specific behavior of spdy stream.
   class NET_EXPORT_PRIVATE Delegate {
    public:
     Delegate() {}
 
-    // Called when the request headers have been sent.  Must return
-    // whether there's body data to send.
-    //
-    // There's some redundancy in SendRequestHeaders() taking a
-    // SpdySendStatus and this function returning one, but it's
-    // necessary. Bidirectional streams always pass in
-    // MORE_DATA_TO_SEND to SendRequestHeaders() but must return
-    // NO_MORE_DATA_TO_SEND from OnSendRequestHeadersComplete(), while
-    // request/response streams always return the same value from
-    // OnSendRequestHeadersComplete() as the one they pass into
-    // SendRequestHeaders().
-    //
-    // TODO(akalin): Have a less subtle way of differentiating
-    // request/response streams from bidirectional ones.
-    virtual SpdySendStatus OnSendRequestHeadersComplete() = 0;
+    // Called when the request headers have been sent. Never called
+    // for push streams.
+    virtual void OnSendRequestHeadersComplete() = 0;
 
     // Called when the stream is ready to send body data.  The
     // delegate must call SendStreamData() on the stream, either
     // immediately or asynchronously (e.g., if the data to be send has
     // to be read asynchronously).
     //
-    // Called only when OnSendRequestHeadersComplete() or
-    // OnSendBodyComplete() returns MORE_DATA_TO_SEND.
+    // Called only for request/response streams when
+    // SendRequestHeaders() is called with MORE_DATA_TO_SEND.
+    //
+    // TODO(akalin): Unify this with OnSendRequestHeadersComplete().
     virtual void OnSendBody() = 0;
 
     // Called when body data has been sent.
+    //
+    // TODO(akalin): Unify this with OnDataSent().
     virtual void OnSendBodyComplete() = 0;
 
     // Called when the SYN_STREAM, SYN_REPLY, or HEADERS frames are received.
     // Normal streams will receive a SYN_REPLY and optional HEADERS frames.
     // Pushed streams will receive a SYN_STREAM and optional HEADERS frames.
     // Because a stream may have a SYN_* frame and multiple HEADERS frames,
     // this callback may be called multiple times.
     // |status| indicates network error. Returns network error code.
     virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                    base::Time response_time,
@@ skipping 13 matching lines @@
     virtual void OnClose(int status) = 0;
 
    protected:
     virtual ~Delegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // SpdyStream constructor
-  SpdyStream(SpdySession* session,
+  SpdyStream(SpdyStreamType type,
+             SpdySession* session,
              const std::string& path,
              RequestPriority priority,
              int32 initial_send_window_size,
              int32 initial_recv_window_size,
-             bool pushed,
              const BoundNetLog& net_log);
 
   ~SpdyStream();
 
   // Set new |delegate|. |delegate| must not be NULL.
   // If it already received SYN_REPLY or data, OnResponseReceived() or
   // OnDataReceived() will be called.
   void SetDelegate(Delegate* delegate);
   Delegate* GetDelegate() { return delegate_; }
 
   // Detach the delegate from the stream, which must not yet be
   // closed, and cancel it.
   void DetachDelegate();
 
-  // Is this stream a pushed stream from the server.
-  bool pushed() const { return pushed_; }
+  SpdyStreamType type() const { return type_; }
 
   SpdyStreamId stream_id() const { return stream_id_; }
   void set_stream_id(SpdyStreamId stream_id) { stream_id_ = stream_id; }
 
   bool response_received() const { return response_received_; }
   void set_response_received() { response_received_ = true; }
 
-  // For pushed streams, we track a path to identify them.
   const std::string& path() const { return path_; }
 
   RequestPriority priority() const { return priority_; }
 
   int32 send_window_size() const { return send_window_size_; }
 
   int32 recv_window_size() const { return recv_window_size_; }
 
   bool send_stalled_by_flow_control() const {
     return send_stalled_by_flow_control_;
@@ skipping 76 matching lines @@
 
   // Returns true if the underlying transport socket ever had any reads or
   // writes.
   bool WasEverUsed() const;
 
   const BoundNetLog& net_log() const { return net_log_; }
 
   base::Time GetRequestTime() const;
   void SetRequestTime(base::Time t);
 
-  // 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.
+  // Called by the SpdySession when a response (e.g. a SYN_STREAM or
+  // SYN_REPLY) has been received for this stream. This is the entry
+  // point for a push stream. Returns a status code.
   int OnResponseReceived(const SpdyHeaderBlock& response);
 
   // Called by the SpdySession when late-bound headers are received for a
   // stream. Returns a status code.
   int OnHeaders(const 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
   // from the network, and will never be called prior to OnResponseReceived.
   //
@@ skipping 31 matching lines @@
   // Returns whether or not this stream is closed. Note that the only
   // time a stream is closed and not deleted is in its delegate's
   // OnClose() method.
   bool closed() const { return io_state_ == STATE_DONE; }
 
   // TODO(satorux): This is only for testing. We should be able to remove
   // this once crbug.com/113107 is addressed.
   bool body_sent() const { return io_state_ > STATE_SEND_BODY_COMPLETE; }
 
   // Interface for the delegate to use.
-  //
-  // TODO(akalin): Mandate that only one send can be in flight at one
-  // time.
 
-  // Sends the request headers.
-  // For non push stream, it will send SYN_STREAM frame.
+  // Only one send can be in flight at a time, except for push
+  // streams, which must not send anything.
+
+  // Sends the request headers. The delegate is called back via
+  // OnSendRequestHeadersComplete() when the request headers have
+  // completed sending. |send_status| must be MORE_DATA_TO_SEND for
+  // bidirectional streams; for request/response streams, it must be
+  // MORE_DATA_TO_SEND if the request has data to upload, or
+  // NO_MORE_DATA_TO_SEND if not.
   int SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
                          SpdySendStatus send_status);
 
   // Sends a DATA frame. The delegate will be notified via
   // OnSendBodyComplete() (if the response hasn't been received yet)
   // or OnDataSent() (if the response has been received) when the send
-  // is complete. Only one data send can be in flight at one time.
+  // is complete. |send_status| must be MORE_DATA_TO_SEND for
+  // bidirectional streams; for request/response streams, it must be

[Ryan Hamilton, 2013/05/26 15:33:49]

What if a bidirectional stream knew (because of some higher level protocol) that
this was in-fact the last data it would send.  Could it use
NO_MORE_DATA_TO_SEND?

[akalin, 2013/05/27 08:13:35]

Yeah, I think we eventually want to allow that. For now, I'm just matching the
current behavior as closely as possible.

+  // MORE_DATA_TO_SEND if there is more data to upload, or
+  // NO_MORE_DATA_TO_SEND if not.
   void SendStreamData(IOBuffer* data, int length, SpdySendStatus send_status);
 
   // Fills SSL info in |ssl_info| and returns true when SSL is in use.
   bool GetSSLInfo(SSLInfo* ssl_info,
                   bool* was_npn_negotiated,
                   NextProto* protocol_negotiated);
 
   // Fills SSL Certificate Request info |cert_request_info| and returns
   // true when SSL is in use.
   bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
@@ skipping 82 matching lines @@
   // Produce the initial HEADER frame for the stream with the given
   // block. The stream must already be activated.
   scoped_ptr<SpdyFrame> ProduceHeaderFrame(
       scoped_ptr<SpdyHeaderBlock> header_block);
 
   // Queues the send for next frame of the remaining data in
   // |pending_send_data_|. Must be called only when
   // |pending_send_data_| and |pending_send_flags_| are set.
   void QueueNextDataFrame();
 
+  const SpdyStreamType type_;
+
   base::WeakPtrFactory<SpdyStream> weak_ptr_factory_;
 
   // Sentinel variable used to make sure we don't get destroyed by a
   // function called from DoLoop().
   bool in_do_loop_;
 
   // There is a small period of time between when a server pushed stream is
   // first created, and the pushed data is replayed. Any data received during
   // this time should continue to be buffered.
   bool continue_buffering_data_;
 
   SpdyStreamId stream_id_;
   const std::string path_;
   const RequestPriority priority_;
   size_t slot_;
 
   // Flow control variables.
   bool send_stalled_by_flow_control_;
   int32 send_window_size_;
   int32 recv_window_size_;
   int32 unacked_recv_window_bytes_;
 
-  const bool pushed_;
   ScopedBandwidthMetrics metrics_;
   bool response_received_;
 
   scoped_refptr<SpdySession> session_;
 
   // The transaction should own the delegate.
   SpdyStream::Delegate* delegate_;
 
   // Whether or not we have more data to send on this stream.
   SpdySendStatus send_status_;
 
   // The headers for the request to send.
+  //
+  // TODO(akalin): Hang onto this only until we send it. This
+  // necessitates stashing the URL separately.
   scoped_ptr<SpdyHeaderBlock> request_;
 
   // The data waiting to be sent.
   scoped_refptr<DrainableIOBuffer> pending_send_data_;
 
   // 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_;
 
   scoped_ptr<SpdyHeaderBlock> response_;
@@ skipping 27 matching lines @@
   // When OnFrameWriteComplete() is called, these variables are set.
   SpdyFrameType just_completed_frame_type_;
   size_t just_completed_frame_size_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_