Modify the MockConnect constructor to take an enum of ASYNC or SYNC, instead

net/http/http_proxy_client_socket_pool_unittest.cc

 // Copyright (c) 2011 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 "net/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 128 matching lines @@
   }
 
   scoped_refptr<HttpProxySocketParams> GetNoTunnelParams() {
     return GetParams(false);
   }
 
   DeterministicMockClientSocketFactory& socket_factory() {
     return socket_factory_;
   }
 
-  void Initialize(bool async, MockRead* reads, size_t reads_count,
+  void Initialize(MockRead* reads, size_t reads_count,
                   MockWrite* writes, size_t writes_count,
                   MockRead* spdy_reads, size_t spdy_reads_count,
                   MockWrite* spdy_writes, size_t spdy_writes_count) {
     if (GetParam() == SPDY)
       data_ = new DeterministicSocketData(spdy_reads, spdy_reads_count,
                                           spdy_writes, spdy_writes_count);
     else
       data_ = new DeterministicSocketData(reads, reads_count, writes,
                                           writes_count);
 
-    data_->set_connect_data(MockConnect(async, 0));
+    data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     data_->StopAfter(2);  // Request / Response
 
     socket_factory_.AddSocketDataProvider(data_.get());
 
     if (GetParam() != HTTP) {
-      ssl_data_.reset(new SSLSocketDataProvider(async, OK));
+      ssl_data_.reset(new SSLSocketDataProvider(false, OK));

[jar (doing other things), 2012/02/17 17:19:16]

There is a chance that this strategy should be pushed further... into
SSLSocketDataProvider.... but already this is a very good change.

[Ryan Hamilton, 2012/02/17 17:33:56]

Yes, totally agree.  I want to push this change into MockRead/MockWrite, and all
the *SocketData providers.  (But once CL at a time so that this CL doesn't touch
every line in every test :>)

       if (GetParam() == SPDY) {
         InitializeSpdySsl();
       }
       socket_factory_.AddSSLSocketDataProvider(ssl_data_.get());
     }
   }
 
   void InitializeSpdySsl() {
     spdy::SpdyFramer::set_enable_compression_default(false);
     ssl_data_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
@@ skipping 43 matching lines @@
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 // and SPDY.
 INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolTests,
                         HttpProxyClientSocketPoolTest,
                         ::testing::Values(HTTP, HTTPS, SPDY));
 
 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
-  Initialize(false, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
+  Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   int rv = handle_.Init("a", GetNoTunnelParams(), LOW, CompletionCallback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
@@ skipping 18 matching lines @@
     CreateMockWrite(*rst, 2, true),
   };
   scoped_ptr<spdy::SpdyFrame> resp(
       ConstructSpdySynReplyError(
           "407 Proxy Authentication Required", NULL, 0, 1));
   MockRead spdy_reads[] = {
     CreateMockWrite(*resp, 1, true),
     MockRead(true, 0, 3)
   };
 
-  Initialize(false, reads, arraysize(reads), writes, arraysize(writes),
+  Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
 
   data_->StopAfter(4);
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
@@ skipping 24 matching lines @@
     MockWrite(false, 0,
               "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(false, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
-  Initialize(false, reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
+  Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
              NULL, 0);
   AddAuthToCache();
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
@@ skipping 15 matching lines @@
                                                        kAuthHeadersSize, 1));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, true)
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, true),
     MockRead(true, 0, 2)
   };
 
-  Initialize(false, reads, arraysize(reads), writes, arraysize(writes),
+  Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
   EXPECT_EQ(OK, callback_.WaitForResult());
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
   if (GetParam() == SPDY) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
-  data_->set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED));
+  data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
 
   socket_factory().AddSocketDataProvider(data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
   if (GetParam() == HTTP) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
-  data_->set_connect_data(MockConnect(true, OK));
+  data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(true,
                                             ERR_CERT_AUTHORITY_INVALID));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
   if (GetParam() == HTTP) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
-  data_->set_connect_data(MockConnect(true, OK));
+  data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(true,
                                             ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
@@ skipping 22 matching lines @@
   };
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(kAuthHeaders,
                                                        kAuthHeadersSize, 1));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, true)
   };
   MockRead spdy_reads[] = {
     MockRead(true, ERR_CONNECTION_CLOSED, 1),
   };
 
-  Initialize(false, reads, arraysize(reads), writes, arraysize(writes),
+  Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
@@ skipping 20 matching lines @@
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, true),
     CreateMockWrite(*rst, 2, true),
   };
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdySynReplyError(1));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, true),
     MockRead(true, 0, 3),
   };
 
-  Initialize(false, reads, arraysize(reads), writes, arraysize(writes),
+  Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
 
   rv = callback_.WaitForResult();
   if (GetParam() == HTTP) {
     // HTTP Proxy CONNECT responses are not trustworthy
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
     EXPECT_FALSE(handle_.is_initialized());
     EXPECT_FALSE(handle_.socket());
   } else {
     // HTTPS or SPDY Proxy CONNECT responses are trustworthy
     EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv);
     EXPECT_TRUE(handle_.is_initialized());
     EXPECT_TRUE(handle_.socket());
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net