Add chunked uploads support to SPDY

net/spdy/spdy_http_stream.cc

Index: net/spdy/spdy_http_stream.cc
diff --git a/net/spdy/spdy_http_stream.cc b/net/spdy/spdy_http_stream.cc
index 6a6abb241f84a1bd83a07c0d3ae822a3a1ffdae4..5263c82a02e57639463cb1a1c9bc4c42ce56967c 100644
--- a/net/spdy/spdy_http_stream.cc
+++ b/net/spdy/spdy_http_stream.cc
@@ -33,7 +33,8 @@ SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session,
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
-      direct_(direct) { }
+      direct_(direct),
+      send_last_chunk_(false) { }
 
 void SpdyHttpStream::InitializeWithExistingStream(SpdyStream* spdy_stream) {
   stream_ = spdy_stream;
@@ -175,6 +176,11 @@ void SpdyHttpStream::SetConnectionReused() {
   // SPDY doesn't need an indicator here.
 }
 
+void SpdyHttpStream::set_chunk_callback(ChunkCallback* callback) {
+  if (request_body_stream_ != NULL)
+    request_body_stream_->set_chunk_callback(callback);
+}
+
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 UploadDataStream* request_body,
                                 HttpResponseInfo* response,
@@ -198,7 +204,7 @@ int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
 
   CHECK(!request_body_stream_.get());
   if (request_body) {
-    if (request_body->size())
+    if (request_body->size() || request_body->is_chunked())
       request_body_stream_.reset(request_body);
     else
       delete request_body;
@@ -255,17 +261,40 @@ bool SpdyHttpStream::OnSendHeadersComplete(int status) {
 
 int SpdyHttpStream::OnSendBody() {
   CHECK(request_body_stream_.get());
+  if (send_last_chunk_) {
+    return stream_->WriteStreamData(request_body_stream_->buf(), 0,
+                                    spdy::DATA_FLAG_FIN);
+  }
+
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
   if (!buf_len)
     return OK;
-  return stream_->WriteStreamData(request_body_stream_->buf(), buf_len,
-                                  spdy::DATA_FLAG_FIN);
+  bool is_chunked = request_body_stream_->is_chunked();
+  return stream_->WriteStreamData(
+      request_body_stream_->buf(), buf_len,
+      is_chunked ? spdy::DATA_FLAG_NONE : spdy::DATA_FLAG_FIN);
 }
 
-bool SpdyHttpStream::OnSendBodyComplete(int status) {
+int SpdyHttpStream::OnSendBodyComplete(int status, bool* eof) {
   CHECK(request_body_stream_.get());
+
+  if (send_last_chunk_) {  // Indicates that the last chunk was SENT here.
+    *eof = true;
+    return OK;

[willchan no longer on Chromium, 2011/02/24 19:41:34]

You should probably add a
if (status != 0) {
  NOTREACHED();
  return ERR_UNEXPECTED;
}

+  }
+
   request_body_stream_->MarkConsumedAndFillBuffer(status);
-  return request_body_stream_->eof();
+  *eof = false;

[willchan no longer on Chromium, 2011/02/24 19:41:34]

Er, does this work for the non-chunked case? When will *eof = true be set in the
non-chunked case? Do we have a test covering this? If not, please add one.

[willchan no longer on Chromium, 2011/03/02 18:44:40]

Was there a test? Or did you add one?

[Satish, 2011/03/03 13:50:10]

I added 2 unit tests and they cover this code path as well. This code has also
been greatly simplified in the latest patch.

+  if (request_body_stream_->is_chunked()) {
+    if (request_body_stream_->eof()) {
+      send_last_chunk_ = true;
+    } else {
+      if (!request_body_stream_->buf_len())
+        return ERR_IO_PENDING;
+    }
+  }
+
+  return OK;
 }
 
 int SpdyHttpStream::OnResponseReceived(const spdy::SpdyHeaderBlock& response,