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

net/spdy/spdy_stream.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 43 matching lines @@
     virtual bool OnSendHeadersComplete(int status) = 0;
 
     // Called when stream is ready to send data.
     // Returns network error code. OK when it successfully sent data.
     virtual int OnSendBody() = 0;
 
     // Called when data has been sent. |status| indicates network error
     // or number of bytes that has been sent. On return, |eof| is set to true
     // if no more data is available to send in the request body.
     // Returns network error code. OK when it successfully sent data.
     virtual int OnSendBodyComplete(int status, bool* eof) = 0;

[Ryan Sleevi, 2012/07/02 21:52:47]

In the case of SPDY, which already (seemingly) supports streaming bodies, it's
not clear how this method is different from OnSendChunkedBody.

Just from reading the comment on OnSendBodyComplete, it seems like no new
delegate methods should be added, and instead the delegate should set eof to
false if IsRequestBodyChunked.

The actual SpdyStream should stay in STATE_SEND_BODY until OnSendBodyComplete
successfully indicates EOF, at which point it should then treat the full body as
written.

It sounds like the bug would still present itself if a delegate set |eof| to
false, since that would involve a transition in the stream from STATE_SEND_BODY
to STATE_SEND_BODY_COMPLETE back to STATE_SEND_BODY

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

I agree with sleevi here.

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

sleevi and I had walked through the code and verified that there is no bug. But
the code in spdy_http_stream.cc how it handles the first upload data is slightly
complicated (cases to prove to ourselves that there is no loop or data is not
duplicated). Will file a separate bug to clean up the code.

Done.

 
+    // Called when stream is ready to send chunked data.
+    // Returns network error code. OK when it successfully sent chunked data.
+    virtual int OnSendChunkedBody() = 0;
+
+    // Called when chunked data has been sent. |status| indicates network error
+    // or number of bytes that has been sent. On return, |eof| is set to true
+    // if no more chunked data is available to send in the request body.
+    // Returns network error code. OK when it successfully sent chunked data.
+    virtual int OnSendChunkedBodyComplete(int status, bool* eof) = 0;
+
     // Called when the SYN_STREAM, SYN_REPLY, or HEADERS frames are received.
     // Normal streams will receive a SYN_REPLY and optional HEADERS frames.
     // Pushed streams will receive a SYN_STREAM and optional HEADERS frames.
     // Because a stream may have a SYN_* frame and multiple HEADERS frames,
     // this callback may be called multiple times.
     // |status| indicates network error. Returns network error code.
     virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                    base::Time response_time,
                                    int status) = 0;
 
     // Called when data is received.
     virtual void OnDataReceived(const char* data, int length) = 0;
 
     // Called when data is sent.
     virtual void OnDataSent(int length) = 0;
 
     // Called when SpdyStream is closed.
     virtual void OnClose(int status) = 0;
 
     // Sets the callback to be invoked when a new chunk is available to upload.
     virtual void set_chunk_callback(ChunkCallback* callback) = 0;
 
+    // Returns true if the upload is chunked.
+    virtual bool IsRequestBodyChunked() = 0;
+
    protected:
     friend class base::RefCounted<Delegate>;
     virtual ~Delegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // SpdyStream constructor
   SpdyStream(SpdySession* session,
@@ skipping 164 matching lines @@
  private:
   enum State {
     STATE_NONE,
     STATE_GET_DOMAIN_BOUND_CERT,
     STATE_GET_DOMAIN_BOUND_CERT_COMPLETE,
     STATE_SEND_DOMAIN_BOUND_CERT,
     STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE,
     STATE_SEND_HEADERS,
     STATE_SEND_HEADERS_COMPLETE,
     STATE_SEND_BODY,
+    STATE_SEND_CHUNKED_BODY,
+    STATE_SEND_CHUNKED_BODY_COMPLETE,
     STATE_SEND_BODY_COMPLETE,
     STATE_WAITING_FOR_RESPONSE,
     STATE_OPEN,
     STATE_DONE
   };
 
   friend class base::RefCounted<SpdyStream>;
   virtual ~SpdyStream();
 
   // If the stream is stalled and if |send_window_size_| is positive, then set
   // |stalled_by_flow_control_| to false and unstall the stream.
   void PossiblyResumeIfStalled();
 
   void OnGetDomainBoundCertComplete(int result);
 
   // Try to make progress sending/receiving the request/response.
   int DoLoop(int result);
 
   // The implementations of each state of the state machine.
   int DoGetDomainBoundCert();
   int DoGetDomainBoundCertComplete(int result);
   int DoSendDomainBoundCert();
   int DoSendDomainBoundCertComplete(int result);
   int DoSendHeaders();
   int DoSendHeadersComplete(int result);
   int DoSendBody();
+  int DoSendChunkedBody();
+  int DoSendChunkedBodyComplete(int result);
   int DoSendBodyComplete(int result);
   int DoReadHeaders();
   int DoReadHeadersComplete(int result);
   int DoOpen(int result);
 
   // Update the histograms.  Can safely be called repeatedly, but should only
   // be called after the stream has completed.
   void UpdateHistograms();
 
   // When a server pushed stream is first created, this function is posted on
@@ skipping 58 matching lines @@
   std::string domain_bound_private_key_;
   std::string domain_bound_cert_;
   ServerBoundCertService::RequestHandle domain_bound_cert_request_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_