Populate EEP estimate in NQE

net/base/network_quality_estimator.cc

Index: net/base/network_quality_estimator.cc
diff --git a/net/base/network_quality_estimator.cc b/net/base/network_quality_estimator.cc
index fdd2212adfb1b4c4853d6be76456ce0e990ef8a7..c5cc320e94e5f9c9b630c0bbf9cbc91d22729c09 100644
--- a/net/base/network_quality_estimator.cc
+++ b/net/base/network_quality_estimator.cc
@@ -10,10 +10,13 @@
 #include <limits>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/task_runner.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
@@ -140,7 +143,10 @@ NetworkQualityEstimator::NetworkQualityEstimator(
       downstream_throughput_kbps_observations_(
           GetWeightMultiplierPerSecond(variation_params)),
       rtt_msec_observations_(GetWeightMultiplierPerSecond(variation_params)),
-      external_estimates_provider_(external_estimates_provider.Pass()) {
+      external_estimates_provider_(external_estimates_provider.Pass()),
+      eep_queried_(base::TimeTicks()),

[bengr, 2015/09/02 20:27:56]

Don't use eep.

[tbansal1, 2015/09/03 00:22:40]

Done.

+      eep_delayed_task_posted_(false),
+      weak_factory_(this) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   static_assert(kDefaultHalfLifeSeconds > 0,
@@ -154,8 +160,17 @@ NetworkQualityEstimator::NetworkQualityEstimator(
 
   ObtainOperatingParams(variation_params);
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
-  if (external_estimates_provider_)
+  if (external_estimates_provider_) {
+    UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus",
+                              EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE,
+                              EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
     external_estimates_provider_->SetUpdatedEstimateDelegate(this);
+    QueryExternalEstimateProvider();
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus",
+                              EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE,
+                              EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
+  }
   current_network_id_ = GetCurrentNetworkID();
   AddDefaultEstimates();
 }
@@ -774,8 +789,66 @@ bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
 
 void NetworkQualityEstimator::OnUpdatedEstimateAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus",
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK,
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
+
+  QueryExternalEstimateProvider();
+}
+
+void NetworkQualityEstimator::QueryExternalEstimateProvider() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(external_estimates_provider_);
-  // TODO(tbansal): Query provider for the recent value.
+
+  UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus",
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED,
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
+
+  base::TimeDelta time_since_last_update;
+  if (!external_estimates_provider_->GetTimeSinceLastUpdate(

[bengr, 2015/09/02 20:27:56]

external_estimate_provider_?

[tbansal1, 2015/09/03 00:22:40]

Done.

+          &time_since_last_update)) {
+    external_estimates_provider_->RequestUpdate();
+    return;
+  }
+
+  eep_queried_ = base::TimeTicks::Now();

[bengr, 2015/09/02 20:27:56]

external_estimate_request_time_. Also, is this used?

[tbansal1, 2015/09/03 00:22:40]

It is used now.

+
+  UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus",
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL,
+                            EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
+
+  base::TimeDelta rtt;
+  if (external_estimates_provider_->GetRTT(&rtt)) {
+    rtt_msec_observations_.AddObservation(Observation(
+        rtt.InMilliseconds(), base::TimeTicks::Now() - time_since_last_update));
+  }
+
+  int32_t downstream_throughput_kbps;
+  if (external_estimates_provider_->GetDownstreamThroughputKbps(
+          &downstream_throughput_kbps)) {
+    downstream_throughput_kbps_observations_.AddObservation(
+        Observation(downstream_throughput_kbps,
+                    base::TimeTicks::Now() - time_since_last_update));
+  }
+
+  if (!eep_delayed_task_posted_ && base::MessageLoop::current()) {

[bengr, 2015/09/02 20:27:56]

eep_delayed_task_posted_ -> external_estimate_pending_?

[tbansal1, 2015/09/03 00:22:40]

Done.

+    base::MessageLoop::current()->task_runner()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(
+            &NetworkQualityEstimator::RunExternalEstimateProviderDelayedTask,
+            weak_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(
+            kExternalEstimateProviderQueryIntervalMsec));
+    eep_delayed_task_posted_ = true;
+  }
+}
+
+void NetworkQualityEstimator::RunExternalEstimateProviderDelayedTask() {

[bengr, 2015/09/02 20:27:56]

I don't understand the flow. Here's what I understand: You start with QEEP and
if there was not a previous update, you request one. Otherwise you get the
previous RTT and throughput values and add them to your observations. You then
post to run QEEP again. 

What I don't understand is what gets new external estimates? Nothing?

Please document the flow. 

[tbansal1, 2015/09/03 00:22:40]

Updated to make it synchronous call. No posting of tasks. It should be clearer
now.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(eep_delayed_task_posted_);
+  eep_delayed_task_posted_ = false;
+  QueryExternalEstimateProvider();
 }
 
 void NetworkQualityEstimator::CacheNetworkQualityEstimate() {