Expose cellular signal strength on Android to native

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 13 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/url_util.h"
 #include "net/nqe/socket_watcher_factory.h"
 #include "net/nqe/throughput_analyzer.h"
 #include "net/url_request/url_request.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 {
 
 // Default value of the half life (in seconds) for computing time weighted
 // percentiles. Every half life, the weight of all observations reduces by
 // half. Lowering the half life would reduce the weight of older values faster.
 const int kDefaultHalfLifeSeconds = 60;
 
@@ skipping 201 matching lines @@
       last_connection_change_(tick_clock_->NowTicks()),
       current_network_id_(
           NetworkID(NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
                     std::string())),
       downstream_throughput_kbps_observations_(weight_multiplier_per_second_),
       rtt_observations_(weight_multiplier_per_second_),
       effective_connection_type_at_last_main_frame_(
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       external_estimate_provider_(std::move(external_estimates_provider)),
       effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
+      min_signal_strength_since_connection_change_(INT32_MAX),
+      max_signal_strength_since_connection_change_(INT32_MIN),
       weak_ptr_factory_(this) {
   static_assert(kDefaultHalfLifeSeconds > 0,
                 "Default half life duration must be > 0");
   static_assert(kMaximumNetworkQualityCacheSize > 0,
                 "Size of the network quality cache must be > 0");
   // This limit should not be increased unless the logic for removing the
   // oldest cache entry is rewritten to use a doubly-linked-list LRU queue.
   static_assert(kMaximumNetworkQualityCacheSize <= 10,
                 "Size of the network quality cache must <= 10");
   // None of the algorithms can have an empty name.
@@ skipping 231 matching lines @@
     // possible to measure the accuracy by comparing the estimate with the
     // observations received over intervals of varying durations.
     for (const base::TimeDelta& measuring_delay :
          GetAccuracyRecordingIntervals()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&NetworkQualityEstimator::RecordAccuracyAfterMainFrame,
                      weak_ptr_factory_.GetWeakPtr(), measuring_delay),
           measuring_delay);
     }
+    UpdateSignalStrength();
   }
 
   LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
 
   // If the load timing info is unavailable, it probably means that the request
   // did not go over the network.
   if (load_timing_info.send_start.is_null() ||
       load_timing_info.receive_headers_end.is_null()) {
     return;
@@ skipping 217 matching lines @@
   RecordMetricsOnConnectionTypeChanged();
 
   // Write the estimates of the previous network to the cache.
   CacheNetworkQualityEstimate();
 
   // 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 (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);
+  }
+#endif  // OS_ANDROID
+  min_signal_strength_since_connection_change_ = INT32_MAX;
+  max_signal_strength_since_connection_change_ = INT32_MIN;
+
   current_network_id_ = GetCurrentNetworkID();
 
   // Query the external estimate provider on certain connection types. Once the
   // updated estimates are available, OnUpdatedEstimateAvailable will be called
   // by |external_estimate_provider_| with updated estimates.
   if (external_estimate_provider_ &&
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_NONE &&
       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();
   }
 
   // Read any cached estimates for the new network. If cached estimates are
   // unavailable, add the default estimates.
   if (!ReadCachedNetworkQualityEstimate())
     AddDefaultEstimates();
   estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
   throughput_analyzer_->OnConnectionTypeChanged();
   MaybeRecomputeEffectiveConnectionType();
+  UpdateSignalStrength();
+}
+
+void NetworkQualityEstimator::UpdateSignalStrength() {
+#if defined(OS_ANDROID)
+  int32_t signal_strength_dbm;
+  if (!android::cellular_signal_strength::GetSignalStrengthDbm(
+          &signal_strength_dbm)) {
+    return;
+  }
+  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);
+#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 585 matching lines @@
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): Add hysteresis in the notification.
   FOR_EACH_OBSERVER(
       EffectiveConnectionTypeObserver, effective_connection_type_observer_list_,
       OnEffectiveConnectionTypeChanged(effective_connection_type_));
 }
 
 }  // namespace net