Add functionality for embedders to configure NQE

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 <map>
 #include <utility>
 
+#include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "components/cronet/stale_host_resolver.h"
 #include "net/base/address_family.h"
 #include "net/cert/caching_cert_verifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/multi_threaded_cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/http/http_server_properties.h"
+#include "net/nqe/network_quality_estimator_params.h"
 #include "net/quic/chromium/quic_utils_chromium.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace cronet {
 
 namespace {
 
 // Name of disk cache directory.
@@ skipping 36 matching lines @@
 const char kStaleDnsMaxStaleUses[] = "max_stale_uses";
 // Name of boolean to allow stale DNS results from other networks to be used on
 // the current network.
 const char kStaleDnsAllowOtherNetwork[] = "allow_other_network";
 
 // Rules to override DNS resolution. Intended for testing.
 // See explanation of format in net/dns/mapped_host_resolver.h.
 const char kHostResolverRulesFieldTrialName[] = "HostResolverRules";
 const char kHostResolverRules[] = "host_resolver_rules";
 
+// NetworkQualityEstimator experiment dictionary name.
+const char kNetworkQualityEstimatorFieldTrialName[] = "NetworkQualityEstimator";
+
 // Disable IPv6 when on WiFi. This is a workaround for a known issue on certain
 // Android phones, and should not be necessary when not on one of those devices.
 // See https://crbug.com/696569 for details.
 const char kDisableIPv6OnWifi[] = "disable_ipv6_on_wifi";
 
 const char kSSLKeyLogFile[] = "ssl_key_log_file";
 
 }  // namespace
 
 URLRequestContextConfig::QuicHint::QuicHint(const std::string& host,
@@ skipping 31 matching lines @@
     : enable_quic(enable_quic),
       quic_user_agent_id(quic_user_agent_id),
       enable_spdy(enable_spdy),
       enable_sdch(enable_sdch),
       enable_brotli(enable_brotli),
       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),
       mock_cert_verifier(std::move(mock_cert_verifier)),
       enable_network_quality_estimator(enable_network_quality_estimator),
       bypass_public_key_pinning_for_local_trust_anchors(
           bypass_public_key_pinning_for_local_trust_anchors),
-      cert_verifier_data(cert_verifier_data) {}
+      cert_verifier_data(cert_verifier_data),
+      experimental_options(experimental_options) {}
 
 URLRequestContextConfig::~URLRequestContextConfig() {}
 
 void URLRequestContextConfig::ParseAndSetExperimentalOptions(
     net::URLRequestContextBuilder* context_builder,
     net::NetLog* net_log,
     const scoped_refptr<base::SequencedTaskRunner>& file_task_runner) {
+  nqe_params.reset(new net::NetworkQualityEstimatorParams(

[mgersh, 2017/06/28 18:26:50]

base::MakeUnique is preferred over raw new.

[tbansal1, 2017/06/29 01:17:58]

Done.

+      std::map<std::string, std::string>()));
   if (experimental_options.empty())
     return;
 
   DCHECK(net_log);
 
   DVLOG(1) << "Experimental Options:" << experimental_options;
   std::unique_ptr<base::Value> options =
       base::JSONReader::Read(experimental_options);
 
   if (!options) {
@@ skipping 162 matching lines @@
         if (!ssl_key_log_file.empty() && file_task_runner) {
           // SetSSLKeyLogFile is only safe to call before any SSLClientSockets
           // are created. This should not be used if there are multiple
           // CronetEngine.
           // TODO(xunjieli): Expose this as a stable API after crbug.com/458365
           // is resolved.
           net::SSLClientSocket::SetSSLKeyLogFile(ssl_key_log_file,
                                                  file_task_runner);
         }
       }
+    } else if (it.key() == kNetworkQualityEstimatorFieldTrialName) {
+      const base::DictionaryValue* nqe_args = nullptr;
+      if (!it.value().GetAsDictionary(&nqe_args)) {
+        LOG(ERROR) << "\"" << it.key() << "\" config params \"" << it.value()
+                   << "\" is not a dictionary value";
+        effective_experimental_options->Remove(it.key(), nullptr);
+        continue;
+      }
+
+      std::string nqe_option;
+      if (nqe_args->GetString("persistent_cache_reading_enabled",

[mgersh, 2017/06/28 18:26:50]

This string can be moved to the top with the other string constants.

[tbansal1, 2017/06/29 01:17:58]

Done.

+                              &nqe_option)) {
+        nqe_params->set_persistent_cache_reading_enabled(
+            nqe_option == "true" ? true : false);

[mgersh, 2017/06/28 18:26:50]

This option could be a boolean instead of a string.

[tbansal1, 2017/06/29 01:17:58]

Thanks, that's much better.

+      }
+
+      if (nqe_args->GetString("effective_connection_type_algorithm",

[mgersh, 2017/06/28 18:26:50]

This string too.

[tbansal1, 2017/06/29 01:17:58]

Done.

+                              &nqe_option)) {
+        nqe_params->SetEffectiveConnectionTypeAlgorithm(
+            net::NetworkQualityEstimatorParams::
+                GetEffectiveConnectionTypeAlgorithmFromString(nqe_option));
+      }
+
+      if (nqe_args->GetString(net::kForceEffectiveConnectionType,
+                              &nqe_option)) {
+        net::EffectiveConnectionType forced_effective_connection_type =
+            net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+        bool effective_connection_type_available =
+            net::GetEffectiveConnectionTypeForName(
+                nqe_option, &forced_effective_connection_type);
+        DCHECK(effective_connection_type_available);

[mgersh, 2017/06/28 18:26:50]

This depends on a user-provided value being correct, so it shouldn't be a
DCHECK, which is for conditions that should be impossible. I'd check it and log
a warning if it fails, and then only set the option in params if it succeeds.

[tbansal1, 2017/06/29 01:17:58]

Done.

+        ALLOW_UNUSED_LOCAL(effective_connection_type_available);
+        nqe_params->SetForcedEffectiveConnectionType(
+            forced_effective_connection_type);
+      }
+
     } else {
       LOG(WARNING) << "Unrecognized Cronet experimental option \"" << it.key()
                    << "\" with params \"" << it.value();
       effective_experimental_options->Remove(it.key(), nullptr);
     }
   }
 
   if (async_dns_enable || stale_dns_enable || host_resolver_rules_enable ||
       disable_ipv6_on_wifi) {
     CHECK(net_log) << "All DNS-related experiments require NetLog.";
@@ skipping 72 matching lines @@
 URLRequestContextConfigBuilder::Build() {
   return base::MakeUnique<URLRequestContextConfig>(
       enable_quic, quic_user_agent_id, enable_spdy, enable_sdch, enable_brotli,
       http_cache, http_cache_max_size, load_disable_cache, storage_path,
       user_agent, experimental_options, std::move(mock_cert_verifier),
       enable_network_quality_estimator,
       bypass_public_key_pinning_for_local_trust_anchors, cert_verifier_data);
 }
 
 }  // namespace cronet