Add chunked uploads support to SPDY

net/spdy/spdy_http_stream.cc

 // Copyright (c) 2010 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 <string>
 
@@ skipping 15 matching lines @@
     : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_factory_(this)),
       stream_(NULL),
       spdy_session_(spdy_session),
       response_info_(NULL),
       download_finished_(false),
       response_headers_received_(false),
       user_callback_(NULL),
       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;
   stream_->SetDelegate(this);
   response_headers_received_ = true;
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_)
     stream_->DetachDelegate();
@@ skipping 121 matching lines @@
 }
 
 bool SpdyHttpStream::IsConnectionReused() const {
   return spdy_session_->IsReused();
 }
 
 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,
                                 CompletionCallback* callback) {
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetDelegate(this);
 
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    headers.get(), direct_);
   stream_->set_spdy_headers(headers);
 
   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(!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;
   }
 
   CHECK(callback);
   CHECK(!stream_->cancelled());
   CHECK(response);
 
   if (!stream_->pushed() && stream_->closed()) {
@@ skipping 36 matching lines @@
 }
 
 bool SpdyHttpStream::OnSendHeadersComplete(int status) {
   if (user_callback_)
     DoCallback(status);
   return request_body_stream_.get() == NULL;
 }
 
 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;
+  bool is_chunked = request_body_stream_->is_chunked();
   return stream_->WriteStreamData(request_body_stream_->buf(), buf_len,

[willchan no longer on Chromium, 2011/02/01 23:35:59]

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...
You need to align your parameters on the second line.

[Satish, 2011/02/22 14:25:44]

Done.

-                                  spdy::DATA_FLAG_FIN);
+      is_chunked ? spdy::DATA_FLAG_NONE : spdy::DATA_FLAG_FIN);
 }
 
-bool SpdyHttpStream::OnSendBodyComplete(int status) {
+bool SpdyHttpStream::OnSendBodyComplete(int* status) {
   CHECK(request_body_stream_.get());
-  request_body_stream_->MarkConsumedAndFillBuffer(status);
-  return request_body_stream_->eof();
+
+  *status = OK;
+  if (send_last_chunk_)  // Indicates that the last chunk was SENT here.
+    return true;
+
+  request_body_stream_->MarkConsumedAndFillBuffer(*status);

[willchan no longer on Chromium, 2011/02/01 23:35:59]

I'm confused how this works. OK == 0. You set *status to OK a few lines before.
How does this ever make progress?

At this point, we've gone through enough of the design. You need to add tests to
show this stuff works.

[Satish, 2011/02/22 14:25:44]

This was a last minute copy/paste error, fixed now.

+
+  bool eof = request_body_stream_->eof();
+  if (request_body_stream_->is_chunked()) {
+    if (eof) {
+      send_last_chunk_ = true;
+      eof = false;
+    } else {
+      if (!request_body_stream_->buf_len())
+        *status = ERR_IO_PENDING;
+    }
+  }
+
+  return eof;
 }
 
 int SpdyHttpStream::OnResponseReceived(const spdy::SpdyHeaderBlock& response,
                                        base::Time response_time,
                                        int status) {
   if (!response_info_) {
     DCHECK(stream_->pushed());
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
@@ skipping 148 matching lines @@
   stream_->GetSSLInfo(ssl_info, &using_npn);
 }
 
 void SpdyHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
   stream_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 }  // namespace net