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 23 matching lines @@
   SPDYNOSSL,
   SPDYSSL,
 };
 
 class SpdyNetworkTransactionSpdy3Test
     : public ::testing::TestWithParam<SpdyNetworkTransactionSpdy3TestTypes> {
  protected:
 
   virtual void SetUp() {
     SpdySession::set_default_protocol(kProtoSPDY3);
+    merge_chunks_ = UploadDataStream::merge_chunks();
     google_get_request_initialized_ = false;
     google_post_request_initialized_ = false;
     google_chunked_post_request_initialized_ = false;
   }
 
   virtual void TearDown() {
+    UploadDataStream::set_merge_chunks(merge_chunks_);
     // 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 421 matching lines @@
 
  private:
   bool google_get_request_initialized_;
   bool google_post_request_initialized_;
   bool google_chunked_post_request_initialized_;
   HttpRequestInfo google_get_request_;
   HttpRequestInfo google_post_request_;
   HttpRequestInfo google_chunked_post_request_;
   HttpRequestInfo google_get_push_request_;
   SpdyTestStateHelper spdy_state_;
+  bool merge_chunks_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different connection types: SPDY after NPN
 // negotiation, SPDY without SSL, and SPDY with SSL.
 INSTANTIATE_TEST_CASE_P(Spdy,
                         SpdyNetworkTransactionSpdy3Test,
                         ::testing::Values(SPDYNOSSL, SPDYSSL, SPDYNPN));
 
 
@@ skipping 1060 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);
+  // TODO(satish): Remove this once we have a better way to unit test POST

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

satish?

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

Done.

+  // 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 4602 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