net: Make URLRequestJobFactories mandatory.

components/data_reduction_proxy/browser/data_reduction_proxy_protocol_unittest.cc

 // Copyright 2014 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 "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/network_delegate.h"
-#include "net/cert/cert_verifier.h"
-#include "net/cert/mock_cert_verifier.h"
-#include "net/dns/mock_host_resolver.h"
-#include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
-#include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/socket/socket_test_util.h"
-#include "net/ssl/ssl_config_service.h"
+#include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using net::HttpNetworkLayer;
-using net::HttpNetworkSession;
 using net::HttpResponseHeaders;
 using net::HostPortPair;
 using net::MockRead;
 using net::MockWrite;
 using net::ProxyRetryInfoMap;
 using net::ProxyService;
 using net::StaticSocketDataProvider;
 using net::TestDelegate;
-using net::TransportSecurityState;
 using net::URLRequest;
-using net::URLRequestContext;
+using net::TestURLRequestContext;
 
 
 namespace {
 // Transform "normal"-looking headers (\n-separated) to the appropriate
 // input format for ParseRawHeaders (\0-separated).
 void HeadersToRaw(std::string* headers) {
   std::replace(headers->begin(), headers->end(), '\n', '\0');
   if (!headers->empty())
     *headers += '\0';
 }
@@ skipping 58 matching lines @@
         test_data_reduction_proxy_params_,
         request,
         original_response_headers,
         override_response_headers);
     return net::OK;
   }
 
   TestDataReductionProxyParams* test_data_reduction_proxy_params_;
 };
 
-// Constructs a |URLRequestContext| that uses a |MockSocketFactory| to simulate
-// requests and responses.
+// Constructs a |TestURLRequestContext| that uses a |MockSocketFactory| to
+// simulate requests and responses.
 class DataReductionProxyProtocolTest : public testing::Test {
  public:
-  DataReductionProxyProtocolTest()
-      : ssl_config_service_(new net::SSLConfigServiceDefaults) {}
+  DataReductionProxyProtocolTest() : http_user_agent_settings_("", "") {}
 
-  // Sets up the |URLRequestContext| with the provided |ProxyService|.
+  // Sets up the |TestURLRequestContext| with the provided |ProxyService|.
   void ConfigureTestDependencies(ProxyService* proxy_service) {
-    cert_verifier_.reset(new net::MockCertVerifier);
-    transport_security_state_.reset(new TransportSecurityState);
+    // Create a context with delayed initialization.
+    context_.reset(new TestURLRequestContext(true));
+
     proxy_service_.reset(proxy_service);
-    HttpNetworkSession::Params session_params;
-    session_params.client_socket_factory = &mock_socket_factory_;
-    session_params.host_resolver = &host_resolver_;
-    session_params.cert_verifier = cert_verifier_.get();
-    session_params.transport_security_state = transport_security_state_.get();
-    session_params.proxy_service = proxy_service_.get();
-    session_params.ssl_config_service = ssl_config_service_.get();
-    session_params.http_server_properties =
-        http_server_properties_.GetWeakPtr();
-    network_session_ = new HttpNetworkSession(session_params);
-    factory_.reset(new HttpNetworkLayer(network_session_.get()));
-
     proxy_params_.reset(new TestDataReductionProxyParams());
     network_delegate_.reset(new TestDataReductionProxyNetworkDelegate(
         proxy_params_.get()));
 
-    context_.reset(new URLRequestContext());
-    context_->set_host_resolver(&host_resolver_);
-    context_->set_cert_verifier(cert_verifier_.get());
+    context_->set_client_socket_factory(&mock_socket_factory_);
     context_->set_proxy_service(proxy_service_.get());
-    context_->set_ssl_config_service(ssl_config_service_.get());
-    context_->set_http_transaction_factory(factory_.get());
-    context_->set_http_server_properties(http_server_properties_.GetWeakPtr());
-    context_->set_transport_security_state(transport_security_state_.get());
     context_->set_network_delegate(network_delegate_.get());
+    // This is needed to prevent the test context from adding language headers
+    // to requests.
+    context_->set_http_user_agent_settings(&http_user_agent_settings_);
+
+    context_->Init();
   }
 
   // Simulates a request to a data reduction proxy that may result in bypassing
   // the proxy and retrying the the request.
   // Runs a test with the given request |method| that expects the first response
   // from the server to be |first_response|. If |expected_retry|, the test
   // will expect a retry of the request. A response body will be expected
   // if |expect_response_body|.
   void TestProxyFallback(const char* method,
                          const char* first_response,
@@ skipping 136 matching lines @@
       ASSERT_TRUE(i != retry_info.end());
       EXPECT_TRUE(expected_min_duration <= (*i).second.current_delay);
       EXPECT_TRUE((*i).second.current_delay <= expected_max_duration);
     }
   }
 
  protected:
   base::MessageLoopForIO loop_;
 
   net::MockClientSocketFactory mock_socket_factory_;
-  net::MockHostResolver host_resolver_;
-  scoped_ptr<net::CertVerifier> cert_verifier_;
-  scoped_ptr<TransportSecurityState> transport_security_state_;
   scoped_ptr<ProxyService> proxy_service_;
-  const scoped_refptr<net::SSLConfigService> ssl_config_service_;
-  scoped_refptr<HttpNetworkSession> network_session_;
-  scoped_ptr<HttpNetworkLayer> factory_;
-  net::HttpServerPropertiesImpl http_server_properties_;
   scoped_ptr<TestDataReductionProxyParams> proxy_params_;
   scoped_ptr<TestDataReductionProxyNetworkDelegate> network_delegate_;
+  net::StaticHttpUserAgentSettings http_user_agent_settings_;
 
-  scoped_ptr<URLRequestContext> context_;
+  scoped_ptr<TestURLRequestContext> context_;
 };
 
 // Tests that request are deemed idempotent or not according to the method used.
 TEST_F(DataReductionProxyProtocolTest, TestIdempotency) {
   net::TestURLRequestContext context;
   const struct {
     const char* method;
     bool expected_result;
   } tests[] = {
       { "GET", true },
@@ skipping 324 matching lines @@
    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status());
    EXPECT_EQ(net::OK, r.status().error());
 
   EXPECT_EQ("Bypass message", d.data_received());
 
   // We should have no entries in our bad proxy list.
   TestBadProxies(0, -1, "", "");
 }
 
 }  // namespace data_reduction_proxy