[SPDY] Refactor SpdyStream::Delegate

net/spdy/spdy_http_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_http_stream.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 namespace net {
 
 SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session,
                                bool direct)
     : weak_factory_(this),
       spdy_session_(spdy_session),
       stream_closed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       request_info_(NULL),
-      has_upload_data_(false),
       response_info_(NULL),
       response_headers_received_(false),
       user_buffer_len_(0),
-      raw_request_body_buf_size_(0),
+      request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct) {}
 
 void SpdyHttpStream::InitializeWithExistingStream(
     const base::WeakPtr<SpdyStream>& spdy_stream) {
   stream_ = spdy_stream;
   stream_->SetDelegate(this);
   response_headers_received_ = true;
 }
@@ skipping 40 matching lines @@
   }
 
   return rv;
 }
 
 const HttpResponseInfo* SpdyHttpStream::GetResponseInfo() const {
   return response_info_;
 }
 
 UploadProgress SpdyHttpStream::GetUploadProgress() const {
-  if (!request_info_ || !request_info_->upload_data_stream)
+  if (!HasUploadData())
     return UploadProgress();
 
   return UploadProgress(request_info_->upload_data_stream->position(),
                         request_info_->upload_data_stream->size());
 }
 
 int SpdyHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(!callback.is_null());
   if (stream_closed_)
     return closed_stream_status_;
@@ skipping 100 matching lines @@
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
-  CHECK(!has_upload_data_);
-  has_upload_data_ = request_info_->upload_data_stream &&
-      (request_info_->upload_data_stream->size() ||
-       request_info_->upload_data_stream->is_chunked());
-  if (has_upload_data_) {
+  CHECK(!request_body_buf_);
+  if (HasUploadData()) {
     // Use kMaxSpdyFrameChunkSize as the buffer size, since the request
     // body data is written with this size at a time.
-    raw_request_body_buf_ = new IOBufferWithSize(kMaxSpdyFrameChunkSize);
+    request_body_buf_ = new IOBufferWithSize(kMaxSpdyFrameChunkSize);
     // The request body buffer is empty at first.
-    raw_request_body_buf_size_ = 0;
+    request_body_buf_size_ = 0;
   }
 
   CHECK(!callback.is_null());
   CHECK(response);
 
   // SendRequest can be called in two cases.
   //
   // a) A client initiated request. In this case, |response_info_| should be
   //    NULL to start with.
   // b) A client request which matches a response that the server has already
@@ skipping 25 matching lines @@
     CreateSpdyHeadersFromHttpRequest(
         *request_info_, request_headers,
         headers.get(), stream_->GetProtocolVersion(),
         direct_);
     stream_->net_log().AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
     result =
         stream_->SendRequestHeaders(
             headers.Pass(),
-            has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
+            HasUploadData() ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
   }
 
   if (result == ERR_IO_PENDING) {
     CHECK(callback_.is_null());
     callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
   callback_.Reset();
   if (stream_) {
     stream_->Cancel();
     DCHECK(!stream_);
   }
 }
 
-void SpdyHttpStream::OnSendRequestHeadersComplete() {
+void SpdyHttpStream::OnRequestHeadersSent() {
   if (!callback_.is_null())
     DoCallback(OK);
+
+  if (HasUploadData())
+    ReadAndSendRequestBodyData();
 }
 
-void SpdyHttpStream::OnSendBody() {
-  CHECK(request_info_ && request_info_->upload_data_stream);
-  if (raw_request_body_buf_size_ > 0) {
-    SendRequestBodyData();
-  } else {
-    // We shouldn't be called if there's no more data to read.
-    CHECK(!request_info_->upload_data_stream->IsEOF());
-    ReadAndSendRequestBodyData();
-  }
-}
-
-void SpdyHttpStream::OnSendBodyComplete() {
-  // |status| is the number of bytes written to the SPDY stream.
-  CHECK(request_info_ && request_info_->upload_data_stream);
-  raw_request_body_buf_size_ = 0;
-}
-
-int SpdyHttpStream::OnResponseReceived(const SpdyHeaderBlock& response,
-                                       base::Time response_time,
-                                       int status) {
+int SpdyHttpStream::OnResponseHeadersReceived(const SpdyHeaderBlock& response,
+                                              base::Time response_time,
+                                              int status) {
   if (!response_info_) {
     DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
 
   // If the response is already received, these headers are too late.
   if (response_headers_received_) {
     LOG(WARNING) << "SpdyHttpStream headers received after response started.";
     return OK;
@@ skipping 62 matching lines @@
     if (user_buffer_) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
     }
   }
   return OK;
 }
 
 void SpdyHttpStream::OnDataSent() {
-  // For HTTP streams, no data is sent from the client while in the OPEN state,
-  // so it is never called.
-  CHECK(false);
+  request_body_buf_size_ = 0;
+  ReadAndSendRequestBodyData();
 }
 
 void SpdyHttpStream::OnClose(int status) {
   if (stream_) {
     stream_closed_ = true;
     closed_stream_status_ = status;
     closed_stream_id_ = stream_->stream_id();
   }
   stream_.reset();
   bool invoked_callback = false;
   if (status == net::OK) {
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
   if (!invoked_callback && !callback_.is_null())
     DoCallback(status);
 }
 
+bool SpdyHttpStream::HasUploadData() const {
+  CHECK(request_info_);
+  return
+      request_info_->upload_data_stream &&
+      ((request_info_->upload_data_stream->size() > 0) ||
+       request_info_->upload_data_stream->is_chunked());
+}
+
 void SpdyHttpStream::OnStreamCreated(
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK) {
     stream_ = stream_request_.ReleaseStream();
     stream_->SetDelegate(this);
   }
   callback.Run(rv);
 }
 
 void SpdyHttpStream::ReadAndSendRequestBodyData() {
-  CHECK(request_info_ && request_info_->upload_data_stream);
-  CHECK_EQ(raw_request_body_buf_size_, 0);
+  CHECK(HasUploadData());
+  CHECK_EQ(request_body_buf_size_, 0);
+
+  if (request_info_->upload_data_stream->IsEOF())
+    return;
 
   // Read the data from the request body stream.
   const int rv = request_info_->upload_data_stream->Read(
-      raw_request_body_buf_, raw_request_body_buf_->size(),
+      request_body_buf_, request_body_buf_->size(),
       base::Bind(
           &SpdyHttpStream::OnRequestBodyReadCompleted,
           weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     // ERR_IO_PENDING is the only possible error.
     CHECK_GE(rv, 0);
     OnRequestBodyReadCompleted(rv);
   }
 }
 
 void SpdyHttpStream::OnRequestBodyReadCompleted(int status) {
   CHECK_GE(status, 0);
-  raw_request_body_buf_size_ = status;
-  SendRequestBodyData();
-}
-
-void SpdyHttpStream::SendRequestBodyData() {
+  request_body_buf_size_ = status;
   const bool eof = request_info_->upload_data_stream->IsEOF();
   if (eof) {
-    CHECK_GE(raw_request_body_buf_size_, 0);
+    CHECK_GE(request_body_buf_size_, 0);
   } else {
-    CHECK_GT(raw_request_body_buf_size_, 0);
+    CHECK_GT(request_body_buf_size_, 0);
   }
-  stream_->SendStreamData(raw_request_body_buf_,
-                          raw_request_body_buf_size_,
-                          eof ? NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND);
+  stream_->SendData(request_body_buf_,
+                    request_body_buf_size_,
+                    eof ? NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND);
 }
 
 void SpdyHttpStream::ScheduleBufferedReadCallback() {
   // If there is already a scheduled DoBufferedReadCallback, don't issue
   // another one.  Mark that we have received more data and return.
   if (buffered_read_callback_pending_) {
     more_read_data_pending_ = true;
     return;
   }
 
@@ skipping 78 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net