Remove use of DeterministicSocketData from QUIC tests.

net/quic/quic_network_transaction_unittest.cc

Index: net/quic/quic_network_transaction_unittest.cc
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index fa5503a031989af238f80aea12e56f482e5ec4d2..556cd54b761474ca0e67e859e065bf2903fe766a 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/network_quality_estimator.h"
@@ -1335,45 +1336,43 @@ TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
       MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHeader),
       MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
-  DeterministicMockClientSocketFactory socket_factory;
+  MockClientSocketFactory socket_factory;
 
-  DeterministicSocketData http_data(http_reads, arraysize(http_reads),
-                                    http_writes, arraysize(http_writes));
+  SequencedSocketData http_data(http_reads, arraysize(http_reads), http_writes,
+                                arraysize(http_writes));
   socket_factory.AddSocketDataProvider(&http_data);
   socket_factory.AddSSLSocketDataProvider(&ssl_data_);
 
   // The QUIC transaction will not be allowed to complete.
-  MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 0)};
+  MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 1)};
   MockRead quic_reads[] = {
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0),
   };
-  DeterministicSocketData quic_data(quic_reads, arraysize(quic_reads),
-                                    quic_writes, arraysize(quic_writes));
+  SequencedSocketData quic_data(quic_reads, arraysize(quic_reads), quic_writes,
+                                arraysize(quic_writes));
   socket_factory.AddSocketDataProvider(&quic_data);
 
   // The HTTP transaction will complete.
-  DeterministicSocketData http_data2(http_reads, arraysize(http_reads),
-                                     http_writes, arraysize(http_writes));
+  SequencedSocketData http_data2(http_reads, arraysize(http_reads), http_writes,
+                                 arraysize(http_writes));
   socket_factory.AddSocketDataProvider(&http_data2);
   socket_factory.AddSSLSocketDataProvider(&ssl_data_);
 
   CreateSessionWithFactory(&socket_factory, true);
 
   // Run the first request.
-  http_data.StopAfter(arraysize(http_reads) + arraysize(http_writes));
   SendRequestAndExpectHttpResponse("hello world");
   ASSERT_TRUE(http_data.AllReadDataConsumed());
   ASSERT_TRUE(http_data.AllWriteDataConsumed());
 
   // Now run the second request in which the QUIC socket hangs,
   // and verify the the transaction continues over HTTP.
-  http_data2.StopAfter(arraysize(http_reads) + arraysize(http_writes));
   SendRequestAndExpectHttpResponse("hello world");
+  base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(http_data2.AllReadDataConsumed());
   ASSERT_TRUE(http_data2.AllWriteDataConsumed());
-  ASSERT_TRUE(!quic_data.AllReadDataConsumed());
-  ASSERT_TRUE(!quic_data.AllWriteDataConsumed());
+  ASSERT_TRUE(quic_data.AllReadDataConsumed());

[mmenke, 2015/12/18 17:37:53]

Note that the "SYCHRONOUS" write, which the ordering implied should happen
before the read, was never being started in these tests. 
DeterministicSocketData just didn't care.

I flipped the order, and fixed the check that all read data is consumed.  Not
really sure if the write is supposed to happen or not, so didn't add any check
for it, one way or the other.

 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {