Misc cleanup.

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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 216 matching lines @@
 
       session_deps_->socket_factory->AddSSLSocketDataProvider(
           ssl_provider.get());
       ssl_vector_.push_back(std::move(ssl_provider));
 
       session_deps_->socket_factory->AddSocketDataProvider(data);
     }
 
     HttpNetworkTransaction* trans() { return trans_.get(); }
     void ResetTrans() { trans_.reset(); }
-    TransactionHelperResult& output() { return output_; }
+    const TransactionHelperResult& output() { return output_; }
     const HttpRequestInfo& request() const { return request_; }
     HttpNetworkSession* session() const { return session_.get(); }
     SpdySessionDependencies* session_deps() { return session_deps_.get(); }
 
    private:
     typedef std::vector<SocketDataProvider*> DataVector;
     typedef std::vector<std::unique_ptr<SSLSocketDataProvider>> SSLVector;
     typedef std::vector<std::unique_ptr<SocketDataProvider>> AlternateVector;
     HttpRequestInfo request_;
     RequestPriority priority_;
     std::unique_ptr<SpdySessionDependencies> session_deps_;
     std::unique_ptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
-    std::unique_ptr<SocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback_;
     std::unique_ptr<HttpNetworkTransaction> trans_;
-    std::unique_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
-    AlternateVector alternate_vector_;
     const BoundNetLog log_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
   void ConnectStatusHelper(const MockRead& status);
 
   const HttpRequestInfo& CreateGetPushRequest() {
     get_push_request_.method = "GET";
@@ skipping 1501 matching lines @@
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   MockRead reads[] = {
       CreateMockRead(resp, 1, ASYNC), MockRead(ASYNC, 0, 0, 4)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
-  HttpNetworkTransaction* trans = helper.trans();
+  helper.StartDefaultTest();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_IO_PENDING));
 
-  TestCompletionCallback callback;
-  int rv = trans->Start(
-      &CreateGetRequest(), callback.callback(), BoundNetLog());
-  EXPECT_THAT(callback.GetResult(rv), IsOk());
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsOk());
 
   helper.ResetTrans();
   base::RunLoop().RunUntilIdle();
 
   helper.VerifyDataConsumed();
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_F(SpdyNetworkTransactionTest, ResponseWithoutHeaders) {
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
@@ skipping 1950 matching lines @@
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(req, 0)};
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   MockRead reads[] = {
       CreateMockRead(resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
-  BoundNetLog log;
-  NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, log,
-                                     NULL);
+
+  NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
+                                     BoundNetLog(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
-  HttpNetworkTransaction* trans = helper.trans();
+  helper.StartDefaultTest();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_IO_PENDING));
 
-  TestCompletionCallback callback;
-  TransactionHelperResult out;
-  out.rv = trans->Start(&CreateGetRequest(), callback.callback(), log);
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_CONNECTION_CLOSED));
 
-  EXPECT_EQ(out.rv, ERR_IO_PENDING);
-  out.rv = callback.WaitForResult();
-  EXPECT_EQ(out.rv, ERR_CONNECTION_CLOSED);
-
-  const HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
   EXPECT_TRUE(response->headers);
   EXPECT_TRUE(response->was_fetched_via_spdy);
-  out.rv = ReadTransaction(trans, &out.response_data);
-  EXPECT_THAT(out.rv, IsError(ERR_CONNECTION_CLOSED));
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Retry with HTTP/1.1 when receiving HTTP_1_1_REQUIRED.  Note that no actual
 // protocol negotiation happens, instead this test forces protocols for both
 // sockets.
 TEST_F(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
   HttpRequestInfo request;
@@ skipping 464 matching lines @@
       CreateMockRead(resp_authentication, 1),
       CreateMockRead(body_authentication, 2),
       CreateMockRead(resp_data, 4),
       CreateMockRead(body_data, 5),
       MockRead(ASYNC, 0, 6),
   };
 
   SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                            arraysize(spdy_writes));
   HttpRequestInfo request(CreateGetRequest());
-  BoundNetLog net_log;
-  NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, net_log, NULL);
+  NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
+                                     NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
-  HttpNetworkTransaction* trans = helper.trans();
-  TestCompletionCallback callback;
-  const int rv_start = trans->Start(&request, callback.callback(), net_log);
-  EXPECT_THAT(rv_start, IsError(ERR_IO_PENDING));
-  const int rv_start_complete = callback.WaitForResult();
-  EXPECT_THAT(rv_start_complete, IsOk());
+  helper.StartDefaultTest();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_IO_PENDING));
+
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsOk());
 
   // Make sure the response has an auth challenge.
+  HttpNetworkTransaction* trans = helper.trans();
   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
   ASSERT_TRUE(response_start);
   ASSERT_TRUE(response_start->headers);
   EXPECT_EQ(401, response_start->headers->response_code());
   EXPECT_TRUE(response_start->was_fetched_via_spdy);
   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
   ASSERT_TRUE(auth_challenge);
   EXPECT_FALSE(auth_challenge->is_proxy);
   EXPECT_EQ(kBasicAuthScheme, auth_challenge->scheme);
   EXPECT_EQ("MyRealm", auth_challenge->realm);
@@ skipping 1952 matching lines @@
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net