[SPDY] Refactor SpdyStream::Delegate

net/spdy/spdy_stream.cc

 // 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.
 
 #include "net/spdy/spdy_stream.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 126 matching lines @@
 void SpdyStream::PushedStreamReplayData() {
   DCHECK_NE(stream_id_, 0u);
 
   if (!delegate_)
     return;
 
   continue_buffering_data_ = false;
 
   // TODO(akalin): This call may delete this object. Figure out what
   // to do in that case.
-  int rv = delegate_->OnResponseReceived(*response_, response_time_, OK);
+  int rv = delegate_->OnResponseHeadersReceived(*response_, response_time_, OK);
   if (rv == ERR_INCOMPLETE_SPDY_HEADERS) {
     // We don't have complete headers.  Assume we're waiting for another
     // HEADERS frame.  Since we don't have headers, we had better not have
     // any pending data frames.
     if (pending_buffers_.size() != 0U) {
       LogStreamError(ERR_SPDY_PROTOCOL_ERROR,
                      "HEADERS incomplete headers, but pending data frames.");
       session_->CloseActiveStream(stream_id_, ERR_SPDY_PROTOCOL_ERROR);
     }
     return;
@@ skipping 203 matching lines @@
 }
 
 base::Time SpdyStream::GetRequestTime() const {
   return request_time_;
 }
 
 void SpdyStream::SetRequestTime(base::Time t) {
   request_time_ = t;
 }
 
-int SpdyStream::OnResponseReceived(const SpdyHeaderBlock& response) {
+int SpdyStream::OnResponseHeadersReceived(const SpdyHeaderBlock& response) {
   int rv = OK;
 
   metrics_.StartStream();
 
   DCHECK(response_->empty());
   *response_ = response;  // TODO(ukai): avoid copy.
 
   recv_first_byte_time_ = base::TimeTicks::Now();
   response_time_ = base::Time::Now();
 
@@ skipping 17 matching lines @@
   }
 
   if ((*response_).find("transfer-encoding") != (*response_).end()) {
     session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   if (delegate_) {
     // May delete this object.
-    rv = delegate_->OnResponseReceived(*response_, response_time_, rv);
+    rv = delegate_->OnResponseHeadersReceived(*response_, response_time_, rv);
   }
-  // If delegate_ is not yet attached, we'll call OnResponseReceived after the
-  // delegate gets attached to the stream.
+  // If delegate_ is not yet attached, we'll call
+  // OnResponseHeadersReceived after the delegate gets attached to the
+  // stream.
 
   return rv;
 }
 
 int SpdyStream::OnHeaders(const SpdyHeaderBlock& headers) {
   DCHECK(!response_->empty());
 
   // Append all the headers into the response header block.
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
       it != headers.end(); ++it) {
@@ skipping 16 matching lines @@
 
   if ((*response_).find("transfer-encoding") != (*response_).end()) {
     session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   int rv = OK;
   if (delegate_) {
     // May delete this object.
-    rv = delegate_->OnResponseReceived(*response_, response_time_, rv);
+    rv = delegate_->OnResponseHeadersReceived(*response_, response_time_, rv);
     // ERR_INCOMPLETE_SPDY_HEADERS means that we are waiting for more
     // headers before the response header block is complete.
     if (rv == ERR_INCOMPLETE_SPDY_HEADERS)
       rv = OK;
   }
   return rv;
 }
 
 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   DCHECK(session_->IsStreamActive(stream_id_));
@@ skipping 109 matching lines @@
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_);
   CHECK(!pending_send_data_);
   CHECK_EQ(io_state_, STATE_NONE);
   request_ = headers.Pass();
   send_status_ = send_status;
   io_state_ = STATE_GET_DOMAIN_BOUND_CERT;
   return DoLoop(OK);
 }
 
-void SpdyStream::SendStreamData(IOBuffer* data,
-                                int length,
-                                SpdySendStatus send_status) {
+void SpdyStream::SendData(IOBuffer* data,
+                          int length,
+                          SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK_GE(io_state_, STATE_SEND_BODY);
   CHECK(!pending_send_data_);
   pending_send_data_ = new DrainableIOBuffer(data, length);
   send_status_ = send_status;
   QueueNextDataFrame();
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info,
@@ skipping 68 matching lines @@
         result = DoSendDomainBoundCertComplete(result);
         break;
       case STATE_SEND_REQUEST_HEADERS:
         CHECK_EQ(result, OK);
         result = DoSendRequestHeaders();
         break;
       case STATE_SEND_REQUEST_HEADERS_COMPLETE:
         CHECK_EQ(result, OK);
         result = DoSendRequestHeadersComplete();
         break;
+      // TODO(akalin): Remove the states STATE_SEND_BODY through
+      // STATE_WAITING_FOR_RESPONSE; we can infer correct behavior
+      // from |type_| and |send_status_|.
       case STATE_SEND_BODY:
         CHECK_EQ(result, OK);
         result = DoSendBody();
         break;
       case STATE_SEND_BODY_COMPLETE:
         result = DoSendBodyComplete(result);
         break;
       // This is an intermediary waiting state. This state is reached when all
       // data has been sent, but no data has been received.
       case STATE_WAITING_FOR_RESPONSE:
         io_state_ = STATE_WAITING_FOR_RESPONSE;
         result = ERR_IO_PENDING;
         break;
       // State machine 2: connection is established.
-      // In STATE_OPEN, OnResponseReceived has already been called.
+      // In STATE_OPEN, OnResponseHeadersReceived has already been called.
       // OnDataReceived, OnClose and OnFrameWriteComplete can be called.
       // Only OnFrameWriteComplete calls DoLoop().
       //
       // For HTTP streams, no data is sent from the client while in the OPEN
       // state, so OnFrameWriteComplete is never called here.  The HTTP body is
       // handled in the OnDataReceived callback, which does not call into
       // DoLoop.
       //
       // For WebSocket streams, which are bi-directional, we'll send and
       // receive data once the connection is established.  Received data is
@@ skipping 114 matching lines @@
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendRequestHeadersComplete() {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
   DCHECK_EQ(just_completed_frame_type_, SYN_STREAM);
   DCHECK_NE(stream_id_, 0u);
   if (!delegate_)
     return ERR_UNEXPECTED;
 
-  delegate_->OnSendRequestHeadersComplete();
-
   switch (type_) {
     case SPDY_BIDIRECTIONAL_STREAM:
       DCHECK_EQ(send_status_, MORE_DATA_TO_SEND);
       io_state_ = STATE_WAITING_FOR_RESPONSE;
       break;
 
     case SPDY_REQUEST_RESPONSE_STREAM:
       io_state_ =
           (send_status_ == MORE_DATA_TO_SEND) ?
           STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
       break;
 
     case SPDY_PUSH_STREAM:
       // Fall through.
     default:
       NOTREACHED();
       return ERR_UNEXPECTED;
   }
 
+  delegate_->OnRequestHeadersSent();
+
   return OK;
 }
 
 // DoSendBody is called to send the optional body for the request.  This call
 // will also be called as each write of a chunk of the body completes.
 int SpdyStream::DoSendBody() {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
   io_state_ = STATE_SEND_BODY_COMPLETE;
-  CHECK(delegate_);
-  delegate_->OnSendBody();
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendBodyComplete(int result) {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
   result = ProcessJustCompletedFrame(result, STATE_SEND_BODY_COMPLETE);
 
   if (result != OK)
     return result;
 
-  delegate_->OnSendBodyComplete();
-
   io_state_ =
       (send_status_ == MORE_DATA_TO_SEND) ?
       STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
 
+  delegate_->OnDataSent();
+
   return OK;
 }
 
 int SpdyStream::DoOpen() {
   int result = ProcessJustCompletedFrame(OK, STATE_OPEN);
 
   if (result != OK)
     return result;
 
   // Set |io_state_| first as |delegate_| may check it.
@@ skipping 108 matching lines @@
                    GetWeakPtr(), payload_size));
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 }  // namespace net