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);
+  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 414 matching lines @@
   // Force write of WINDOW_UPDATE which was scheduled during the above
   // read.
   MessageLoop::current()->RunAllPending();
 
   // Read EOF.
   data->CompleteRead();
 
   helper.VerifyDataConsumed();
 }
 
-// Test that WINDOW_UPDATE frame causing overflow is handled correctly.  We
-// use the same trick as in the above test to enforce our scenario.
+// Test that WINDOW_UPDATE frame causing overflow is handled correctly.
 TEST_P(SpdyNetworkTransactionSpdy3Test, WindowUpdateOverflow) {
-  // number of full frames we hope to write (but will not, used to
+  // Number of full frames we hope to write (but will not, used to
   // set content-length header correctly)
   static int kFrameCount = 3;
 
   scoped_ptr<std::string> content(
       new std::string(kMaxSpdyFrameChunkSize, 'a'));
   scoped_ptr<SpdyFrame> req(ConstructSpdyPost(
       kMaxSpdyFrameChunkSize * kFrameCount, NULL, 0));
   scoped_ptr<SpdyFrame> body(
       ConstructSpdyBodyFrame(1, content->c_str(), content->size(), false));
   scoped_ptr<SpdyFrame> rst(
       ConstructSpdyRstStream(1, FLOW_CONTROL_ERROR));
 
   // We're not going to write a data frame with FIN, we'll receive a bad
   // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame.
   MockWrite writes[] = {
-    CreateMockWrite(*req),
-    CreateMockWrite(*body),
-    CreateMockWrite(*rst),
+    CreateMockWrite(*req, 0),
+    CreateMockWrite(*body, 2),
+    CreateMockWrite(*rst, 3),
   };
 
   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(*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
+    CreateMockRead(*window_update, 1),
+    MockRead(ASYNC, 0, 4)  // EOF
   };
 
-  scoped_ptr<DelayedSocketData> data(
-      new DelayedSocketData(0, reads, arraysize(reads),
-                            writes, arraysize(writes)));
+  scoped_ptr<DeterministicSocketData> data(
+      new DeterministicSocketData(reads, arraysize(reads),
+                                  writes, arraysize(writes)));
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
   for (int i = 0; i < kFrameCount; ++i)
     request.upload_data->AppendBytes(content->c_str(), content->size());
 
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam(), NULL);
-  helper.AddData(data.get());
+  helper.SetDeterministic();
   helper.RunPreTestSetup();
-
+  helper.AddDeterministicData(data.get());
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
+  ASSERT_EQ(ERR_IO_PENDING, rv);
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  rv = callback.WaitForResult();
-  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
-
-  data->CompleteRead();
-
-  ASSERT_TRUE(helper.session() != NULL);
-  ASSERT_TRUE(helper.session()->spdy_session_pool() != NULL);
-  helper.session()->spdy_session_pool()->CloseAllSessions();
+  data->RunFor(5);
+  ASSERT_TRUE(callback.have_result());
+  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult());
   helper.VerifyDataConsumed();
 }
 
 // Test that after hitting a send window size of 0, the write process
 // stalls and upon receiving WINDOW_UPDATE frame write resumes.
 
 // This test constructs a POST request followed by enough data frames
 // containing 'a' that would make the window size 0, followed by another
 // data frame containing default content (which is "hello!") and this frame
 // also contains a FIN flag.  DelayedSocketData is used to enforce all
@@ skipping 4092 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