Add a NetworkQualityEstimator to TestURLRequestContext.

net/url_request/url_request_test_util.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/url_request/url_request_test_util.h"
 
+#include <map>
+#include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/host_port_pair.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
+#include "net/nqe/external_estimate_provider.h"
 #include "net/proxy/proxy_retry_info.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
@@ skipping 13 matching lines @@
 const int kStageCompletedSuccess = 1 << 7;
 const int kStageCompletedError = 1 << 8;
 const int kStageURLRequestDestroyed = 1 << 9;
 const int kStageDestruction = 1 << 10;
 
 }  // namespace
 
 TestURLRequestContext::TestURLRequestContext() : TestURLRequestContext(false) {}
 
 TestURLRequestContext::TestURLRequestContext(bool delay_initialization)
-    : context_storage_(this) {
+    : network_quality_estimator_(std::unique_ptr<ExternalEstimateProvider>(),
+                                 std::map<std::string, std::string>()),
+      context_storage_(this) {
   if (!delay_initialization)
     Init();
 }
 
 TestURLRequestContext::~TestURLRequestContext() {
   DCHECK(initialized_);
   AssertNoURLRequests();
 }
 
 void TestURLRequestContext::Init() {
@@ skipping 34 matching lines @@
     context_storage_.set_cookie_store(
         base::MakeUnique<CookieMonster>(nullptr, nullptr));
   }
   // In-memory Channel ID service.  Must be created before the
   // HttpNetworkSession.
   if (!channel_id_service()) {
     context_storage_.set_channel_id_service(base::MakeUnique<ChannelIDService>(
         new DefaultChannelIDStore(nullptr),
         base::WorkerPool::GetTaskRunner(true)));
   }
+
+  if (!network_quality_estimator())
+    set_network_quality_estimator(&network_quality_estimator_);
+
   if (http_transaction_factory()) {
     // Make sure we haven't been passed an object we're not going to use.
     EXPECT_FALSE(client_socket_factory_);
   } else {
     HttpNetworkSession::Params params;
 
     if (http_network_session_params_)
       params = *http_network_session_params_;
     params.client_socket_factory = client_socket_factory();
     params.proxy_delegate = proxy_delegate();
     params.host_resolver = host_resolver();
     params.cert_verifier = cert_verifier();
     params.cert_transparency_verifier = cert_transparency_verifier();
     params.ct_policy_enforcer = ct_policy_enforcer();
     params.transport_security_state = transport_security_state();
     params.proxy_service = proxy_service();
     params.ssl_config_service = ssl_config_service();
     params.http_auth_handler_factory = http_auth_handler_factory();
     params.http_server_properties = http_server_properties();
     params.net_log = net_log();
     params.channel_id_service = channel_id_service();
+    params.socket_performance_watcher_factory =

[tbansal1, 2016/11/14 20:26:01]

Currently, the problem is that in some tests, |params| does not have NQE set.
With this fix, NQE will be set for params, but in some tests, |params| will have
a different NQE than the context.

Would a better solution be for NQE tests to override the |params| too?
Similar to:
https://cs.chromium.org/chromium/src/net/nqe/network_quality_estimator_unitte...
If yes, I can do that for all NQE tests since I have already done it for one
other test. wdyt?

[mmenke, 2016/11/14 20:29:52]

A better solution instead of this CL, or in addition to this CL?

The goal of this CL is to make TestURLRequestContext better reflect the main
URLRequestContext in production code, and that includes the NQE.  Even if most
tests using the TestURLRequestContext don't explicitly check the NQE, this will
let them exercise its code, and make sure it doesn't crash or DCHECK under a
greater variety of circumstances than it makes sense to have explicit NQE tests
for.

[tbansal1, 2016/11/14 20:39:27]

"In addition to". OK, I will do that after this CL is submitted.
Got it.

+        network_quality_estimator()->GetSocketPerformanceWatcherFactory();
     context_storage_.set_http_network_session(
         base::MakeUnique<HttpNetworkSession>(params));
     context_storage_.set_http_transaction_factory(base::MakeUnique<HttpCache>(
         context_storage_.http_network_session(),
         HttpCache::DefaultBackend::InMemory(0), false));
   }
   if (!http_user_agent_settings()) {
     context_storage_.set_http_user_agent_settings(
         base::MakeUnique<StaticHttpUserAgentSettings>("en-us,fr",
                                                       std::string()));
@@ skipping 526 matching lines @@
     NetworkDelegate* network_delegate) const {
   return main_intercept_job_.release();
 }
 
 void TestJobInterceptor::set_main_intercept_job(
     std::unique_ptr<URLRequestJob> job) {
   main_intercept_job_ = std::move(job);
 }
 
 }  // namespace net