Add SetSupportsQuic method to explicitly specify server that supports QUIC.

components/cronet/android/url_request_context_adapter.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/cronet/android/url_request_context_adapter.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "components/cronet/url_request_context_config.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_logger.h"
 #include "net/cert/cert_verifier.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_layer.h"
-#include "net/http/http_server_properties_impl.h"
+#include "net/http/http_server_properties.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 
 namespace {
 
@@ skipping 110 matching lines @@
     scoped_ptr<URLRequestContextConfig> config) {
   // TODO(mmenke):  Add method to have the builder enable SPDY.
   net::URLRequestContextBuilder context_builder;
   context_builder.set_network_delegate(new BasicNetworkDelegate());
   context_builder.set_proxy_config_service(
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
   config->ConfigureURLRequestContextBuilder(&context_builder);
 
   context_.reset(context_builder.Build());
 
+  // Currently (circa M39) enabling QUIC requires setting probability threshold.
+  if (config->enable_quic) {
+    context_->http_server_properties()
+        ->SetAlternateProtocolProbabilityThreshold(1.0f);
+    if (!config->quic_hints.empty()) {

[Ryan Hamilton, 2014/09/10 20:58:19]

I'm not sure that this guard saves you anything... You might as well just hit
the for() loop, which will terminate once it checks the size of hints. (And it
lets you outdent the code one level.

[mef, 2014/09/12 19:44:33]

Done.

+      for (size_t hint = 0; hint < config->quic_hints.size(); ++hint) {
+        const URLRequestContextConfig::QuicHint& quic_hint =
+            *config->quic_hints[hint];
+        GURL quic_hint_server(quic_hint.server);
+        net::HostPortPair quic_hint_host(quic_hint_server.HostNoBrackets(),
+                                         quic_hint_server.EffectiveIntPort());

[Ryan Hamilton, 2014/09/10 20:58:19]

If you change the types of the QuicHint members, I think you can simplify this
code to some extent.

[mef, 2014/09/12 19:44:33]

As Matt has mention this is de-serialized from JSON strings from Java side. 

+        if (!quic_hint_server.is_valid() ||
+            quic_hint.alternate_port <= std::numeric_limits<uint16>::min() ||
+            quic_hint.alternate_port > std::numeric_limits<uint16>::max() ||
+            quic_hint_host.IsEmpty()) {
+          LOG(ERROR) << "Invalid QUIC hint: " << quic_hint.server;
+          continue;
+        }

[Ryan Hamilton, 2014/09/10 20:58:19]

Does SetAlternateProtocol perform similar checks? If so, perhaps you can skip
this check.

[mef, 2014/09/12 19:44:33]

Umm, SetAlternateProtocol just uses host_port_pair as a key to the map. I've
added this to debug my quic hint insertion issues.

+
+        context_->http_server_properties()->SetAlternateProtocol(
+            quic_hint_host,
+            static_cast<uint16>(quic_hint.alternate_port),
+            net::AlternateProtocol::QUIC,
+            1.0f);
+      }
+    }
+  }
+
   if (VLOG_IS_ON(2)) {
     net_log_observer_.reset(new NetLogObserver());
     context_->net_log()->AddThreadSafeObserver(net_log_observer_.get(),
                                                net::NetLog::LOG_ALL_BUT_BYTES);
   }
 
   delegate_->OnContextInitialized(this);
 }
 
 URLRequestContextAdapter::~URLRequestContextAdapter() {
@@ skipping 37 matching lines @@
   net_log_logger_->StartObserving(context_->net_log());
 }
 
 void URLRequestContextAdapter::StopNetLog() {
   if (net_log_logger_) {
     net_log_logger_->StopObserving();
     net_log_logger_.reset();
   }
 }
 
+void URLRequestContextAdapter::SetQuicHint(const net::HostPortPair& server,
+                                           uint16 alternate_port,
+                                           double probability) {
+  GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServerProperties::SetAlternateProtocol,
+                 context_->http_server_properties(),
+                 server,
+                 alternate_port,
+                 net::AlternateProtocol::QUIC,
+                 probability));
+}
+
 void NetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
   VLOG(2) << "Net log entry: type=" << entry.type()
           << ", source=" << entry.source().type << ", phase=" << entry.phase();
 }
 
 }  // namespace cronet