Use Android callback API to obtain cellular signal strength

net/nqe/network_quality_estimator.cc

 // Copyright 2015 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 "net/nqe/network_quality_estimator.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 24 matching lines @@
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/nqe/network_quality_estimator_params.h"
 #include "net/nqe/socket_watcher_factory.h"
 #include "net/nqe/throughput_analyzer.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
-#include "net/android/cellular_signal_strength.h"
 #include "net/android/network_library.h"
 #endif  // OS_ANDROID
 
 namespace net {
 
 namespace {
 
 // Returns the histogram that should be used to record the given statistic.
 // |max_limit| is the maximum value that can be stored in the histogram.
 base::HistogramBase* GetHistogram(const std::string& statistic_name,
@@ skipping 190 matching lines @@
                                     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
                                {"TransportRTTOrDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
                                     TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT}}),
       use_localhost_requests_(use_local_host_requests_for_tests),
       use_small_responses_(use_smaller_responses_for_tests),
       disable_offline_check_(false),
       add_default_platform_observations_(add_default_platform_observations),
       weight_multiplier_per_second_(
           nqe::internal::GetWeightMultiplierPerSecond(variation_params)),
-      weight_multiplier_per_dbm_(
-          nqe::internal::GetWeightMultiplierPerDbm(variation_params)),
+      weight_multiplier_per_signal_strength_level_(
+          nqe::internal::GetWeightMultiplierPerSignalStrengthLevel(
+              variation_params)),
       effective_connection_type_algorithm_(
           algorithm_name_to_enum_.find(
               nqe::internal::GetEffectiveConnectionTypeAlgorithm(
                   variation_params)) == algorithm_name_to_enum_.end()
               ? kDefaultEffectiveConnectionTypeAlgorithm
               : algorithm_name_to_enum_
                     .find(nqe::internal::GetEffectiveConnectionTypeAlgorithm(
                         variation_params))
                     ->second),
       tick_clock_(new base::DefaultTickClock()),
       last_connection_change_(tick_clock_->NowTicks()),
       current_network_id_(nqe::internal::NetworkID(
           NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
           std::string())),
-      downstream_throughput_kbps_observations_(weight_multiplier_per_second_,
-                                               weight_multiplier_per_dbm_),
+      downstream_throughput_kbps_observations_(
+          weight_multiplier_per_second_,
+          weight_multiplier_per_signal_strength_level_),
       rtt_observations_(weight_multiplier_per_second_,
-                        weight_multiplier_per_dbm_),
+                        weight_multiplier_per_signal_strength_level_),
       effective_connection_type_at_last_main_frame_(
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       external_estimate_provider_(std::move(external_estimates_provider)),
       effective_connection_type_recomputation_interval_(
           base::TimeDelta::FromSeconds(10)),
       rtt_observations_size_at_last_ect_computation_(0),
       throughput_observations_size_at_last_ect_computation_(0),
       effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
-      signal_strength_dbm_(INT32_MIN),
-      min_signal_strength_since_connection_change_(INT32_MAX),
-      max_signal_strength_since_connection_change_(INT32_MIN),
       correlation_uma_logging_probability_(
           nqe::internal::correlation_uma_logging_probability(variation_params)),
       forced_effective_connection_type_set_(
           nqe::internal::forced_effective_connection_type_set(
               variation_params)),
       forced_effective_connection_type_(
           nqe::internal::forced_effective_connection_type(variation_params)),
       persistent_cache_reading_enabled_(
           nqe::internal::persistent_cache_reading_enabled(variation_params)),
       event_creator_(net_log),
@@ skipping 14 matching lines @@
 
   DCHECK_EQ(algorithm_name_to_enum_.size(),
             static_cast<size_t>(EffectiveConnectionTypeAlgorithm::
                                     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST));
   DCHECK_NE(EffectiveConnectionTypeAlgorithm::
                 EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST,
             effective_connection_type_algorithm_);
 
   network_quality_store_.reset(new nqe::internal::NetworkQualityStore());
   ObtainOperatingParams(variation_params);
+
+#if defined(OS_ANDROID)
+  if (weight_multiplier_per_signal_strength_level_ < 1.0)
+    cellular_signal_strength_.reset(new android::CellularSignalStrength());
+#endif  // OS_ANDROID
+
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
   if (external_estimate_provider_) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE);
     external_estimate_provider_->SetUpdatedEstimateDelegate(this);
   } else {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE);
   }
   current_network_id_ = GetCurrentNetworkID();
@@ skipping 155 matching lines @@
   base::TimeDelta observed_http_rtt =
       load_timing_info.receive_headers_end - load_timing_info.send_start;
   DCHECK_GE(observed_http_rtt, base::TimeDelta());
   if (observed_http_rtt < peak_network_quality_.http_rtt() ||
       peak_network_quality_.http_rtt() == nqe::internal::InvalidRTT()) {
     peak_network_quality_ = nqe::internal::NetworkQuality(
         observed_http_rtt, peak_network_quality_.transport_rtt(),
         peak_network_quality_.downstream_throughput_kbps());
   }
 
-  RttObservation http_rtt_observation(
-      observed_http_rtt, tick_clock_->NowTicks(), signal_strength_dbm_,
-      NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP);
+  RttObservation http_rtt_observation(observed_http_rtt,
+                                      tick_clock_->NowTicks(), signal_strength_,
+                                      NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP);
   rtt_observations_.AddObservation(http_rtt_observation);
   NotifyObserversOfRTT(http_rtt_observation);
 }
 
 void NetworkQualityEstimator::RecordAccuracyAfterMainFrame(
     base::TimeDelta measuring_duration) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0, measuring_duration.InMilliseconds() % 1000);
   DCHECK(ContainsValue(GetAccuracyRecordingIntervals(), measuring_duration));
 
@@ skipping 340 matching lines @@
                                last_effective_connection_type_computation_,
                                network_quality_, effective_connection_type_));
 
   // Clear the local state.
   last_connection_change_ = tick_clock_->NowTicks();
   peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
 
 #if defined(OS_ANDROID)
-  if (weight_multiplier_per_dbm_ < 1.0 &&
+  if (cellular_signal_strength_ &&
       NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type)) {
-    UMA_HISTOGRAM_BOOLEAN(
-        "NQE.CellularSignalStrengthAvailable",
-        min_signal_strength_since_connection_change_ != INT32_MAX &&
-            max_signal_strength_since_connection_change_ != INT32_MIN);
+    bool signal_strength_available =
+        min_signal_strength_since_connection_change_ &&
+        max_signal_strength_since_connection_change_;
+    UMA_HISTOGRAM_BOOLEAN("NQE.CellularSignalStrength.LevelAvailable",
+                          signal_strength_available);
 
-    if (min_signal_strength_since_connection_change_ != INT32_MAX &&
-        max_signal_strength_since_connection_change_ != INT32_MIN) {
+    if (signal_strength_available) {
       UMA_HISTOGRAM_COUNTS_100(
-          "NQE.CellularSignalStrengthDifference",
-          max_signal_strength_since_connection_change_ -
-              min_signal_strength_since_connection_change_);
+          "NQE.CellularSignalStrength.LevelDifference",
+          max_signal_strength_since_connection_change_.value() -
+              min_signal_strength_since_connection_change_.value());
     }
   }
 #endif  // OS_ANDROID
-  signal_strength_dbm_ = INT32_MIN;
-  min_signal_strength_since_connection_change_ = INT32_MAX;
-  max_signal_strength_since_connection_change_ = INT32_MIN;
+  signal_strength_.reset();
+  min_signal_strength_since_connection_change_.reset();
+  max_signal_strength_since_connection_change_.reset();
   network_quality_ = nqe::internal::NetworkQuality();
   effective_connection_type_ = EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   effective_connection_type_at_last_main_frame_ =
       EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   rtt_observations_size_at_last_ect_computation_ = 0;
   throughput_observations_size_at_last_ect_computation_ = 0;
 
   // Update the local state as part of preparation for the new connection.
   current_network_id_ = GetCurrentNetworkID();
   RecordNetworkIDAvailability();
@@ skipping 22 matching lines @@
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_UNKNOWN &&
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_ETHERNET &&
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_BLUETOOTH) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED);
     external_estimate_provider_->Update();
   }
 }
 
 void NetworkQualityEstimator::UpdateSignalStrength() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  signal_strength_.reset();
 #if defined(OS_ANDROID)
-  if (weight_multiplier_per_dbm_ >= 1.0 ||
-      !NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type) ||
-      !android::cellular_signal_strength::GetSignalStrengthDbm(
-          &signal_strength_dbm_)) {
-    signal_strength_dbm_ = INT32_MIN;
-  }
-  min_signal_strength_since_connection_change_ = std::min(
-      min_signal_strength_since_connection_change_, signal_strength_dbm_);
-  max_signal_strength_since_connection_change_ = std::max(
-      max_signal_strength_since_connection_change_, signal_strength_dbm_);
+  if (!cellular_signal_strength_)
+    return;
+  if (!NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type))
+    return;
+
+  signal_strength_ = cellular_signal_strength_->GetSignalStrengthLevel();
+
+  if (!signal_strength_)
+    return;
+
+  min_signal_strength_since_connection_change_ =
+      std::min(min_signal_strength_since_connection_change_.value_or(INT32_MAX),
+               signal_strength_.value());
+  max_signal_strength_since_connection_change_ =
+      std::max(max_signal_strength_since_connection_change_.value_or(INT32_MIN),
+               signal_strength_.value());
 #endif  // OS_ANDROID
 }
 
 void NetworkQualityEstimator::RecordMetricsOnConnectionTypeChanged() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (peak_network_quality_.http_rtt() != nqe::internal::InvalidRTT()) {
     base::HistogramBase* rtt_histogram =
         GetHistogram("FastestRTT.", current_network_id_.type, 10 * 1000);
     rtt_histogram->Add(peak_network_quality_.http_rtt().InMilliseconds());
   }
@@ skipping 432 matching lines @@
     const base::Optional<Statistic>& statistic,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // RTT observations are sorted by duration from shortest to longest, thus
   // a higher percentile RTT will have a longer RTT than a lower percentile.
   base::TimeDelta rtt = nqe::internal::InvalidRTT();
 
   if (!statistic) {
     // Use default statistic algorithm.
-    if (!rtt_observations_.GetPercentile(start_time, signal_strength_dbm_, &rtt,
+    if (!rtt_observations_.GetPercentile(start_time, signal_strength_, &rtt,
                                          percentile,
                                          disallowed_observation_sources)) {
       return nqe::internal::InvalidRTT();
     }
     return rtt;
   }
 
   switch (statistic.value()) {
     case STATISTIC_LAST:
       NOTREACHED();
       return nqe::internal::InvalidRTT();
     case STATISTIC_WEIGHTED_AVERAGE:
-      if (!rtt_observations_.GetWeightedAverage(
-              start_time, signal_strength_dbm_, disallowed_observation_sources,
-              &rtt)) {
+      if (!rtt_observations_.GetWeightedAverage(start_time, signal_strength_,
+                                                disallowed_observation_sources,
+                                                &rtt)) {
         return nqe::internal::InvalidRTT();
       }
       return rtt;
     case STATISTIC_UNWEIGHTED_AVERAGE:
       if (!rtt_observations_.GetUnweightedAverage(
-              start_time, signal_strength_dbm_, disallowed_observation_sources,
+              start_time, signal_strength_, disallowed_observation_sources,
               &rtt)) {
         return nqe::internal::InvalidRTT();
       }
       return rtt;
   }
   NOTREACHED();
   return nqe::internal::InvalidRTT();
 }
 
 int32_t NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimateInternal(
     const base::TimeTicks& start_time,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Throughput observations are sorted by kbps from slowest to fastest,
   // thus a higher percentile throughput will be faster than a lower one.
   int32_t kbps = nqe::internal::kInvalidThroughput;
   if (!downstream_throughput_kbps_observations_.GetPercentile(
-          start_time, signal_strength_dbm_, &kbps, 100 - percentile,
+          start_time, signal_strength_, &kbps, 100 - percentile,
           std::vector<NetworkQualityObservationSource>())) {
     return nqe::internal::kInvalidThroughput;
   }
   return kbps;
 }
 
 nqe::internal::NetworkID NetworkQualityEstimator::GetCurrentNetworkID() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): crbug.com/498068 Add NetworkQualityEstimatorAndroid class
@@ skipping 102 matching lines @@
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK);
 
   external_estimate_provider_quality_ = nqe::internal::NetworkQuality();
 
   if (rtt > base::TimeDelta()) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE);
     UMA_HISTOGRAM_TIMES("NQE.ExternalEstimateProvider.RTT", rtt);
     RttObservation rtt_observation(
-        rtt, tick_clock_->NowTicks(), signal_strength_dbm_,
+        rtt, tick_clock_->NowTicks(), signal_strength_,
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_EXTERNAL_ESTIMATE);
     rtt_observations_.AddObservation(rtt_observation);
     external_estimate_provider_quality_.set_http_rtt(rtt);
     NotifyObserversOfRTT(rtt_observation);
   }
 
   if (downstream_throughput_kbps > 0) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE);
     UMA_HISTOGRAM_COUNTS("NQE.ExternalEstimateProvider.DownlinkBandwidth",
                          downstream_throughput_kbps);
     ThroughputObservation throughput_observation(
-        downstream_throughput_kbps, tick_clock_->NowTicks(),
-        signal_strength_dbm_,
+        downstream_throughput_kbps, tick_clock_->NowTicks(), signal_strength_,
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_EXTERNAL_ESTIMATE);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     external_estimate_provider_quality_.set_downstream_throughput_kbps(
         downstream_throughput_kbps);
     NotifyObserversOfThroughput(throughput_observation);
   }
 }
 
 void NetworkQualityEstimator::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(thread_checker_.CalledOnValidThread());
   tick_clock_ = std::move(tick_clock);
 }
 
 double NetworkQualityEstimator::RandDouble() const {
   return base::RandDouble();
 }
 
 void NetworkQualityEstimator::OnUpdatedRTTAvailable(
     SocketPerformanceWatcherFactory::Protocol protocol,
     const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::InvalidRTT(), rtt);
 
-  RttObservation observation(rtt, tick_clock_->NowTicks(), signal_strength_dbm_,
+  RttObservation observation(rtt, tick_clock_->NowTicks(), signal_strength_,
                              ProtocolSourceToObservationSource(protocol));
   NotifyObserversOfRTT(observation);
   rtt_observations_.AddObservation(observation);
 }
 
 void NetworkQualityEstimator::NotifyObserversOfRTT(
     const RttObservation& observation) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::InvalidRTT(), observation.value);
   DCHECK_GT(NETWORK_QUALITY_OBSERVATION_SOURCE_MAX, observation.source);
@@ skipping 38 matching lines @@
   DCHECK_NE(nqe::internal::kInvalidThroughput, downstream_kbps);
 
   if (downstream_kbps > peak_network_quality_.downstream_throughput_kbps() ||
       peak_network_quality_.downstream_throughput_kbps() ==
           nqe::internal::kInvalidThroughput) {
     peak_network_quality_ = nqe::internal::NetworkQuality(
         peak_network_quality_.http_rtt(), peak_network_quality_.transport_rtt(),
         downstream_kbps);
   }
   ThroughputObservation throughput_observation(
-      downstream_kbps, tick_clock_->NowTicks(), signal_strength_dbm_,
+      downstream_kbps, tick_clock_->NowTicks(), signal_strength_,
       NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP);
   downstream_throughput_kbps_observations_.AddObservation(
       throughput_observation);
   NotifyObserversOfThroughput(throughput_observation);
 }
 
 void NetworkQualityEstimator::MaybeComputeEffectiveConnectionType() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::TimeTicks now = tick_clock_->NowTicks();
@@ skipping 188 matching lines @@
   return base::Optional<base::TimeDelta>();
 }
 
 base::Optional<int32_t>
 NetworkQualityEstimator::NetworkQualityProvider::GetDownstreamThroughputKbps()
     const {
   return base::Optional<int32_t>();
 }
 
 }  // namespace net