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

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 133 matching lines @@
   request_ = headers;
 }
 
 void SpdyStream::set_initial_recv_window_size(int32 window_size) {
   session_->set_initial_recv_window_size(window_size);
 }
 
 void SpdyStream::PossiblyResumeIfStalled() {
   if (send_window_size_ > 0 && stalled_by_flow_control_) {
     stalled_by_flow_control_ = false;
-    io_state_ = STATE_SEND_BODY;
+    if (delegate_->IsRequestBodyChunked())
+      io_state_ = STATE_SEND_CHUNKED_BODY;
+    else
+      io_state_ = STATE_SEND_BODY;
     DoLoop(OK);
   }
 }
 
 void SpdyStream::AdjustSendWindowSize(int32 delta_window_size) {
   send_window_size_ += delta_window_size;
   PossiblyResumeIfStalled();
 }
 
 void SpdyStream::IncreaseSendWindowSize(int32 delta_window_size) {
   DCHECK(session_->is_flow_control_enabled());
   DCHECK_GE(delta_window_size, 1);
 
   int32 new_window_size = send_window_size_ + delta_window_size;
 
   // We should ignore WINDOW_UPDATEs received before or after this state,
   // since before means we've not written SYN_STREAM yet (i.e. it's too
   // early) and after means we've written a DATA frame with FIN bit.
-  if (io_state_ != STATE_SEND_BODY_COMPLETE)
+  if (io_state_ != STATE_SEND_BODY_COMPLETE &&
+      io_state_ != STATE_SEND_CHUNKED_BODY &&
+      io_state_ != STATE_SEND_CHUNKED_BODY_COMPLETE) {
     return;

[Ryan Hamilton, 2012/07/02 22:34:32]

This still feels totally wrong to me.  I do not think it makes sense to silently
ignore this condition.  Either it should be an *error* to get WINDOW_UPDATE when
we don't expect it, or we should handle them.

[ramant (doing other things), 2012/07/04 21:04:33]

Done.

+  }
 
   // it's valid for send_window_size_ to become negative (via an incoming
   // SETTINGS), in which case incoming WINDOW_UPDATEs will eventually make
   // it positive; however, if send_window_size_ is positive and incoming
   // WINDOW_UPDATE makes it negative, we have an overflow.
   if (send_window_size_ > 0 && new_window_size < 0) {
     std::string desc = base::StringPrintf(
         "Received WINDOW_UPDATE [delta: %d] for stream %d overflows "
         "send_window_size_ [current: %d]", delta_window_size, stream_id_,
         send_window_size_);
@@ skipping 243 matching lines @@
 // This function is only called when an entire frame is written.
 void SpdyStream::OnWriteComplete(int bytes) {
   DCHECK_LE(0, bytes);
   send_bytes_ += bytes;
   if (cancelled() || closed())
     return;
   DoLoop(bytes);
 }
 
 void SpdyStream::OnChunkAvailable() {
-  DCHECK(io_state_ == STATE_SEND_HEADERS || io_state_ == STATE_SEND_BODY ||
-         io_state_ == STATE_SEND_BODY_COMPLETE);
-  if (io_state_ == STATE_SEND_BODY)
+  DCHECK(io_state_ == STATE_SEND_HEADERS ||
+         io_state_ == STATE_SEND_CHUNKED_BODY ||
+         io_state_ == STATE_SEND_CHUNKED_BODY_COMPLETE);
+  if (io_state_ == STATE_SEND_CHUNKED_BODY)
     OnWriteComplete(0);
 }
 
 int SpdyStream::GetProtocolVersion() const {
   return session_->GetProtocolVersion();
 }
 
 void SpdyStream::LogStreamError(int status, const std::string& description) {
   net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ERROR,
                     base::Bind(&NetLogSpdyStreamErrorCallback,
@@ skipping 104 matching lines @@
         CHECK_EQ(OK, result);
         result = DoSendHeaders();
         break;
       case STATE_SEND_HEADERS_COMPLETE:
         result = DoSendHeadersComplete(result);
         break;
       case STATE_SEND_BODY:
         CHECK_EQ(OK, result);
         result = DoSendBody();
         break;
+      case STATE_SEND_CHUNKED_BODY:
+        result = DoSendChunkedBody();
+        break;
+      case STATE_SEND_CHUNKED_BODY_COMPLETE:
+        result = DoSendChunkedBodyComplete(result);
+        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.
@@ skipping 113 matching lines @@
 
   if (!delegate_)
     return ERR_UNEXPECTED;
 
   // There is no body, skip that state.
   if (delegate_->OnSendHeadersComplete(result)) {
     io_state_ = STATE_WAITING_FOR_RESPONSE;
     return OK;
   }
 
-  io_state_ = STATE_SEND_BODY;
+  if (delegate_->IsRequestBodyChunked())
+    io_state_ = STATE_SEND_CHUNKED_BODY;
+  else
+    io_state_ = STATE_SEND_BODY;
   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() {
   // If we're already in the STATE_SENDING_BODY state, then we've already
   // sent a portion of the body.  In that case, we need to first consume
   // the bytes written in the body stream.  Note that the bytes written is
   // the number of bytes in the frame that were written, only consume the
@@ skipping 14 matching lines @@
   bool eof = false;
   result = delegate_->OnSendBodyComplete(result, &eof);
   if (!eof)
     io_state_ = STATE_SEND_BODY;
   else
     io_state_ = STATE_WAITING_FOR_RESPONSE;
 
   return result;
 }
 
+int SpdyStream::DoSendChunkedBody() {
+  io_state_ = STATE_SEND_CHUNKED_BODY_COMPLETE;
+  if (!delegate_)
+    return ERR_UNEXPECTED;
+  return delegate_->OnSendChunkedBody();
+}
+
+int SpdyStream::DoSendChunkedBodyComplete(int result) {
+  if (result < 0)
+    return result;
+
+  if (!delegate_)
+    return ERR_UNEXPECTED;
+
+  bool eof = false;
+  result = delegate_->OnSendChunkedBodyComplete(result, &eof);
+  if (!eof)
+    io_state_ = STATE_SEND_CHUNKED_BODY;
+  else
+    io_state_ = STATE_WAITING_FOR_RESPONSE;
+
+  return result;
+}
+
 int SpdyStream::DoOpen(int result) {
   if (delegate_)
     delegate_->OnDataSent(result);
   io_state_ = STATE_OPEN;
   return result;
 }
 
 void SpdyStream::UpdateHistograms() {
   // We need all timers to be filled in, otherwise metrics can be bogus.
   if (send_time_.is_null() || recv_first_byte_time_.is_null() ||
       recv_last_byte_time_.is_null())
     return;
 
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTimeToFirstByte",
       recv_first_byte_time_ - send_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net