[SPDY] Refactor SpdyStream::Delegate

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 53 matching lines @@
 // 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. 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 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;
+    virtual void OnRequestHeadersSent() = 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;
+    virtual int OnResponseHeadersReceived(const SpdyHeaderBlock& response,

[Ryan Hamilton, 2013/05/28 21:57:13]

Nice naming symmetry.

+                                          base::Time response_time,
+                                          int status) = 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() = 0;
 
     // Called when SpdyStream is closed. No other delegate functions
@@ skipping 12 matching lines @@
   SpdyStream(SpdyStreamType type,
              SpdySession* session,
              const std::string& path,
              RequestPriority priority,
              int32 initial_send_window_size,
              int32 initial_recv_window_size,
              const BoundNetLog& net_log);
 
   ~SpdyStream();
 
-  // Set new |delegate|. |delegate| must not be NULL.
-  // If it already received SYN_REPLY or data, OnResponseReceived() or
+  // Set new |delegate|. |delegate| must not be NULL.  If it already
+  // received SYN_REPLY or data, OnResponseHeadersReceived() 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();
 
   SpdyStreamType type() const { return type_; }
 
@@ skipping 95 matching lines @@
   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. This is the entry
   // point for a push stream. Returns a status code.
-  int OnResponseReceived(const SpdyHeaderBlock& response);
+  int OnResponseHeadersReceived(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.
+  // 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
+  // OnResponseHeadersReceived.
   //
   // |buffer| contains the data received, or NULL if the stream is
   //          being closed.  The stream must copy any data from this
   //          buffer before returning from this callback.
   //
   // |length| is the number of bytes received (at most 2^24 - 1) or 0 if
   //          the stream is being closed.
   void OnDataReceived(scoped_ptr<SpdyBuffer> buffer);
 
   // Called by the SpdySession when a frame has been successfully and
@@ skipping 27 matching lines @@
   // 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.
 
   // 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
+  // OnRequestHeadersSent() 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)

[Ryan Hamilton, 2013/05/28 21:57:13]

nit: I think this comment is out of date.

[akalin, 2013/05/28 22:11:04]

Fixed!

   // or OnDataSent() (if the response has been received) when the send
   // is complete. |send_status| must be MORE_DATA_TO_SEND for
   // bidirectional streams; for request/response streams, it must be
   // 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);
+  void SendData(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 167 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_