Change MockQuicData::AddRead() and MockQuicData::AddWrite() to take explicit IoMode.

- Change the API for MockQuicData::AddRead() and MockQuicData::AddWrite() to always take explicit IoMode.
- Deprecate the following methods as those are confusing to consume:
MockQuicData::AddSynchronousRead() and MockQuicData::AddAsyncWrite().

Bug: 832803
Change-Id: Ie2dc096820988c47c8a75082ce2baacd1d32c3ae
Reviewed-on: https://chromium-review.googlesource.com/1012700Reviewed-by: Ryan Hamilton <rch@chromium.org>
Commit-Queue: Zhongyi Shi <zhongyi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551045}

net/http/http_proxy_client_socket_wrapper_unittest.cc

@@ -250,12 +250,12 @@ TEST_P(HttpProxyClientSocketWrapperTest, QuicProxy) {
   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
-  mock_quic_data_.AddWrite(ConstructSettingsPacket(1));
-  mock_quic_data_.AddWrite(ConstructConnectRequestPacket(2));
-  mock_quic_data_.AddRead(ConstructServerConnectReplyPacket(1, !kFin));
+  mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructSettingsPacket(1));
+  mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
+  mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   mock_quic_data_.AddWrite(
-      ConstructAckAndRstPacket(3, QUIC_STREAM_CANCELLED, 1, 1, 1));
+      SYNCHRONOUS, ConstructAckAndRstPacket(3, QUIC_STREAM_CANCELLED, 1, 1, 1));
   mock_quic_data_.AddSocketDataToFactory(&socket_factory_);
 
   scoped_refptr<TransportSocketParams> transport_params =
@@ -299,12 +299,12 @@ TEST_P(HttpProxyClientSocketWrapperTest, QuicProxySocketTag) {
   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 
-  mock_quic_data_.AddWrite(ConstructSettingsPacket(1));
-  mock_quic_data_.AddWrite(ConstructConnectRequestPacket(2));
-  mock_quic_data_.AddRead(ConstructServerConnectReplyPacket(1, !kFin));
+  mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructSettingsPacket(1));
+  mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
+  mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   mock_quic_data_.AddWrite(
-      ConstructAckAndRstPacket(3, QUIC_STREAM_CANCELLED, 1, 1, 1));
+      SYNCHRONOUS, ConstructAckAndRstPacket(3, QUIC_STREAM_CANCELLED, 1, 1, 1));
   mock_quic_data_.AddSocketDataToFactory(&socket_factory_);
 
   scoped_refptr<TransportSocketParams> transport_params =

net/http/http_stream_factory_impl_job_controller_unittest.cc

@@ -878,7 +878,8 @@ TEST_F(HttpStreamFactoryImplJobControllerTest, AltJobSucceedsMainJobDestroyed) {
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        AltJobSucceedsMainJobBlockedControllerDestroyed) {
   quic_data_ = std::make_unique<MockQuicData>();
-  quic_data_->AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data_->AddWrite(SYNCHRONOUS,
+                       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data_->AddRead(ASYNC, OK);
 
   HttpRequestInfo request_info;
@@ -1903,7 +1904,8 @@ TEST_F(HttpStreamFactoryImplJobControllerTest,
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        PreconnectToHostWithValidAltSvc) {
   quic_data_ = std::make_unique<MockQuicData>();
-  quic_data_->AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data_->AddWrite(SYNCHRONOUS,
+                       client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data_->AddRead(ASYNC, OK);
 
   HttpRequestInfo request_info;
@@ -2336,7 +2338,8 @@ TEST_P(HttpStreamFactoryImplJobControllerMisdirectedRequestRetry,
   if (enable_alternative_services) {
     quic_data_ = std::make_unique<MockQuicData>();
     quic_data_->AddConnect(SYNCHRONOUS, OK);
-    quic_data_->AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+    quic_data_->AddWrite(SYNCHRONOUS,
+                         client_maker_.MakeInitialSettingsPacket(1, nullptr));
     quic_data_->AddRead(ASYNC, OK);
   }
   tcp_data_ = std::make_unique<SequencedSocketData>(nullptr, 0, nullptr, 0);

net/quic/chromium/mock_quic_data.cc

@@ -15,32 +15,20 @@ void MockQuicData::AddConnect(IoMode mode, int rv) {
   connect_.reset(new MockConnect(mode, rv));
 }
 
-void MockQuicData::AddSynchronousRead(
-    std::unique_ptr<QuicEncryptedPacket> packet) {
-  reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(),
-                            sequence_number_++));
-  packets_.push_back(std::move(packet));
-}
-
-void MockQuicData::AddRead(std::unique_ptr<QuicEncryptedPacket> packet) {
+void MockQuicData::AddRead(IoMode mode,
+                           std::unique_ptr<QuicEncryptedPacket> packet) {
   reads_.push_back(
-      MockRead(ASYNC, packet->data(), packet->length(), sequence_number_++));
+      MockRead(mode, packet->data(), packet->length(), sequence_number_++));
   packets_.push_back(std::move(packet));
 }
-
 void MockQuicData::AddRead(IoMode mode, int rv) {
   reads_.push_back(MockRead(mode, rv, sequence_number_++));
 }
 
-void MockQuicData::AddWrite(std::unique_ptr<QuicEncryptedPacket> packet) {
-  writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(),
-                              sequence_number_++));
-  packets_.push_back(std::move(packet));
-}
-
-void MockQuicData::AddAsyncWrite(std::unique_ptr<QuicEncryptedPacket> packet) {
+void MockQuicData::AddWrite(IoMode mode,
+                            std::unique_ptr<QuicEncryptedPacket> packet) {
   writes_.push_back(
-      MockWrite(ASYNC, packet->data(), packet->length(), sequence_number_++));
+      MockWrite(mode, packet->data(), packet->length(), sequence_number_++));
   packets_.push_back(std::move(packet));
 }
 

net/quic/chromium/mock_quic_data.h

@@ -22,25 +22,17 @@ class MockQuicData {
   // synchronusly or asynchronously based on |mode|.
   void AddConnect(IoMode mode, int rv);
 
-  // Adds a synchronous read at the next sequence number which will read
-  // |packet|.
-  void AddSynchronousRead(std::unique_ptr<QuicEncryptedPacket> packet);
-
-  // Adds an asynchronous read at the next sequence number which will read
-  // |packet|.
-  void AddRead(std::unique_ptr<QuicEncryptedPacket> packet);
+  // Adds a read at the next sequence number which will read |packet|
+  // synchronously or asynchronously based on |mode|.
+  void AddRead(IoMode mode, std::unique_ptr<QuicEncryptedPacket> packet);
 
   // Adds a read at the next sequence number which will return |rv| either
   // synchronously or asynchronously based on |mode|.
   void AddRead(IoMode mode, int rv);
 
-  // Adds a synchronous write at the next sequence number which will write
-  // |packet|.
-  void AddWrite(std::unique_ptr<QuicEncryptedPacket> packet);
-
-  // Adds an asynchronous write at the next sequence number which will write
-  // |packet|.
-  void AddAsyncWrite(std::unique_ptr<QuicEncryptedPacket> packet);
+  // Adds a write at the next sequence number which will write |packet|
+  // synchronously or asynchronously based on |mode|.
+  void AddWrite(IoMode mode, std::unique_ptr<QuicEncryptedPacket> packet);
 
   // Adds a write at the next sequence number which will return |rv| either
   // synchronously or asynchronously based on |mode|.

net/quic/chromium/quic_chromium_client_session_test.cc

@@ -289,7 +289,8 @@ TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
 
 TEST_P(QuicChromiumClientSessionTest, Handle) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -374,7 +375,8 @@ TEST_P(QuicChromiumClientSessionTest, Handle) {
 
 TEST_P(QuicChromiumClientSessionTest, StreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -398,7 +400,8 @@ TEST_P(QuicChromiumClientSessionTest, StreamRequest) {
 
 TEST_P(QuicChromiumClientSessionTest, ConfirmationRequiredStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -422,7 +425,8 @@ TEST_P(QuicChromiumClientSessionTest, ConfirmationRequiredStreamRequest) {
 
 TEST_P(QuicChromiumClientSessionTest, StreamRequestBeforeConfirmation) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -451,9 +455,11 @@ TEST_P(QuicChromiumClientSessionTest, StreamRequestBeforeConfirmation) {
 
 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(
-      2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket(
+                                      2, true, GetNthClientInitiatedStreamId(0),
+                                      QUIC_STREAM_CANCELLED));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -477,9 +483,11 @@ TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
 
 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(
-      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket(
+                                      2, true, GetNthClientInitiatedStreamId(0),
+                                      QUIC_RST_ACKNOWLEDGEMENT));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -520,7 +528,8 @@ TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
 
 TEST_P(QuicChromiumClientSessionTest, ClosedWithAsyncStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -569,9 +578,11 @@ TEST_P(QuicChromiumClientSessionTest, ClosedWithAsyncStreamRequest) {
 
 TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakeRstPacket(
-      2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket(
+                                      2, true, GetNthClientInitiatedStreamId(0),
+                                      QUIC_RST_ACKNOWLEDGEMENT));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -613,9 +624,11 @@ TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddRead(server_maker_.MakeConnectionClosePacket(
-      1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddRead(ASYNC, server_maker_.MakeConnectionClosePacket(
+                               1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED,
+                               "Time to panic!"));
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
@@ -640,8 +653,9 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) {
 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeHandshakeConfirmed) {
   MockQuicData quic_data;
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
-  quic_data.AddRead(server_maker_.MakeConnectionClosePacket(
-      1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
+  quic_data.AddRead(ASYNC, server_maker_.MakeConnectionClosePacket(
+                               1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED,
+                               "Time to panic!"));
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
@@ -668,10 +682,12 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeHandshakeConfirmed) {
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseWithPendingStreamRequest) {
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
-  quic_data.AddRead(server_maker_.MakeConnectionClosePacket(
-      1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
+  quic_data.AddRead(ASYNC, server_maker_.MakeConnectionClosePacket(
+                               1, false, QUIC_CRYPTO_VERSION_NOT_SUPPORTED,
+                               "Time to panic!"));
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
@@ -1417,11 +1433,12 @@ TEST_P(QuicChromiumClientSessionTest, RetransmittableOnWireTimeout) {
   migrate_session_early_v2_ = true;
 
   MockQuicData quic_data;
-  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  quic_data.AddWrite(client_maker_.MakePingPacket(2, true));
-  quic_data.AddRead(server_maker_.MakeAckPacket(1, 2, 1, 1, false));
+  quic_data.AddWrite(SYNCHRONOUS,
+                     client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(2, true));
+  quic_data.AddRead(ASYNC, server_maker_.MakeAckPacket(1, 2, 1, 1, false));
 
-  quic_data.AddWrite(client_maker_.MakePingPacket(3, false));
+  quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(3, false));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);