[SPDY] Change SpdyStream::QueueStreamData() To SendStreamData()

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>
@@ skipping 38 matching lines @@
 // 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 SYN frame has been sent.
-    // Returns true if no more data to be sent after SYN frame.
+    // Called when SYN frame has been sent.  Must return whether
+    // there's body data to send.
     virtual SpdySendStatus OnSendHeadersComplete() = 0;
 
     // Called when the stream is ready to send body data.  The
-    // delegate must call QueueStreamData() on the stream, either
+    // 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 OnSendHeadersComplete() or
     // OnSendBodyComplete() returns MORE_DATA_TO_SEND.
     virtual void OnSendBody() = 0;
 
-    // Called when body data has been sent. |bytes_sent| is the number
-    // of bytes that has been sent (may be zero). Must return whether
+    // Called when body data has been sent. Must return whether
     // there's more body data to send.
-    virtual SpdySendStatus OnSendBodyComplete(size_t bytes_sent) = 0;
+    virtual SpdySendStatus 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,
                                    int status) = 0;
 
     // Called when a HEADERS frame is sent.
     virtual void OnHeadersSent() = 0;
 
     // Called when data is received. |buffer| may be NULL, which
     // signals EOF.  Must return OK if the data was received
     // successfully, or a network error code otherwise.
     virtual int OnDataReceived(scoped_ptr<SpdyBuffer> buffer) = 0;
 
     // Called when data is sent.
-    virtual void OnDataSent(size_t bytes_sent) = 0;
+    virtual void OnDataSent() = 0;
 
     // Called when SpdyStream is closed. No other delegate functions
     // will be called after this is called, and the delegate must not
     // access the stream after this is called.
     virtual void OnClose(int status) = 0;
 
    protected:
     virtual ~Delegate() {}
 
    private:
@@ skipping 174 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 Spdy[Http|WebSocket]Stream to use.
+  // Interface for the delegate to use.
+  //
+  // TODO(akalin): Mandate that only one send can be in flight at one
+  // time.
 
   // Sends the request.
   // For non push stream, it will send SYN_STREAM frame.
   int SendRequest(bool has_upload_data);
 
-  // Queues a HEADERS frame to be sent.
-  void QueueHeaders(scoped_ptr<SpdyHeaderBlock> headers);
+  // Sends a HEADERS frame. The delegate will be notified via
+  // OnHeadersSent() when the send is complete.
+  void SendHeaders(scoped_ptr<SpdyHeaderBlock> headers);
 
-  // Queues a DATA frame to be sent. May not queue all the data that
-  // is given (or even any of it) depending on flow control.
-  void QueueStreamData(IOBuffer* data, int length,
-                       SpdyDataFlags flags);
+  // 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.
+  //
+  // |flags| must be DATA_FLAG_NONE except for the last piece of data
+  // for a request in a request/response stream, where it should be
+  // DATA_FLAG_FIN.
+  void SendStreamData(IOBuffer* data, int length, SpdyDataFlags flags);
 
   // 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 69 matching lines @@
 
   // Produces the SYN_STREAM frame for the stream. The stream must
   // already be activated.
   scoped_ptr<SpdyFrame> ProduceSynStreamFrame();
 
   // 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();
+
   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_;
@@ skipping 14 matching lines @@
   bool response_received_;
 
   scoped_refptr<SpdySession> session_;
 
   // The transaction should own the delegate.
   SpdyStream::Delegate* delegate_;
 
   // The request to send.
   scoped_ptr<SpdyHeaderBlock> request_;
 
+  // The data waiting to be sent.
+  scoped_refptr<DrainableIOBuffer> pending_send_data_;
+  SpdyDataFlags pending_send_flags_;
+
   // 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_;
   base::Time response_time_;
 
   State io_state_;
 
   // Since we buffer the response, we also buffer the response status.
@@ skipping 24 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_