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

net/spdy/spdy_stream.h

Index: net/spdy/spdy_stream.h
===================================================================
--- net/spdy/spdy_stream.h	(revision 144839)
+++ net/spdy/spdy_stream.h	(working copy)
@@ -63,6 +63,16 @@
     // 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.
@@ -85,6 +95,9 @@
     // 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() {}
@@ -269,6 +282,8 @@
     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,
@@ -295,6 +310,8 @@
   int DoSendHeaders();
   int DoSendHeadersComplete(int result);
   int DoSendBody();
+  int DoSendChunkedBody();
+  int DoSendChunkedBodyComplete(int result);
   int DoSendBodyComplete(int result);
   int DoReadHeaders();
   int DoReadHeadersComplete(int result);