Expose effective connection type to Cronet

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 33 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/url_util.h"
 #include "net/cert/caching_cert_verifier.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 347 matching lines @@
 CronetURLRequestContextAdapter::~CronetURLRequestContextAdapter() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
 
   if (http_server_properties_manager_)
     http_server_properties_manager_->ShutdownOnPrefThread();
   if (pref_service_)
     pref_service_->CommitPendingWrite();
   if (network_quality_estimator_) {
     network_quality_estimator_->RemoveRTTObserver(this);
     network_quality_estimator_->RemoveThroughputObserver(this);
+    network_quality_estimator_->RemoveEffectiveConnectionTypeObserver(this);
   }
   // Stop |write_to_file_observer_| if there is one.
   StopNetLogHelper();
 }
 
 void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller) {
   base::android::ScopedJavaGlobalRef<jobject> jcaller_ref;
   jcaller_ref.Reset(env, jcaller);
@@ skipping 161 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";
     network_quality_estimator_.reset(new net::NetworkQualityEstimator(
-        std::unique_ptr<net::ExternalEstimateProvider>(),
-        std::map<std::string, std::string>(), false, false));
+        std::unique_ptr<net::ExternalEstimateProvider>(), variation_params,
+        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());
+    network_quality_estimator_->AddEffectiveConnectionTypeObserver(this);
   }
 
   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) {
@@ skipping 198 matching lines @@
 
 base::Thread* CronetURLRequestContextAdapter::GetFileThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Network File Thread"));
     file_thread_->Start();
   }
   return file_thread_.get();
 }
 
+void CronetURLRequestContextAdapter::OnEffectiveConnectionTypeChanged(
+    net::EffectiveConnectionType effective_connection_type) {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+  Java_CronetUrlRequestContext_onEffectiveConnectionTypeChanged(
+      base::android::AttachCurrentThread(), jcronet_url_request_context_.obj(),
+      effective_connection_type);
+}
+
 void CronetURLRequestContextAdapter::OnRTTObservation(
     int32_t rtt_ms,
     const base::TimeTicks& timestamp,
     net::NetworkQualityObservationSource source) {
   Java_CronetUrlRequestContext_onRttObservation(
       base::android::AttachCurrentThread(), jcronet_url_request_context_.obj(),
       rtt_ms, (timestamp - base::TimeTicks::UnixEpoch()).InMilliseconds(),
       source);
 }
 
@@ skipping 143 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