Remove use of DeterministicSocketData from QUIC tests.

net/quic/quic_network_transaction_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 <vector>
 
 #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"
 #include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
@@ skipping 1299 matching lines @@
   MockWrite http_writes[] = {
       MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
       MockWrite(SYNCHRONOUS, 1, "Host: mail.example.com\r\n"),
       MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
       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());
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "https", "/")));
   mock_quic_data.AddRead(ConstructResponseHeadersPacket(
       1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
@@ skipping 462 matching lines @@
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(rtt_observer_.rtt_notification_received());
 }
 
 }  // namespace test
 }  // namespace net