Plumb NQP to context and to http_proxy_client_socket_pool

net/url_request/url_request_context_builder.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_context_builder.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/http/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
 #include "net/net_features.h"
+#include "net/nqe/network_quality_estimator.h"
 #include "net/quic/chromium/quic_stream_factory.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
@@ skipping 174 matching lines @@
       request_context->cert_transparency_verifier();
   session_context->ct_policy_enforcer = request_context->ct_policy_enforcer();
   session_context->proxy_service = request_context->proxy_service();
   session_context->ssl_config_service = request_context->ssl_config_service();
   session_context->http_auth_handler_factory =
       request_context->http_auth_handler_factory();
   session_context->http_server_properties =
       request_context->http_server_properties();
   session_context->net_log = request_context->net_log();
   session_context->channel_id_service = request_context->channel_id_service();
+  session_context->network_quality_provider =
+      request_context->network_quality_estimator();
 }
 
 void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
   http_cache_enabled_ = true;
   http_cache_params_ = params;
 }
 
 void URLRequestContextBuilder::DisableHttpCache() {
   http_cache_enabled_ = false;
   http_cache_params_ = HttpCacheParams();
@@ skipping 166 matching lines @@
   }
   storage->set_proxy_service(std::move(proxy_service_));
 
   HttpNetworkSession::Context network_session_context;
   SetHttpNetworkSessionComponents(context.get(), &network_session_context);
 
   if (proxy_delegate_) {
     network_session_context.proxy_delegate = proxy_delegate_.get();
     storage->set_proxy_delegate(std::move(proxy_delegate_));
   }
   if (socket_performance_watcher_factory_) {

[mmenke, 2017/06/07 21:31:26]

Should we instead get rid of socket_performance_watcher_factory_, and instead
have:

if (network_quality_estimator_) {
  network_session_context.socket_performance_watcher_factory =
      network_quality_estimator_->GetSocketPerformanceWatcherFactory();
}

Could even move that logic into SetHttpNetworkSessionComponents

[tbansal1, 2017/06/08 05:01:50]

Doing in a separate CL.

     network_session_context.socket_performance_watcher_factory =
         socket_performance_watcher_factory_;
+    DCHECK(network_session_context.network_quality_provider);
   }
 
   storage->set_http_network_session(base::MakeUnique<HttpNetworkSession>(
       http_network_session_params_, network_session_context));
 
   std::unique_ptr<HttpTransactionFactory> http_transaction_factory;
   if (http_cache_enabled_) {
     std::unique_ptr<HttpCache::BackendFactory> http_cache_backend;
     if (http_cache_params_.type != HttpCacheParams::IN_MEMORY) {
       BackendType backend_type =
@@ skipping 65 matching lines @@
     std::unique_ptr<ProxyConfigService> proxy_config_service,
     URLRequestContext* url_request_context,
     HostResolver* host_resolver,
     NetworkDelegate* network_delegate,
     NetLog* net_log) {
   return ProxyService::CreateUsingSystemProxyResolver(
       std::move(proxy_config_service), net_log);
 }
 
 }  // namespace net