Created new URLRequestContext for secure proxy check

net/http/http_stream_factory_impl_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 "net/http/http_stream_factory_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "net/base/capturing_net_log.h"
 #include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/http/transport_security_state.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
+#include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
+#include "net/quic/test_tools/mock_random.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/mock_client_socket_pool_manager.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 // This file can be included from net/http even though
@@ skipping 1064 matching lines @@
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
 }
 
+TEST_P(HttpStreamFactoryTest, RequestQuicHTTPStream) {
+  for (int i = 0; i <= 1; i++) {
+    scoped_ptr<ProxyService> proxy_service;
+    proxy_service.reset(ProxyService::CreateFixedFromPacResult("DIRECT"));
+
+    HttpNetworkSession::Params params;
+    MockClock* clock_ = new MockClock();
+    MockRandom random_generator_;
+    MockCryptoClientStreamFactory crypto_client_stream_factory_;
+    MockCertVerifier cert_verifier_;
+
+    params.enable_quic = true;
+    params.enable_quic_for_proxies = true;
+    scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
+        new SSLConfigServiceDefaults);
+    HttpServerPropertiesImpl http_server_properties;
+    MockClientSocketFactory socket_factory;
+    params.client_socket_factory = &socket_factory;
+    MockHostResolver host_resolver;
+    params.host_resolver = &host_resolver;
+    TransportSecurityState transport_security_state;
+    params.transport_security_state = &transport_security_state;
+    params.proxy_service = proxy_service.get();
+    params.ssl_config_service = ssl_config_service.get();
+    params.http_server_properties = http_server_properties.GetWeakPtr();
+    params.use_alternate_protocols = true;
+    params.next_protos = NextProtosWithSpdyAndQuic(true, true);
+    params.quic_clock = clock_;
+    clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
+    params.quic_random = &random_generator_;
+    params.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
+    params.cert_verifier = &cert_verifier_;
+    scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
+    params.http_auth_handler_factory = auth_handler_factory_.get();
+    params.quic_supported_versions.push_back(QUIC_VERSION_24);
+
+    params.origin_to_force_quic_on =
+        HostPortPair::FromString("www.google.com:80");
+
+    scoped_refptr<HttpNetworkSession> session;
+    session = new HttpNetworkSession(params);
+    session->quic_stream_factory()->set_require_confirmation(false);
+
+    MockRead http_reads[] = {
+        MockRead("HTTP/1.1 200 OK\r\n"),
+        MockRead("Alternate-Protocol: 80:quic\r\n\r\n"),
+        MockRead("hello world"),
+        MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+        MockRead(ASYNC, OK),
+    };
+
+    HttpRequestInfo request_info;
+    request_info.method = "GET";
+    request_info.url = GURL("http://www.google.com");
+
+    request_info.load_flags = 0;
+    if (i == 1) {
+      request_info.load_flags = LOAD_UNENCRYPTED_HTTP11;
+    }
+
+    SSLConfig ssl_config;
+    EXPECT_TRUE(params.enable_quic) << i;
+
+    StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
+                                       nullptr, 0);
+    socket_factory.AddSocketDataProvider(&http_data);
+
+    scoped_ptr<HttpNetworkTransaction> trans(
+        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+
+    CapturingBoundNetLog net_log_;
+    TestCompletionCallback callback;
+
+    int rv = trans.get()->Start(&request_info, callback.callback(),
+                                net_log_.bound());
+    EXPECT_EQ(ERR_IO_PENDING, rv) << i;
+    EXPECT_EQ(i == 0, OK != callback.WaitForResult());
+
+    const HttpResponseInfo* response = trans->GetResponseInfo();
+    EXPECT_EQ(i == 0, response == nullptr) << i;
+    if (i == 0) {
+      // When LOAD_UNENCRYPTED_HTTP11 is not enabled, request fails because
+      // there is no QUIC mock socket.
+      continue;
+    }
+    ASSERT_TRUE(response->headers.get() != nullptr) << i;
+    EXPECT_FALSE(response->was_fetched_via_spdy) << i;
+    EXPECT_FALSE(response->was_npn_negotiated) << i;
+
+    EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
+              response->connection_info)
+        << i;
+
+    EXPECT_EQ(i == 1, http_server_properties.RequiresHTTP11(
+                          HostPortPair::FromString("www.google.com:80")))
+        << i;
+  }
+}
+
 TEST_P(HttpStreamFactoryTest, RequestSpdyHttpStream) {
-  SpdySessionDependencies session_deps(GetParam(),
-                                       ProxyService::CreateDirect());
+  for (int i = 0; i <= 1; i++) {
+    SpdySessionDependencies session_deps(GetParam(),
+                                         ProxyService::CreateDirect());
 
-  MockRead mock_read(ASYNC, OK);
-  DeterministicSocketData socket_data(&mock_read, 1, nullptr, 0);
-  socket_data.set_connect_data(MockConnect(ASYNC, OK));
-  session_deps.deterministic_socket_factory->AddSocketDataProvider(
-      &socket_data);
+    MockRead mock_read(ASYNC, OK);
+    DeterministicSocketData socket_data(&mock_read, 1, nullptr, 0);
+    socket_data.set_connect_data(MockConnect(ASYNC, OK));
+    session_deps.deterministic_socket_factory->AddSocketDataProvider(
+        &socket_data);
 
-  SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
-  ssl_socket_data.SetNextProto(GetParam());
-  session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
-      &ssl_socket_data);
+    SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
+    ssl_socket_data.SetNextProto(GetParam());
+    session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
+        &ssl_socket_data);
 
-  HostPortPair host_port_pair("www.google.com", 443);
-  scoped_refptr<HttpNetworkSession>
-      session(SpdySessionDependencies::SpdyCreateSessionDeterministic(
-          &session_deps));
+    HostPortPair host_port_pair("www.google.com", 443);
+    scoped_refptr<HttpNetworkSession> session(
+        SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps));
 
-  // Now request a stream.
-  HttpRequestInfo request_info;
-  request_info.method = "GET";
-  request_info.url = GURL("https://www.google.com");
-  request_info.load_flags = 0;
+    // Now request a stream.
+    HttpRequestInfo request_info;
+    request_info.method = "GET";
+    request_info.url = GURL("https://www.google.com");
+    request_info.load_flags = 0;
+    if (i == 1) {
+      request_info.load_flags = LOAD_UNENCRYPTED_HTTP11;
+    }
 
-  SSLConfig ssl_config;
-  StreamRequestWaiter waiter;
-  scoped_ptr<HttpStreamRequest> request(
-      session->http_stream_factory()->RequestStream(
-          request_info,
-          DEFAULT_PRIORITY,
-          ssl_config,
-          ssl_config,
-          &waiter,
-          BoundNetLog()));
-  waiter.WaitForStream();
-  EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(nullptr == waiter.websocket_stream());
-  ASSERT_TRUE(nullptr != waiter.stream());
-  EXPECT_TRUE(waiter.stream()->IsSpdyHttpStream());
-  EXPECT_EQ(1, GetSocketPoolGroupCount(
-      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
-  EXPECT_EQ(1, GetSocketPoolGroupCount(
-      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
-  EXPECT_EQ(0, GetSocketPoolGroupCount(
-      session->GetTransportSocketPool(
-          HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
-  EXPECT_EQ(0, GetSocketPoolGroupCount(
-      session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
-  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+    SSLConfig ssl_config;
+    StreamRequestWaiter waiter;
+    scoped_ptr<HttpStreamRequest> request(
+        session->http_stream_factory()->RequestStream(
+            request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter,
+            BoundNetLog()));
+    waiter.WaitForStream();
+    EXPECT_TRUE(waiter.stream_done());
+    EXPECT_TRUE(nullptr == waiter.websocket_stream());
+    ASSERT_TRUE(nullptr != waiter.stream());
+    EXPECT_EQ(i == 0, waiter.stream()->IsSpdyHttpStream());
+    EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool(
+                     HttpNetworkSession::NORMAL_SOCKET_POOL)));
+    EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool(
+                     HttpNetworkSession::NORMAL_SOCKET_POOL)));
+    EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool(
+                     HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
+    EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
+                     HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
+    EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+
+    base::WeakPtr<HttpServerProperties> http_server_properties =
+        session->http_server_properties();
+
+    EXPECT_EQ(i == 1, http_server_properties->RequiresHTTP11(host_port_pair))
+        << i;
+  }
 }
 
 // TODO(ricea): This test can be removed once the new WebSocket stack supports
 // SPDY. Currently, even if we connect to a SPDY-supporting server, we need to
 // use plain SSL.
 TEST_P(HttpStreamFactoryTest, RequestWebSocketSpdyHandshakeStreamButGetSSL) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
@@ skipping 188 matching lines @@
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net