[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_;

[halliwell, 2017/01/27 04:32:53]

how frequently does this get logged?  Just want to make sure it's not going to
be spammy.

[mbjorge, 2017/01/27 06:22:20]

It'll get logged a max of 3 times, once for each of the
Main/System/MediaContextGetters when they get created.

+  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)));

[halliwell, 2017/01/27 04:32:53]

Should this be done with weak ptr, or is there a guarantee that this object
lives until posted task is run?

[mbjorge, 2017/01/27 06:22:20]

URLRequestContextFactory is owned by CastContentBrowserClient, so it will live
as long as that does, which to my understanding was the entire life of
cast_shell, since it's getting created/owned by CastMainDelegate in
cast_main.cc, so it should outlive basically everything.

I don't see harm in adding it though, so I'm happy to add it if it makes it more
obviously safe to a reader. I've tried just adding a comment for now describing
why it should be safe. 

[halliwell, 2017/01/27 18:35:35]

That's fine, looks good.

+}
+
+void URLRequestContextFactory::DisableQuicOnBrowserIOThread() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (!enable_quic_)
+    return;
+
+  LOG(INFO) << "Disabled QUIC.";
+
+  // Disable QUIC for any new URLContextGetter that gets created.

[halliwell, 2017/01/27 04:32:53]

this and the next 3 comments don't add value (what the code does is
self-evident)

[mbjorge, 2017/01/27 06:22:20]

done

+  enable_quic_ = false;
+
+  // Disable QUIC for the main URLContext.
+  if (main_getter_) {
+    main_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+
+  // Disable QUIC for the system URLContext.
+  if (system_getter_) {
+    system_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+
+  // Disable QUIC for the media URLContext.
+  if (media_getter_) {
+    media_getter_->GetURLRequestContext()
+        ->http_transaction_factory()
+        ->GetSession()
+        ->DisableQuic();
+  }
+}
+
 }  // namespace shell
 }  // namespace chromecast