Add functionality for embedders to configure NQE

components/cronet/android/cronet_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/cronet_url_request_context_adapter.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 589 matching lines @@
 void CronetURLRequestContextAdapter::ProvideThroughputObservations(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     bool should) {
   PostTaskToNetworkThread(
       FROM_HERE, base::Bind(&CronetURLRequestContextAdapter::
                                 ProvideThroughputObservationsOnNetworkThread,
                             base::Unretained(this), should));
 }
 
+void CronetURLRequestContextAdapter::InitializeNQEPrefsOnNetworkThread() const {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+
+  // Initializing |network_qualities_prefs_manager_| may post a callback to
+  // |this|. So, |network_qualities_prefs_manager_| should be initialized after
+  // |jcronet_url_request_context_| has been constructed.
+  DCHECK(jcronet_url_request_context_.obj() != nullptr);
+  network_qualities_prefs_manager_->InitializeOnNetworkThread(
+      network_quality_estimator_.get());
+}
+
 void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     std::unique_ptr<URLRequestContextConfig> config,
     const base::android::ScopedJavaGlobalRef<jobject>&
         jcronet_url_request_context) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   DCHECK(!is_context_initialized_);
   DCHECK(proxy_config_service_);
 
   // TODO(mmenke):  Add method to have the builder enable SPDY.
   net::URLRequestContextBuilder context_builder;
@@ skipping 61 matching lines @@
   // Explicitly disable the persister for Cronet to avoid persistence of dynamic
   // HPKP. This is a safety measure ensuring that nobody enables the persistence
   // of HPKP by specifying transport_security_persister_path in the future.
   context_builder.set_transport_security_persister_path(base::FilePath());
 
   // Disable net::CookieStore and net::ChannelIDService.
   context_builder.SetCookieAndChannelIdStores(nullptr, nullptr);
 
   if (config->enable_network_quality_estimator) {
     DCHECK(!network_quality_estimator_);
-    std::map<std::string, std::string> variation_params;
-    // Configure network quality estimator: Specify the algorithm that should
-    // be used for computing the effective connection type. The algorithm
-    // is specified using the key-value pairs defined in
-    // //net/nqe/network_quality_estimator.cc.
-    // TODO(tbansal): Investigate a more robust way of configuring the network
-    // quality estimator.
-    variation_params["effective_connection_type_algorithm"] =
-        "TransportRTTOrDownstreamThroughput";
+    std::unique_ptr<net::NetworkQualityEstimatorParams> nqe_params =
+        base::MakeUnique<net::NetworkQualityEstimatorParams>(
+            std::map<std::string, std::string>());
+    nqe_params->set_persistent_cache_reading_enabled(
+        config->nqe_persistent_caching_enabled);
+    if (config->nqe_forced_effective_connection_type) {
+      nqe_params->SetForcedEffectiveConnectionType(
+          config->nqe_forced_effective_connection_type.value());
+    }
+
     network_quality_estimator_ = base::MakeUnique<net::NetworkQualityEstimator>(
-        std::unique_ptr<net::ExternalEstimateProvider>(),
-        base::MakeUnique<net::NetworkQualityEstimatorParams>(variation_params),
+        std::unique_ptr<net::ExternalEstimateProvider>(), std::move(nqe_params),
         g_net_log.Get().net_log());
     network_quality_estimator_->AddEffectiveConnectionTypeObserver(this);
     network_quality_estimator_->AddRTTAndThroughputEstimatesObserver(this);
 
     // Set up network quality prefs if the storage path is specified.
     if (!config->storage_path.empty()) {
       DCHECK(!network_qualities_prefs_manager_);
       network_qualities_prefs_manager_ =
           base::MakeUnique<net::NetworkQualitiesPrefsManager>(
               base::MakeUnique<NetworkQualitiesPrefDelegateImpl>(
                   pref_service_.get()));
-      network_qualities_prefs_manager_->InitializeOnNetworkThread(
-          network_quality_estimator_.get());
+      PostTaskToNetworkThread(FROM_HERE,
+                              base::Bind(&CronetURLRequestContextAdapter::
+                                             InitializeNQEPrefsOnNetworkThread,
+                                         base::Unretained(this)));
     }
     context_builder.set_network_quality_estimator(
         network_quality_estimator_.get());
   }
 
   context_ = context_builder.Build();
 
   // Set up host cache persistence if it's enabled. Happens after building the
   // URLRequestContext to get access to the HostCache.
   if (pref_service_ && config->enable_host_cache_persistence) {
@@ skipping 468 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   DCHECK(base::StatisticsRecorder::IsActive());
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet