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

net/spdy/spdy_network_transaction_spdy3_unittest.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/http/http_network_transaction.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
  protected:
 
   virtual void SetUp() {
     SpdySession::set_default_protocol(kProtoSPDY3);
     google_get_request_initialized_ = false;
     google_post_request_initialized_ = false;
     google_chunked_post_request_initialized_ = false;
   }
 
   virtual void TearDown() {
+    UploadDataStream::ResetMergeChunks();
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
   }
 
+  void set_merge_chunks(bool merge) {
+    UploadDataStream::set_merge_chunks(merge);
+  }
+
   struct TransactionHelperResult {
     int rv;
     std::string status_line;
     std::string response_data;
     HttpResponseInfo response_info;
   };
 
   // A helper class that handles all the initial npn/ssl setup.
   class NormalSpdyTransactionHelper {
    public:
@@ skipping 14 matching lines @@
               case SPDYNOSSL:
               case SPDYSSL:
                 port_ = 80;
                 break;
               case SPDYNPN:
                 port_ = 443;
                 break;
               default:
                 NOTREACHED();
             }
-          }
-
+    }
 
     ~NormalSpdyTransactionHelper() {
       // Any test which doesn't close the socket by sending it an EOF will
       // have a valid session left open, which leaks the entire session pool.
       // This is just fine - in fact, some of our tests intentionally do this
       // so that we can check consistency of the SpdySessionPool as the test
       // finishes.  If we had put an EOF on the socket, the SpdySession would
       // have closed and we wouldn't be able to check the consistency.
 
       // Forcefully close existing sessions here.
@@ skipping 1488 matching lines @@
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a chunked POST works.
 TEST_P(SpdyNetworkTransactionSpdy3Test, ChunkedPost) {
-  UploadDataStream::set_merge_chunks(false);
+  // Disable merging of chunks until we have a better way to unit test POST
+  // requests with chunked uploads.
+  set_merge_chunks(false);
+
   scoped_ptr<SpdyFrame> req(ConstructChunkedSpdyPost(NULL, 0));
   scoped_ptr<SpdyFrame> chunk1(ConstructSpdyBodyFrame(1, false));
   scoped_ptr<SpdyFrame> chunk2(ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*chunk1),
     CreateMockWrite(*chunk2),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
@@ skipping 446 matching lines @@
   };
 
   static const int32 kDeltaWindowSize = 0x7fffffff;  // cause an overflow
   scoped_ptr<SpdyFrame> window_update(
       ConstructSpdyWindowUpdate(1, kDeltaWindowSize));
   scoped_ptr<SpdyFrame> window_update2(
       ConstructSpdyWindowUpdate(2, kDeltaWindowSize));
   scoped_ptr<SpdyFrame> reply(ConstructSpdyPostSynReply(NULL, 0));
 
   MockRead reads[] = {
+    CreateMockRead(*reply),

[Ryan Hamilton, 2012/07/11 17:11:19]

Why is this change required?  Since the test used to pass, I suspect this is
indicative of a bug.

[ramant (doing other things), 2012/07/11 19:40:43]

As we have discussed, re-implemented this test using DeterministicSocketData.

+    CreateMockRead(*window_update2),
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update2),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     CreateMockRead(*window_update),
     MockRead(ASYNC, ERR_IO_PENDING, 0),  // Wait for the RST to be written.
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   scoped_ptr<DelayedSocketData> data(
@@ skipping 4132 matching lines @@
   // And now we can allow everything else to run to completion.
   data->SetStop(10);
   data->Run();
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ(OK, callback3.WaitForResult());
 
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net