SPDY - chunked upload - speech recognition doesn't work with SPDY/3

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 <string>
 
@@ skipping 169 matching lines @@
 bool SpdyHttpStream::IsConnectionReusable() const {
   // SPDY streams aren't considered reusable.
   return false;
 }
 
 void SpdyHttpStream::set_chunk_callback(ChunkCallback* callback) {
   if (request_body_stream_ != NULL)
     request_body_stream_->set_chunk_callback(callback);
 }
 
+bool SpdyHttpStream::IsRequestBodyChunked() {
+  return request_body_stream_ != NULL && request_body_stream_->is_chunked();
+}
+
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 scoped_ptr<UploadDataStream> request_body,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetDelegate(this);
 
   linked_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
@@ skipping 64 matching lines @@
 }
 
 void SpdyHttpStream::Cancel() {
   if (spdy_session_)
     spdy_session_->CancelPendingCreateStreams(&stream_);
   callback_.Reset();
   if (stream_)
     stream_->Cancel();
 }
 
-bool SpdyHttpStream::OnSendHeadersComplete(int status) {
-  if (!callback_.is_null())
-    DoCallback(status);
-  return request_body_stream_.get() == NULL;
-}
-
-int SpdyHttpStream::OnSendBody() {
+int SpdyHttpStream::SendBody() {
   CHECK(request_body_stream_.get());
 
   // TODO(satorux): Clean up the logic here. This behavior is weird. Reading
   // of upload data should happen in OnSendBody(). crbug.com/113107.
   //
   // Nothing to send. This happens when OnSendBody() is first called.
   // A read of the upload data stream is initiated in OnSendBodyComplete().
   if (request_body_buf_->BytesRemaining() == 0)
     return OK;
 
   const bool eof = request_body_stream_->IsEOF();
   return stream_->WriteStreamData(
       request_body_buf_,
       request_body_buf_->BytesRemaining(),
       eof ? DATA_FLAG_FIN : DATA_FLAG_NONE);
 }
 
-int SpdyHttpStream::OnSendBodyComplete(int status, bool* eof) {
+int SpdyHttpStream::SendBodyComplete(int status, bool* eof) {
   // |status| is the number of bytes written to the SPDY stream.
   CHECK(request_body_stream_.get());
   *eof = false;
 
   if (status > 0) {
     request_body_buf_->DidConsume(status);
     if (request_body_buf_->BytesRemaining()) {
       // Go back to OnSendBody() to send the remaining data.
       return OK;
     }
@@ skipping 11 matching lines @@
   if (request_body_stream_->is_chunked() && bytes_read == ERR_IO_PENDING)
     return ERR_IO_PENDING;
   // ERR_IO_PENDING with chunked encoding is the only possible error.
   DCHECK_GE(bytes_read, 0);
 
   request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_,
                                             bytes_read);
   return OK;
 }
 
+bool SpdyHttpStream::OnSendHeadersComplete(int status) {
+  if (!callback_.is_null())
+    DoCallback(status);
+  return request_body_stream_.get() == NULL;
+}
+
+int SpdyHttpStream::OnSendBody() {
+  return SendBody();
+}
+
+int SpdyHttpStream::OnSendBodyComplete(int status, bool* eof) {
+  return SendBodyComplete(status, eof);
+}
+
+int SpdyHttpStream::OnSendChunkedBody() {
+  return OnSendBody();
+}
+
+int SpdyHttpStream::OnSendChunkedBodyComplete(int status, bool* eof) {
+  return OnSendBodyComplete(status, eof);
+}
+
 int SpdyHttpStream::OnResponseReceived(const 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();
   }
 
   // If the response is already received, these headers are too late.
@@ skipping 164 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net