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 110 matching lines @@
     } else {
       delegate_->OnDataReceived(NULL, 0);
       session_->CloseStream(stream_id_, net::OK);
       // Note: |this| may be deleted after calling CloseStream.
       DCHECK_EQ(buffers.size() - 1, i);
     }
   }
 }
 
 void SpdyStream::DetachDelegate() {
-  if (delegate_)
-    delegate_->set_chunk_callback(NULL);
   delegate_ = NULL;
   if (!closed())
     Cancel();
 }
 
 const linked_ptr<SpdyHeaderBlock>& SpdyStream::spdy_headers() const {
   return request_;
 }
 
 void SpdyStream::set_spdy_headers(
@@ skipping 15 matching lines @@
 
 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)

[Ryan Hamilton, 2012/07/09 17:52:02]

I don't like this.  While it is OK (mebe) to receive a WINDOW_UPDATE frame on a
closed SpdyStream (and hence it is safe to silently ignore it) it is NOT OK to
receive a WINDOW_UPDATE frame before we have written the request headers.  In
this case, we need to either process the update or error out, not silently
ignore it.

[ramant (doing other things), 2012/07/11 01:36:18]

Done.

     return;
 
-  // it's valid for send_window_size_ to become negative (via an incoming
+  int32 new_window_size = send_window_size_ + delta_window_size;
+
+  // 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_);
     session_->ResetStream(stream_id_, FLOW_CONTROL_ERROR, desc);
     return;
   }
 
   send_window_size_ = new_window_size;
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
                  stream_id_, delta_window_size, send_window_size_));
+
   PossiblyResumeIfStalled();
 }
 
 void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) {
   // we only call this method when sending a frame, therefore
   // |delta_window_size| should be within the valid frame size range.
   DCHECK(session_->is_flow_control_enabled());
   DCHECK_GE(delta_window_size, 1);
   DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize);
 
@@ skipping 222 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)
-    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,
                                stream_id_, status, &description));
 }
 
 void SpdyStream::OnClose(int status) {
   io_state_ = STATE_DONE;
   response_status_ = status;
   Delegate* delegate = delegate_;
   delegate_ = NULL;
-  if (delegate) {
-    delegate->set_chunk_callback(NULL);
+  if (delegate)
     delegate->OnClose(status);
-  }
 }
 
 void SpdyStream::Cancel() {
   if (cancelled())
     return;
 
   cancelled_ = true;
   if (session_->IsStreamActive(stream_id_))
     session_->ResetStream(stream_id_, CANCEL, "");
 }
 
 void SpdyStream::Close() {
   session_->CloseStream(stream_id_, net::OK);
 }
 
 int SpdyStream::SendRequest(bool has_upload_data) {
-  if (delegate_)
-    delegate_->set_chunk_callback(this);
-
   // Pushed streams do not send any data, and should always be in STATE_OPEN or
   // STATE_DONE. However, we still want to return IO_PENDING to mimic non-push
   // behavior.
   has_upload_data_ = has_upload_data;
   if (pushed_) {
     send_time_ = base::TimeTicks::Now();
     DCHECK(!has_upload_data_);
     DCHECK(response_received());
     return ERR_IO_PENDING;
   }
@@ skipping 203 matching lines @@
     return OK;
   }
 
   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
+  // If we're already in the STATE_SEND_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
   // data portion, of course.
   io_state_ = STATE_SEND_BODY_COMPLETE;
   if (!delegate_)
     return ERR_UNEXPECTED;
   return delegate_->OnSendBody();
 }
 
@@ skipping 32 matching lines @@
   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