Created new URLRequestContext for secure proxy check

net/http/http_stream_factory_impl_unittest.cc

Index: net/http/http_stream_factory_impl_unittest.cc
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index e55aff50b27d06ee5a10e9e187311e7c0dca3041..94f08897d8d9a2a9377bcb345f01bdff9d60ad7e 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -9,6 +9,7 @@
 
 #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"
@@ -24,6 +25,9 @@
 #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"
@@ -1108,6 +1112,97 @@ TEST_P(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverProxy) {
   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());