Remove unused SocketDataProvider argument from SpdyNetworkTransactionTest::ReadResult

net/spdy/spdy_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 254 matching lines @@
     }
 
     // Most tests will want to call this function. In particular, the MockReads
     // should end with an empty read, and that read needs to be processed to
     // ensure proper deletion of the spdy_session_pool.
     void VerifyDataConsumed() {
       for (const SocketDataProvider* provider : data_vector_) {
         EXPECT_TRUE(provider->AllReadDataConsumed());
         EXPECT_TRUE(provider->AllWriteDataConsumed());
       }
+      for (const SocketDataProvider* provider : deterministic_data_vector_) {
+        EXPECT_TRUE(provider->AllReadDataConsumed());
+        EXPECT_TRUE(provider->AllWriteDataConsumed());
+      }
     }
 
     // Occasionally a test will expect to error out before certain reads are
     // processed. In that case we want to explicitly ensure that the reads were
     // not processed.
     void VerifyDataNotConsumed() {
       for (const SocketDataProvider* provider : data_vector_) {
         EXPECT_FALSE(provider->AllReadDataConsumed());
         EXPECT_FALSE(provider->AllWriteDataConsumed());
       }
+      for (const SocketDataProvider* provider : deterministic_data_vector_) {
+        EXPECT_FALSE(provider->AllReadDataConsumed());
+        EXPECT_FALSE(provider->AllWriteDataConsumed());
+      }
     }
 
     void RunToCompletion(SocketDataProvider* data) {
       RunPreTestSetup();
       AddData(data);
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void RunToCompletionWithSSLData(
@@ skipping 34 matching lines @@
             new StaticSocketDataProvider(NULL, 0, NULL, 0);
         hanging_non_alt_svc_socket->set_connect_data(hanging_connect);
         session_deps_->socket_factory->AddSocketDataProvider(
             hanging_non_alt_svc_socket);
         alternate_vector_.push_back(hanging_non_alt_svc_socket);
       }
     }
 
     void AddDeterministicData(DeterministicSocketData* data) {
       DCHECK(deterministic_);
-      data_vector_.push_back(data);
+      deterministic_data_vector_.push_back(data);
       SSLSocketDataProvider* ssl_provider =
           new SSLSocketDataProvider(ASYNC, OK);
       ssl_provider->SetNextProto(test_params_.protocol);
       ssl_provider->cert =
           ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
       ssl_vector_.push_back(ssl_provider);
       session_deps_->deterministic_socket_factory->AddSSLSocketDataProvider(
           ssl_provider);
 
       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
       if (test_params_.ssl_type == HTTP_SPDY_VIA_ALT_SVC) {
         MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
         DeterministicSocketData* hanging_non_alt_svc_socket =
             new DeterministicSocketData(NULL, 0, NULL, 0);
         hanging_non_alt_svc_socket->set_connect_data(hanging_connect);
         session_deps_->deterministic_socket_factory->AddSocketDataProvider(
             hanging_non_alt_svc_socket);
-        alternate_vector_.push_back(hanging_non_alt_svc_socket);
+        alternate_deterministic_vector_.push_back(hanging_non_alt_svc_socket);
       }
     }
 
     void SetSession(const scoped_refptr<HttpNetworkSession>& session) {
       session_ = session;
     }
     HttpNetworkTransaction* trans() { return trans_.get(); }
     void ResetTrans() { trans_.reset(); }
     TransactionHelperResult& output() { return output_; }
     const HttpRequestInfo& request() const { return request_; }
     const scoped_refptr<HttpNetworkSession>& session() const {
       return session_;
     }
     scoped_ptr<SpdySessionDependencies>& session_deps() {
       return session_deps_;
     }
     int port() const { return port_; }
     SpdyNetworkTransactionTestParams test_params() const {
       return test_params_;
     }
 
    private:
     typedef std::vector<SocketDataProvider*> DataVector;
+    typedef std::vector<DeterministicSocketData*> DeterministicDataVector;
     typedef ScopedVector<SSLSocketDataProvider> SSLVector;
     typedef ScopedVector<SocketDataProvider> AlternateVector;
     typedef ScopedVector<DeterministicSocketData> AlternateDeterministicVector;
     HttpRequestInfo request_;
     RequestPriority priority_;
     scoped_ptr<SpdySessionDependencies> session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     scoped_ptr<SocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback_;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
+    DeterministicDataVector deterministic_data_vector_;
     AlternateVector alternate_vector_;
     AlternateDeterministicVector alternate_deterministic_vector_;
     const BoundNetLog log_;
     SpdyNetworkTransactionTestParams test_params_;
     int port_;
     bool deterministic_;
     bool spdy_enabled_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
@@ skipping 141 matching lines @@
       chunked_post_request_initialized_ = true;
     }
     return chunked_post_request_;
   }
 
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
   int ReadResult(HttpNetworkTransaction* trans,
-                 SocketDataProvider* data,
                  std::string* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
     scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
       int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         rv = callback.WaitForResult();
@@ skipping 47 matching lines @@
     rv = trans2->Start(
         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     base::RunLoop().RunUntilIdle();
 
     // The data for the pushed path may be coming in more than 1 frame. Compile
     // the results into a single string.
 
     // Read the server push body.
     std::string result2;
-    ReadResult(trans2.get(), data, &result2);
+    ReadResult(trans2.get(), &result2);
     // Read the response body.
     std::string result;
-    ReadResult(trans, data, &result);
+    ReadResult(trans, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data->AllReadDataConsumed());
     EXPECT_TRUE(data->AllWriteDataConsumed());
 
     // Verify that the received push data is same as the expected push data.
     EXPECT_EQ(result2.compare(expected), 0) << "Received data: "
                                             << result2
                                             << "||||| Expected data: "
                                             << expected;
@@ skipping 4499 matching lines @@
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(3);
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
-  ReadResult(trans2.get(), &data, &result2);
+  ReadResult(trans2.get(), &result2);
   // Read the response body.
   std::string result;
-  ReadResult(trans, &data, &result);
+  ReadResult(trans, &result);
 
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(result2.compare(expected_push_result), 0)
       << "Received data: "
       << result2
       << "||||| Expected data: "
       << expected_push_result;
 
   // Verify the SYN_REPLY.
   // Copy the response info, because trans goes away.
@@ skipping 114 matching lines @@
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(3);
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
-  ReadResult(trans2.get(), &data, &result2);
+  ReadResult(trans2.get(), &result2);
   // Read the response body.
   std::string result;
-  ReadResult(trans, &data, &result);
+  ReadResult(trans, &result);
 
   // Verify that the received push data is same as the expected push data.
   EXPECT_EQ(expected_push_result, result2);
 
   // Verify the SYN_REPLY.
   // Copy the response info, because trans goes away.
   response = *trans->GetResponseInfo();
   response2 = *trans2->GetResponseInfo();
 
   VerifyStreamsClosed(helper);
@@ skipping 92 matching lines @@
   scoped_ptr<HttpNetworkTransaction> trans2(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
   rv = trans2->Start(
       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   data.RunFor(2);
   base::RunLoop().RunUntilIdle();
 
   // Read the server push body.
   std::string result2;
-  ReadResult(trans2.get(), &data, &result2);
+  ReadResult(trans2.get(), &result2);
   // Read the response body.
   std::string result;
-  ReadResult(trans, &data, &result);
+  ReadResult(trans, &result);
   EXPECT_EQ("hello!", result);
 
   // Verify that we haven't received any push data.
   EXPECT_EQ("", result2);
 
   // Verify the SYN_REPLY.
   // Copy the response info, because trans goes away.
   HttpResponseInfo response = *trans->GetResponseInfo();
 
   VerifyStreamsClosed(helper);
@@ skipping 181 matching lines @@
 
     // Start the transaction with basic parameters.
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback.WaitForResult();
 
     // Read the response body.
     std::string result;
-    ReadResult(trans, &data, &result);
+    ReadResult(trans, &result);
 
     // Verify that we consumed all test data.
     EXPECT_TRUE(data.AllReadDataConsumed());
     EXPECT_TRUE(data.AllWriteDataConsumed());
 
     // Verify the SYN_REPLY.
     // Copy the response info, because trans goes away.
     response = *trans->GetResponseInfo();
 
     VerifyStreamsClosed(helper);
@@ skipping 969 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net