[Cronet] Add QUIC experimental params

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 "base/basictypes.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "net/cert/cert_verifier.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace cronet {
 
 namespace {
 
 // TODO(xunjieli): Refactor constants in io_thread.cc.
 const char kQuicFieldTrialName[] = "QUIC";
 const char kQuicConnectionOptions[] = "connection_options";
+const char kQuicStoreServerConfigsInProperties[] =
+    "store_server_configs_in_properties";
+const char kQuicDelayTcpRace[] = "delay_tcp_race";
+const char kQuicMaxNumberOfLossyConnections[] =
+    "max_number_of_lossy_connections";
+const char kQuicPacketLossThreshold[] = "packet_loss_threshold";
 
 // Using a reference to scoped_ptr is unavoidable because of the semantics of
 // RegisterCustomField.
 // TODO(xunjieli): Remove this once crbug.com/544976 is fixed.
 bool GetMockCertVerifierFromString(
     const base::StringPiece& mock_cert_verifier_string,
     scoped_ptr<net::CertVerifier>* result) {
   int64 val;
   bool success = base::StringToInt64(mock_cert_verifier_string, &val);
   *result = make_scoped_ptr(reinterpret_cast<net::CertVerifier*>(val));
   return success;
 }
 
 void ParseAndSetExperimentalOptions(
     const std::string& experimental_options,
     net::URLRequestContextBuilder* context_builder) {
   if (experimental_options.empty())
     return;
 
+  VLOG(1) << "Experimental Options:" << experimental_options;

[ramant (doing other things), 2015/11/18 21:22:08]

nit: is this intentional? Should we do DVLOG(1)?

[xunjieli, 2015/11/18 21:52:55]

Done.

   scoped_ptr<base::Value> options =
       base::JSONReader::Read(experimental_options);
 
   if (!options) {
     DCHECK(false) << "Parsing experimental options failed: "
                   << experimental_options;
     return;
   }
 
   scoped_ptr<base::DictionaryValue> dict =
       base::DictionaryValue::From(options.Pass());
 
   if (!dict) {
     DCHECK(false) << "Experimental options string is not a dictionary: "
                   << experimental_options;
     return;
   }
 
   const base::DictionaryValue* quic_args = nullptr;
   if (dict->GetDictionary(kQuicFieldTrialName, &quic_args)) {
     std::string quic_connection_options;
     if (quic_args->GetString(kQuicConnectionOptions,
                              &quic_connection_options)) {
       context_builder->set_quic_connection_options(
           net::QuicUtils::ParseQuicConnectionOptions(quic_connection_options));
     }
+
+    bool quic_store_server_configs_in_properties = false;
+    if (quic_args->GetBoolean(kQuicStoreServerConfigsInProperties,
+                              &quic_store_server_configs_in_properties)) {
+      context_builder->set_quic_store_server_configs_in_properties(
+          quic_store_server_configs_in_properties);
+    }
+
+    bool quic_delay_tcp_race = false;
+    if (quic_args->GetBoolean(kQuicDelayTcpRace, &quic_delay_tcp_race)) {
+      context_builder->set_quic_delay_tcp_race(quic_delay_tcp_race);
+    }
+
+    int quic_max_number_of_lossy_connections = 0;
+    if (quic_args->GetInteger(kQuicMaxNumberOfLossyConnections,
+                              &quic_max_number_of_lossy_connections)) {
+      context_builder->set_quic_max_number_of_lossy_connections(
+          quic_max_number_of_lossy_connections);
+    }
+
+    double quic_packet_loss_threshold = 0.0;
+    if (quic_args->GetDouble(kQuicPacketLossThreshold,
+                             &quic_packet_loss_threshold)) {
+      context_builder->set_quic_packet_loss_threshold(
+          quic_packet_loss_threshold);
+    }
   }
 }
 
 }  // namespace
 
 #define DEFINE_CONTEXT_CONFIG(x) const char REQUEST_CONTEXT_CONFIG_##x[] = #x;
 #include "components/cronet/url_request_context_config_list.h"
 #undef DEFINE_CONTEXT_CONFIG
 
 URLRequestContextConfig::QuicHint::QuicHint() {
@@ skipping 101 matching lines @@
       &URLRequestContextConfig::data_reduction_proxy_key);
 
   // For Testing.
   converter->RegisterCustomField<scoped_ptr<net::CertVerifier>>(
       REQUEST_CONTEXT_CONFIG_MOCK_CERT_VERIFIER,
       &URLRequestContextConfig::mock_cert_verifier,
       &GetMockCertVerifierFromString);
 }
 
 }  // namespace cronet