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 23 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.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 206 matching lines @@
               : algorithm_name_to_enum_
                     .find(params_.GetEffectiveConnectionTypeAlgorithm())
                     ->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_(
           params_.weight_multiplier_per_second(),
-          params_.weight_multiplier_per_dbm()),
+          params_.weight_multiplier_per_signal_strength_level()),
       rtt_observations_(params_.weight_multiplier_per_second(),
-                        params_.weight_multiplier_per_dbm()),
+                        params_.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),
       event_creator_(net_log),
       disallowed_observation_sources_for_http_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_TCP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC,
            NETWORK_QUALITY_OBSERVATION_SOURCE_TRANSPORT_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_TRANSPORT_FROM_PLATFORM}),
       disallowed_observation_sources_for_transport_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_EXTERNAL_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM}),
       weak_ptr_factory_(this) {
   // None of the algorithms can have an empty name.
   DCHECK(algorithm_name_to_enum_.end() ==
          algorithm_name_to_enum_.find(std::string()));
 
   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());
+
+#if defined(OS_ANDROID)
+  if (params_.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 145 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 339 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 (params_.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 (params_.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 448 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 196 matching lines @@
       return "UnweightedAverage";
     case STATISTIC_LAST:
       NOTREACHED();
       return "";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net