Enable NQE when Cronet Engine is built

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 29 matching lines @@
 #include "net/base/logging_network_change_observer.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/url_util.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "net/nqe/external_estimate_provider.h"
+#include "net/nqe/network_quality_estimator.h"
 #include "net/proxy/proxy_config_service_android.h"
 #include "net/proxy/proxy_service.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_interceptor.h"
 
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
 #include "components/cronet/android/cronet_data_reduction_proxy.h"
@@ skipping 354 matching lines @@
   // android ProxyConfigServices.
   android_proxy_config_service->set_exclude_pac_url(true);
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&CronetURLRequestContextAdapter::InitializeOnNetworkThread,
                  base::Unretained(this), base::Passed(&context_config_),
                  jcaller_ref));
 }
 
 void CronetURLRequestContextAdapter::
-    EnableNetworkQualityEstimatorOnNetworkThread(bool use_local_host_requests,
-                                                 bool use_smaller_responses) {
+    ConfigureNetworkQualityEstimatorOnNetworkThreadForTesting(
+        bool use_local_host_requests,
+        bool use_smaller_responses) {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());

[bengr, 2016/06/07 20:53:16]

DCHECK also that the nqe is enabled.

[tbansal1, 2016/06/07 21:37:16]

The next line calls a function of network_quality_estimator_. If NQE is not
enabled that call will fail result in crash to nullptr. So, that's effectively
same as D-checking if NQE is enabled.

+  network_quality_estimator_->SetUseLocalHostRequestsForTesting(
+      use_local_host_requests);
+  network_quality_estimator_->SetUseSmallResponsesForTesting(
+      use_smaller_responses);
+}
+
+void CronetURLRequestContextAdapter::ConfigureNetworkQualityEstimatorForTesting(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jboolean use_local_host_requests,
+    jboolean use_smaller_responses) {
+  PostTaskToNetworkThread(
+      FROM_HERE,
+      base::Bind(&CronetURLRequestContextAdapter::
+                     ConfigureNetworkQualityEstimatorOnNetworkThreadForTesting,
+                 base::Unretained(this), use_local_host_requests,
+                 use_smaller_responses));
+}
+
+void CronetURLRequestContextAdapter::
+    EnableNetworkQualityEstimatorOnNetworkThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   DCHECK(!network_quality_estimator_);
   network_quality_estimator_.reset(new net::NetworkQualityEstimator(
       std::unique_ptr<net::ExternalEstimateProvider>(),
-      std::map<std::string, std::string>(), use_local_host_requests,
-      use_smaller_responses));
+      std::map<std::string, std::string>()));
   context_->set_network_quality_estimator(network_quality_estimator_.get());
 }
 
 void CronetURLRequestContextAdapter::EnableNetworkQualityEstimator(
     JNIEnv* env,
-    const JavaParamRef<jobject>& jcaller,
-    jboolean use_local_host_requests,
-    jboolean use_smaller_responses) {
+    const JavaParamRef<jobject>& jcaller) {
   PostTaskToNetworkThread(
       FROM_HERE, base::Bind(&CronetURLRequestContextAdapter::
                                 EnableNetworkQualityEstimatorOnNetworkThread,
-                            base::Unretained(this), use_local_host_requests,
-                            use_smaller_responses));
+                            base::Unretained(this)));
 }
 
 void CronetURLRequestContextAdapter::ProvideRTTObservationsOnNetworkThread(
     bool should) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (!network_quality_estimator_)
     return;
   if (should) {
     network_quality_estimator_->AddRTTObserver(this);
   } else {
@@ skipping 110 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_);
+    network_quality_estimator_.reset(new net::NetworkQualityEstimator(
+        std::unique_ptr<net::ExternalEstimateProvider>(),
+        std::map<std::string, std::string>(), false, false));
+    // Set the socket performance watcher factory so that network quality
+    // estimator is notified of socket performance metrics from TCP and QUIC.
+    context_builder.set_socket_performance_watcher_factory(
+        network_quality_estimator_->GetSocketPerformanceWatcherFactory());
+  }
+
   context_ = context_builder.Build();
+  if (network_quality_estimator_)
+    context_->set_network_quality_estimator(network_quality_estimator_.get());
 
   if (config->load_disable_cache)
     default_load_flags_ |= net::LOAD_DISABLE_CACHE;
 
   if (config->enable_sdch) {
     DCHECK(context_->sdch_manager());
     sdch_owner_.reset(
         new net::SdchOwner(context_->sdch_manager(), context_.get()));
     if (json_pref_store_) {
       sdch_owner_->EnablePersistentStorage(
@@ skipping 207 matching lines @@
     jboolean jhttp2_enabled,
     jboolean jsdch_enabled,
     const JavaParamRef<jstring>& jdata_reduction_proxy_key,
     const JavaParamRef<jstring>& jdata_reduction_proxy_primary_proxy,
     const JavaParamRef<jstring>& jdata_reduction_proxy_fallback_proxy,
     const JavaParamRef<jstring>& jdata_reduction_proxy_secure_proxy_check_url,
     jboolean jdisable_cache,
     jint jhttp_cache_mode,
     jlong jhttp_cache_max_size,
     const JavaParamRef<jstring>& jexperimental_quic_connection_options,
-    jlong jmock_cert_verifier) {
+    jlong jmock_cert_verifier,
+    jboolean jenable_network_quality_estimator) {
   return reinterpret_cast<jlong>(new URLRequestContextConfig(
       jquic_enabled,
       ConvertNullableJavaStringToUTF8(env, jquic_default_user_agent_id),
       jhttp2_enabled, jsdch_enabled,
       static_cast<URLRequestContextConfig::HttpCacheType>(jhttp_cache_mode),
       jhttp_cache_max_size, jdisable_cache,
       ConvertNullableJavaStringToUTF8(env, jstorage_path),
       ConvertNullableJavaStringToUTF8(env, juser_agent),
       ConvertNullableJavaStringToUTF8(env,
                                       jexperimental_quic_connection_options),
       ConvertNullableJavaStringToUTF8(env, jdata_reduction_proxy_key),
       ConvertNullableJavaStringToUTF8(env, jdata_reduction_proxy_primary_proxy),
       ConvertNullableJavaStringToUTF8(env,
                                       jdata_reduction_proxy_fallback_proxy),
       ConvertNullableJavaStringToUTF8(
           env, jdata_reduction_proxy_secure_proxy_check_url),
       base::WrapUnique(
-          reinterpret_cast<net::CertVerifier*>(jmock_cert_verifier))));
+          reinterpret_cast<net::CertVerifier*>(jmock_cert_verifier)),
+      jenable_network_quality_estimator));
 }
 
 // Add a QUIC hint to a URLRequestContextConfig.
 static void AddQuicHint(JNIEnv* env,
                         const JavaParamRef<jclass>& jcaller,
                         jlong jurl_request_context_config,
                         const JavaParamRef<jstring>& jhost,
                         jint jport,
                         jint jalternate_port) {
   URLRequestContextConfig* config =
@@ skipping 72 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   base::StatisticsRecorder::Initialize();
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet