[Cronet] Expose quic_user_agent_id and quic_prefer_aes config options.

components/cronet/url_request_context_config.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/url_request_context_config.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
     "store_server_configs_in_properties";
 const char kQuicMaxServerConfigsStoredInProperties[] =
     "max_server_configs_stored_in_properties";
 const char kQuicDelayTcpRace[] = "delay_tcp_race";
 const char kQuicMaxNumberOfLossyConnections[] =
     "max_number_of_lossy_connections";
 const char kQuicPacketLossThreshold[] = "packet_loss_threshold";
 const char kQuicIdleConnectionTimeoutSeconds[] =
     "idle_connection_timeout_seconds";
 const char kQuicHostWhitelist[] = "host_whitelist";
+const char kQuicPreferAes[] = "prefer_aes";
 
 // AsyncDNS experiment dictionary name.
 const char kAsyncDnsFieldTrialName[] = "AsyncDNS";
 // Name of boolean to enable AsyncDNS experiment.
 const char kAsyncDnsEnable[] = "enable";
 
 void ParseAndSetExperimentalOptions(
     const std::string& experimental_options,
     net::URLRequestContextBuilder* context_builder,
     net::NetLog* net_log) {
@@ skipping 73 matching lines @@
     std::string quic_host_whitelist;
     if (quic_args->GetString(kQuicHostWhitelist, &quic_host_whitelist)) {
       std::unordered_set<std::string> hosts;
       for (const std::string& host :
            base::SplitString(quic_host_whitelist, ",", base::TRIM_WHITESPACE,
                              base::SPLIT_WANT_ALL)) {
         hosts.insert(host);
       }
       context_builder->set_quic_host_whitelist(hosts);
     }
+
+    bool quic_prefer_aes = false;
+    if (quic_args->GetBoolean(kQuicPreferAes, &quic_prefer_aes)) {
+      context_builder->set_quic_prefer_aes(quic_prefer_aes);
+    }
   }
 
   const base::DictionaryValue* async_dns_args = nullptr;
   if (dict->GetDictionary(kAsyncDnsFieldTrialName, &async_dns_args)) {
     bool async_dns_enable = false;
     if (async_dns_args->GetBoolean(kAsyncDnsEnable, &async_dns_enable) &&
         async_dns_enable) {
       if (net_log == nullptr) {
         DCHECK(false) << "AsyncDNS experiment requires NetLog.";
       } else {
@@ skipping 19 matching lines @@
                                   bool include_subdomains,
                                   const base::Time& expiration_date)
     : host(host),
       include_subdomains(include_subdomains),
       expiration_date(expiration_date) {}
 
 URLRequestContextConfig::Pkp::~Pkp() {}
 
 URLRequestContextConfig::URLRequestContextConfig(
     bool enable_quic,
+    const std::string& quic_user_agent_id,
     bool enable_spdy,
     bool enable_sdch,
     HttpCacheType http_cache,
     int http_cache_max_size,
     bool load_disable_cache,
     const std::string& storage_path,
     const std::string& user_agent,
     const std::string& experimental_options,
     const std::string& data_reduction_proxy_key,
     const std::string& data_reduction_primary_proxy,
     const std::string& data_reduction_fallback_proxy,
     const std::string& data_reduction_secure_proxy_check_url,
     scoped_ptr<net::CertVerifier> mock_cert_verifier)
     : enable_quic(enable_quic),
+      quic_user_agent_id(quic_user_agent_id),
       enable_spdy(enable_spdy),
       enable_sdch(enable_sdch),
       http_cache(http_cache),
       http_cache_max_size(http_cache_max_size),
       load_disable_cache(load_disable_cache),
       storage_path(storage_path),
       user_agent(user_agent),
       experimental_options(experimental_options),
       data_reduction_proxy_key(data_reduction_proxy_key),
       data_reduction_primary_proxy(data_reduction_primary_proxy),
@@ skipping 18 matching lines @@
           net::URLRequestContextBuilder::HttpCacheParams::IN_MEMORY;
     }
     cache_params.max_size = http_cache_max_size;
     context_builder->EnableHttpCache(cache_params);
   } else {
     context_builder->DisableHttpCache();
   }
   context_builder->set_user_agent(user_agent);
   context_builder->SetSpdyAndQuicEnabled(enable_spdy, enable_quic);
   context_builder->set_sdch_enabled(enable_sdch);
+  context_builder->set_quic_user_agent_id(quic_user_agent_id);
 
   ParseAndSetExperimentalOptions(experimental_options, context_builder,
                                  net_log);
 
   if (mock_cert_verifier)
     context_builder->SetCertVerifier(std::move(mock_cert_verifier));
   // TODO(mef): Use |config| to set cookies.
 }
 
 }  // namespace cronet