[Chromecast] Enable QUIC for Chromecast.

chromecast/browser/url_request_context_factory.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 "chromecast/browser/url_request_context_factory.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 147 matching lines @@
   std::unique_ptr<net::URLRequestContext> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(MainURLRequestContextGetter);
 };
 
 URLRequestContextFactory::URLRequestContextFactory()
     : app_network_delegate_(CastNetworkDelegate::Create()),
       system_network_delegate_(CastNetworkDelegate::Create()),
       system_dependencies_initialized_(false),
       main_dependencies_initialized_(false),
-      media_dependencies_initialized_(false) {
-}
+      media_dependencies_initialized_(false),
+      enable_quic_(true) {}
 
 URLRequestContextFactory::~URLRequestContextFactory() {
 }
 
 void URLRequestContextFactory::InitializeOnUIThread(net::NetLog* net_log) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // Cast http user agent settings must be initialized in UI thread
   // because it registers itself to pref notification observer which is not
   // thread safe.
   http_user_agent_settings_.reset(new CastHttpUserAgentSettings());
@@ skipping 120 matching lines @@
   if (media_dependencies_initialized_)
     return;
 
   media_transaction_factory_.reset(transaction_factory);
   media_dependencies_initialized_ = true;
 }
 
 void URLRequestContextFactory::PopulateNetworkSessionParams(
     bool ignore_certificate_errors,
     net::HttpNetworkSession::Params* params) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   params->host_resolver = host_resolver_.get();
   params->cert_verifier = cert_verifier_.get();
   params->channel_id_service = channel_id_service_.get();
   params->ssl_config_service = ssl_config_service_.get();
   params->transport_security_state = transport_security_state_.get();
   params->cert_transparency_verifier = cert_transparency_verifier_.get();
   params->ct_policy_enforcer = ct_policy_enforcer_.get();
   params->http_auth_handler_factory = http_auth_handler_factory_.get();
   params->http_server_properties = http_server_properties_.get();
   params->ignore_certificate_errors = ignore_certificate_errors;
   params->proxy_service = proxy_service_.get();
+
+  LOG(INFO) << "Set HttpNetworkSessionParams.enable_quic = " << enable_quic_;
+  params->enable_quic = enable_quic_;
 }
 
 net::URLRequestContext* URLRequestContextFactory::CreateSystemRequestContext() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   InitializeSystemContextDependencies();
   net::HttpNetworkSession::Params system_params;
   PopulateNetworkSessionParams(false, &system_params);
   system_transaction_factory_.reset(new net::HttpNetworkLayer(
       new net::HttpNetworkSession(system_params)));
   system_job_factory_.reset(new net::URLRequestJobFactoryImpl());
@@ skipping 89 matching lines @@
   return main_context;
 }
 
 void URLRequestContextFactory::InitializeNetworkDelegates() {
   app_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized app network delegate.";
   system_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized system network delegate.";
 }
 
+void URLRequestContextFactory::DisableQuic() {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&URLRequestContextFactory::DisableQuicOnBrowserIOThread,
+                 base::Unretained(this)));
+}
+
+void URLRequestContextFactory::DisableQuicOnBrowserIOThread() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (!enable_quic_)
+    return;
+
+  LOG(INFO) << "Disabled QUIC.";
+
+  enable_quic_ = false;
+
+  if (main_getter_) {
+    main_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+
+  if (system_getter_) {
+    system_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+
+  if (media_getter_) {
+    media_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+}
+
 }  // namespace shell
 }  // namespace chromecast