| Index: net/http/http_proxy_client_socket_pool_unittest.cc
|
| diff --git a/net/http/http_proxy_client_socket_pool_unittest.cc b/net/http/http_proxy_client_socket_pool_unittest.cc
|
| index d7955d2c058dfce711c060aee467f27dec76276b..283cf89a16a1fdc19a753f2405858496b16cf33b 100644
|
| --- a/net/http/http_proxy_client_socket_pool_unittest.cc
|
| +++ b/net/http/http_proxy_client_socket_pool_unittest.cc
|
| @@ -27,27 +27,19 @@ namespace {
|
|
|
| const int kMaxSockets = 32;
|
| const int kMaxSocketsPerGroup = 6;
|
| -const char * const kAuthHeaders[] = {
|
| - "proxy-authorization", "Basic Zm9vOmJhcg=="
|
| -};
|
| +const char* const kAuthHeaders[] = {"proxy-authorization",
|
| + "Basic Zm9vOmJhcg=="};
|
| const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2;
|
|
|
| -enum HttpProxyType {
|
| - HTTP,
|
| - HTTPS,
|
| - SPDY
|
| -};
|
| +enum HttpProxyType { HTTP, HTTPS, SPDY };
|
|
|
| struct HttpProxyClientSocketPoolTestParams {
|
| HttpProxyClientSocketPoolTestParams()
|
| - : proxy_type(HTTP),
|
| - protocol(kProtoSPDY3) {}
|
| + : proxy_type(HTTP), protocol(kProtoSPDY3) {}
|
|
|
| - HttpProxyClientSocketPoolTestParams(
|
| - HttpProxyType proxy_type,
|
| - NextProto protocol)
|
| - : proxy_type(proxy_type),
|
| - protocol(protocol) {}
|
| + HttpProxyClientSocketPoolTestParams(HttpProxyType proxy_type,
|
| + NextProto protocol)
|
| + : proxy_type(proxy_type), protocol(protocol) {}
|
|
|
| HttpProxyType proxy_type;
|
| NextProto protocol;
|
| @@ -96,15 +88,14 @@ class HttpProxyClientSocketPoolTest
|
| &ssl_socket_pool_,
|
| NULL) {}
|
|
|
| - virtual ~HttpProxyClientSocketPoolTest() {
|
| - }
|
| + virtual ~HttpProxyClientSocketPoolTest() {}
|
|
|
| void AddAuthToCache() {
|
| const base::string16 kFoo(base::ASCIIToUTF16("foo"));
|
| const base::string16 kBar(base::ASCIIToUTF16("bar"));
|
| - GURL proxy_url(GetParam().proxy_type == HTTP ?
|
| - (std::string("http://") + kHttpProxyHost) :
|
| - (std::string("https://") + kHttpsProxyHost));
|
| + GURL proxy_url(GetParam().proxy_type == HTTP
|
| + ? (std::string("http://") + kHttpProxyHost)
|
| + : (std::string("https://") + kHttpsProxyHost));
|
| session_->http_auth_cache()->Add(proxy_url,
|
| "MyRealm1",
|
| HttpAuth::AUTH_SCHEME_BASIC,
|
| @@ -126,11 +117,10 @@ class HttpProxyClientSocketPoolTest
|
| if (GetParam().proxy_type == HTTP)
|
| return NULL;
|
| return new SSLSocketParams(
|
| - new TransportSocketParams(
|
| - HostPortPair(kHttpsProxyHost, 443),
|
| - false,
|
| - false,
|
| - OnHostResolutionCallback()),
|
| + new TransportSocketParams(HostPortPair(kHttpsProxyHost, 443),
|
| + false,
|
| + false,
|
| + OnHostResolutionCallback()),
|
| NULL,
|
| NULL,
|
| HostPortPair(kHttpsProxyHost, 443),
|
| @@ -168,16 +158,20 @@ class HttpProxyClientSocketPoolTest
|
| return session_deps_.deterministic_socket_factory.get();
|
| }
|
|
|
| - 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) {
|
| + 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().proxy_type == SPDY) {
|
| - data_.reset(new DeterministicSocketData(spdy_reads, spdy_reads_count,
|
| - spdy_writes, spdy_writes_count));
|
| + data_.reset(new DeterministicSocketData(
|
| + spdy_reads, spdy_reads_count, spdy_writes, spdy_writes_count));
|
| } else {
|
| - data_.reset(new DeterministicSocketData(reads, reads_count, writes,
|
| - writes_count));
|
| + data_.reset(new DeterministicSocketData(
|
| + reads, reads_count, writes, writes_count));
|
| }
|
|
|
| data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
|
| @@ -194,9 +188,7 @@ class HttpProxyClientSocketPoolTest
|
| }
|
| }
|
|
|
| - void InitializeSpdySsl() {
|
| - ssl_data_->SetNextProto(GetParam().protocol);
|
| - }
|
| + void InitializeSpdySsl() { ssl_data_->SetNextProto(GetParam().protocol); }
|
|
|
| HttpNetworkSession* CreateNetworkSession() {
|
| return SpdySessionDependencies::SpdyCreateSessionDeterministic(
|
| @@ -255,13 +247,17 @@ INSTANTIATE_TEST_CASE_P(
|
| TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
|
| Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
|
|
|
| - int rv = handle_.Init("a", CreateNoTunnelParams(), LOW, CompletionCallback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateNoTunnelParams(),
|
| + 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());
|
| + static_cast<HttpProxyClientSocket*>(handle_.socket());
|
| EXPECT_TRUE(tunnel_socket->IsConnected());
|
| }
|
|
|
| @@ -270,36 +266,40 @@ TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
|
| TEST_P(HttpProxyClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
|
| Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
|
| EXPECT_EQ(OK,
|
| - handle_.Init("a", CreateNoTunnelParams(), HIGHEST,
|
| - CompletionCallback(), &pool_, BoundNetLog()));
|
| + handle_.Init("a",
|
| + CreateNoTunnelParams(),
|
| + HIGHEST,
|
| + CompletionCallback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority());
|
| }
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
|
| - "Host: www.google.com\r\n"
|
| - "Proxy-Connection: keep-alive\r\n\r\n"),
|
| + MockWrite(ASYNC,
|
| + 0,
|
| + "CONNECT www.google.com:443 HTTP/1.1\r\n"
|
| + "Host: www.google.com\r\n"
|
| + "Proxy-Connection: keep-alive\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - // No credentials.
|
| - MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"),
|
| - MockRead(ASYNC, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
|
| - MockRead(ASYNC, 3, "Content-Length: 10\r\n\r\n"),
|
| - MockRead(ASYNC, 4, "0123456789"),
|
| + // No credentials.
|
| + MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"),
|
| + MockRead(ASYNC, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
|
| + MockRead(ASYNC, 3, "Content-Length: 10\r\n\r\n"),
|
| + MockRead(ASYNC, 4, "0123456789"),
|
| };
|
| - scoped_ptr<SpdyFrame> req(
|
| - spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOW));
|
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOW));
|
| scoped_ptr<SpdyFrame> rst(
|
| spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
|
| MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC),
|
| - CreateMockWrite(*rst, 2, ASYNC),
|
| + CreateMockWrite(*req, 0, ASYNC), CreateMockWrite(*rst, 2, ASYNC),
|
| };
|
| const char* const kAuthChallenge[] = {
|
| - spdy_util_.GetStatusKey(), "407 Proxy Authentication Required",
|
| - spdy_util_.GetVersionKey(), "HTTP/1.1",
|
| - "proxy-authenticate", "Basic realm=\"MyRealm1\"",
|
| + spdy_util_.GetStatusKey(), "407 Proxy Authentication Required",
|
| + spdy_util_.GetVersionKey(), "HTTP/1.1",
|
| + "proxy-authenticate", "Basic realm=\"MyRealm1\"",
|
| };
|
| scoped_ptr<SpdyFrame> resp(
|
| spdy_util_.ConstructSpdyControlFrame(NULL,
|
| @@ -312,18 +312,25 @@ TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) {
|
| kAuthChallenge,
|
| arraysize(kAuthChallenge),
|
| 0));
|
| - MockRead spdy_reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 3)
|
| - };
|
| -
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - spdy_reads, arraysize(spdy_reads), spdy_writes,
|
| + MockRead spdy_reads[] = {CreateMockRead(*resp, 1, ASYNC),
|
| + MockRead(ASYNC, 0, 3)};
|
| +
|
| + 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", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -350,59 +357,71 @@ TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) {
|
| if (GetParam().proxy_type == SPDY)
|
| return;
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 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"),
|
| + MockWrite(SYNCHRONOUS,
|
| + 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(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| };
|
|
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
|
| - NULL, 0);
|
| + Initialize(
|
| + reads, arraysize(reads), writes, arraysize(writes), NULL, 0, NULL, 0);
|
| AddAuthToCache();
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + 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());
|
| + static_cast<HttpProxyClientSocket*>(handle_.socket());
|
| EXPECT_TRUE(tunnel_socket->IsConnected());
|
| }
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 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"),
|
| + MockWrite(ASYNC,
|
| + 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(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> req(
|
| spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
|
| - MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC)
|
| - };
|
| + MockWrite spdy_writes[] = {CreateMockWrite(*req, 0, ASYNC)};
|
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
|
| - MockRead spdy_reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2)
|
| - };
|
| -
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - spdy_reads, arraysize(spdy_reads), spdy_writes,
|
| + MockRead spdy_reads[] = {CreateMockRead(*resp, 1, ASYNC),
|
| + MockRead(ASYNC, 0, 2)};
|
| +
|
| + Initialize(reads,
|
| + arraysize(reads),
|
| + writes,
|
| + arraysize(writes),
|
| + spdy_reads,
|
| + arraysize(spdy_reads),
|
| + spdy_writes,
|
| arraysize(spdy_writes));
|
| AddAuthToCache();
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -412,7 +431,7 @@ TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
|
| EXPECT_TRUE(handle_.is_initialized());
|
| ASSERT_TRUE(handle_.socket());
|
| HttpProxyClientSocket* tunnel_socket =
|
| - static_cast<HttpProxyClientSocket*>(handle_.socket());
|
| + static_cast<HttpProxyClientSocket*>(handle_.socket());
|
| EXPECT_TRUE(tunnel_socket->IsConnected());
|
| }
|
|
|
| @@ -423,26 +442,30 @@ TEST_P(HttpProxyClientSocketPoolTest,
|
| if (GetParam().proxy_type != SPDY)
|
| return;
|
|
|
| - scoped_ptr<SpdyFrame> req(
|
| - spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize,
|
| - 1, MEDIUM));
|
| - MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC)
|
| - };
|
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect(
|
| + kAuthHeaders, kAuthHeadersSize, 1, MEDIUM));
|
| + MockWrite spdy_writes[] = {CreateMockWrite(*req, 0, ASYNC)};
|
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
|
| - MockRead spdy_reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2)
|
| - };
|
| -
|
| - Initialize(NULL, 0, NULL, 0,
|
| - spdy_reads, arraysize(spdy_reads),
|
| - spdy_writes, arraysize(spdy_writes));
|
| + MockRead spdy_reads[] = {CreateMockRead(*resp, 1, ASYNC),
|
| + MockRead(ASYNC, 0, 2)};
|
| +
|
| + Initialize(NULL,
|
| + 0,
|
| + NULL,
|
| + 0,
|
| + spdy_reads,
|
| + arraysize(spdy_reads),
|
| + spdy_writes,
|
| + arraysize(spdy_writes));
|
| AddAuthToCache();
|
|
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle_.Init("a", CreateTunnelParams(), MEDIUM,
|
| - callback_.callback(), &pool_, BoundNetLog()));
|
| + handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + MEDIUM,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| EXPECT_EQ(MEDIUM, GetLastTransportRequestPriority());
|
|
|
| data_->RunFor(2);
|
| @@ -450,14 +473,19 @@ TEST_P(HttpProxyClientSocketPoolTest,
|
| }
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
|
| - if (GetParam().proxy_type == SPDY) return;
|
| + if (GetParam().proxy_type == SPDY)
|
| + return;
|
| data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
|
| data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
|
|
|
| socket_factory()->AddSocketDataProvider(data_.get());
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -469,20 +497,24 @@ TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
|
| }
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
|
| - if (GetParam().proxy_type == HTTP) return;
|
| + if (GetParam().proxy_type == HTTP)
|
| + return;
|
| data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
|
| data_->set_connect_data(MockConnect(ASYNC, OK));
|
| socket_factory()->AddSocketDataProvider(data_.get());
|
|
|
| - ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
|
| - ERR_CERT_AUTHORITY_INVALID));
|
| + ssl_data_.reset(new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID));
|
| if (GetParam().proxy_type == SPDY) {
|
| InitializeSpdySsl();
|
| }
|
| socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -494,20 +526,25 @@ TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
|
| }
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
|
| - if (GetParam().proxy_type == HTTP) return;
|
| + if (GetParam().proxy_type == HTTP)
|
| + return;
|
| data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
|
| data_->set_connect_data(MockConnect(ASYNC, OK));
|
| socket_factory()->AddSocketDataProvider(data_.get());
|
|
|
| - ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
|
| - ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
|
| + ssl_data_.reset(
|
| + new SSLSocketDataProvider(ASYNC, ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
|
| if (GetParam().proxy_type == SPDY) {
|
| InitializeSpdySsl();
|
| }
|
| socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -520,32 +557,40 @@ TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 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"),
|
| + MockWrite(ASYNC,
|
| + 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(ASYNC, 1, "HTTP/1.1 200 Conn"),
|
| - MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 200 Conn"),
|
| + MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2),
|
| };
|
| scoped_ptr<SpdyFrame> req(
|
| spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
|
| - MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC)
|
| - };
|
| + MockWrite spdy_writes[] = {CreateMockWrite(*req, 0, ASYNC)};
|
| MockRead spdy_reads[] = {
|
| - MockRead(ASYNC, ERR_CONNECTION_CLOSED, 1),
|
| + MockRead(ASYNC, ERR_CONNECTION_CLOSED, 1),
|
| };
|
|
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - spdy_reads, arraysize(spdy_reads), spdy_writes,
|
| + Initialize(reads,
|
| + arraysize(reads),
|
| + writes,
|
| + arraysize(writes),
|
| + spdy_reads,
|
| + arraysize(spdy_reads),
|
| + spdy_writes,
|
| arraysize(spdy_writes));
|
| AddAuthToCache();
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -570,21 +615,26 @@ TEST_P(HttpProxyClientSocketPoolTest, Tunnel1xxResponse) {
|
| }
|
|
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0,
|
| - "CONNECT www.google.com:443 HTTP/1.1\r\n"
|
| - "Host: www.google.com\r\n"
|
| - "Proxy-Connection: keep-alive\r\n\r\n"),
|
| + MockWrite(ASYNC,
|
| + 0,
|
| + "CONNECT www.google.com:443 HTTP/1.1\r\n"
|
| + "Host: www.google.com\r\n"
|
| + "Proxy-Connection: keep-alive\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 1, "HTTP/1.1 100 Continue\r\n\r\n"),
|
| - MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 100 Continue\r\n\r\n"),
|
| + MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"),
|
| };
|
|
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - NULL, 0, NULL, 0);
|
| + Initialize(
|
| + reads, arraysize(reads), writes, arraysize(writes), NULL, 0, NULL, 0);
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -595,36 +645,44 @@ TEST_P(HttpProxyClientSocketPoolTest, Tunnel1xxResponse) {
|
|
|
| TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 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"),
|
| + MockWrite(ASYNC,
|
| + 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(ASYNC, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"),
|
| };
|
| scoped_ptr<SpdyFrame> req(
|
| spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
|
| scoped_ptr<SpdyFrame> rst(
|
| spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
|
| MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC),
|
| - CreateMockWrite(*rst, 2, ASYNC),
|
| + CreateMockWrite(*req, 0, ASYNC), CreateMockWrite(*rst, 2, ASYNC),
|
| };
|
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdySynReplyError(1));
|
| MockRead spdy_reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 3),
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3),
|
| };
|
|
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - spdy_reads, arraysize(spdy_reads), spdy_writes,
|
| + Initialize(reads,
|
| + arraysize(reads),
|
| + writes,
|
| + arraysize(writes),
|
| + spdy_reads,
|
| + arraysize(spdy_reads),
|
| + spdy_writes,
|
| arraysize(spdy_writes));
|
| AddAuthToCache();
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
| @@ -641,19 +699,23 @@ TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) {
|
| TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupRedirect) {
|
| const std::string redirectTarget = "https://foo.google.com/";
|
|
|
| - const std::string responseText = "HTTP/1.1 302 Found\r\n"
|
| - "Location: " + redirectTarget + "\r\n"
|
| - "Set-Cookie: foo=bar\r\n"
|
| - "\r\n";
|
| + const std::string responseText =
|
| + "HTTP/1.1 302 Found\r\n"
|
| + "Location: " +
|
| + redirectTarget +
|
| + "\r\n"
|
| + "Set-Cookie: foo=bar\r\n"
|
| + "\r\n";
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 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"),
|
| + MockWrite(ASYNC,
|
| + 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(ASYNC, 1, responseText.c_str()),
|
| + MockRead(ASYNC, 1, responseText.c_str()),
|
| };
|
| scoped_ptr<SpdyFrame> req(
|
| spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
|
| @@ -661,32 +723,35 @@ TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupRedirect) {
|
| spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
|
|
|
| MockWrite spdy_writes[] = {
|
| - CreateMockWrite(*req, 0, ASYNC),
|
| - CreateMockWrite(*rst, 3, ASYNC),
|
| + CreateMockWrite(*req, 0, ASYNC), CreateMockWrite(*rst, 3, ASYNC),
|
| };
|
|
|
| const char* const responseHeaders[] = {
|
| - "location", redirectTarget.c_str(),
|
| - "set-cookie", "foo=bar",
|
| + "location", redirectTarget.c_str(), "set-cookie", "foo=bar",
|
| };
|
| const int responseHeadersSize = arraysize(responseHeaders) / 2;
|
| - scoped_ptr<SpdyFrame> resp(
|
| - spdy_util_.ConstructSpdySynReplyError(
|
| - "302 Found",
|
| - responseHeaders, responseHeadersSize,
|
| - 1));
|
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdySynReplyError(
|
| + "302 Found", responseHeaders, responseHeadersSize, 1));
|
| MockRead spdy_reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2),
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2),
|
| };
|
|
|
| - Initialize(reads, arraysize(reads), writes, arraysize(writes),
|
| - spdy_reads, arraysize(spdy_reads), spdy_writes,
|
| + Initialize(reads,
|
| + arraysize(reads),
|
| + writes,
|
| + arraysize(writes),
|
| + spdy_reads,
|
| + arraysize(spdy_reads),
|
| + spdy_writes,
|
| arraysize(spdy_writes));
|
| AddAuthToCache();
|
|
|
| - int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
|
| - &pool_, BoundNetLog());
|
| + int rv = handle_.Init("a",
|
| + CreateTunnelParams(),
|
| + LOW,
|
| + callback_.callback(),
|
| + &pool_,
|
| + BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle_.is_initialized());
|
| EXPECT_FALSE(handle_.socket());
|
|
|
Chromium Code Reviews
