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) {
+  bool UnencryptedHTTP11Flag[2] = {false, true};
+  for (auto loadFlag : UnencryptedHTTP11Flag) {
+    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 = loadFlag ? LOAD_UNENCRYPTED_HTTP11 : 0;
+
+    SSLConfig ssl_config;
+    EXPECT_TRUE(params.enable_quic) << loadFlag;
+
+    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) << loadFlag;
+    EXPECT_EQ(loadFlag, OK == callback.WaitForResult()) << loadFlag;
+
+    const HttpResponseInfo* response = trans->GetResponseInfo();
+    // When LOAD_UNENCRYPTED_HTTP11 is not enabled, request fails because
+    // there is no QUIC mock socket.
+    EXPECT_EQ(loadFlag, response != nullptr) << loadFlag;
+    if (!loadFlag) {
+      continue;
+    }
+    ASSERT_TRUE(response->headers.get() != nullptr) << loadFlag;
+    EXPECT_FALSE(response->was_fetched_via_spdy) << loadFlag;
+    EXPECT_FALSE(response->was_npn_negotiated) << loadFlag;
+
+    EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
+              response->connection_info)
+        << loadFlag;
+  }
+}
+
 TEST_P(HttpStreamFactoryTest, RequestSpdyHttpStream) {
   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);
 
@@ skipping 239 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