Use Android callback API to obtain cellular signal strength

net/nqe/network_quality_estimator.h

 // 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.
 
 #ifndef NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 16 matching lines @@
 #include "net/nqe/event_creator.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/nqe/network_id.h"
 #include "net/nqe/network_quality.h"
 #include "net/nqe/network_quality_observation.h"
 #include "net/nqe/network_quality_observation_source.h"
 #include "net/nqe/network_quality_store.h"
 #include "net/nqe/observation_buffer.h"
 #include "net/socket/socket_performance_watcher_factory.h"
 
+#if defined(OS_ANDROID)
+#include "net/android/cellular_signal_strength.h"
+#endif  // OS_ANDROID
+
 namespace base {
 class TickClock;
 }  // namespace base
 
 namespace net {
 
 class NetLog;
 
 namespace nqe {
 namespace internal {
@@ skipping 615 matching lines @@
   // When set to true, the device offline check is disabled when computing the
   // effective connection type or when writing the prefs.
   bool disable_offline_check_;
 
   // If true, default values provided by the platform are used for estimation.
   const bool add_default_platform_observations_;
 
   // The factor by which the weight of an observation reduces every second.
   const double weight_multiplier_per_second_;
 
-  // The factor by which the weight of an observation reduces for every dBm
-  // difference between the current signal strength (in dBm), and the signal
-  // strength at the time when the observation was taken.
-  const double weight_multiplier_per_dbm_;
+  // The factor by which the weight of an observation reduces for every signal
+  // strength level difference between the current signal strength, and the
+  // signal strength at the time when the observation was taken.
+  const double weight_multiplier_per_signal_strength_level_;
 
   // Algorithm to use for computing effective connection type. The value is
   // obtained from field trial parameters. If the value from field trial
   // parameters is unavailable, it is set to
   // kDefaultEffectiveConnectionTypeAlgorithm.
   const EffectiveConnectionTypeAlgorithm effective_connection_type_algorithm_;
 
   // Tick clock used by the network quality estimator.
   std::unique_ptr<base::TickClock> tick_clock_;
 
@@ skipping 93 matching lines @@
 
   // Current estimate of the network quality.
   nqe::internal::NetworkQuality network_quality_;
 
   // Current effective connection type. It is updated on connection change
   // events. It is also updated every time there is network traffic (provided
   // the last computation was more than
   // |effective_connection_type_recomputation_interval_| ago).
   EffectiveConnectionType effective_connection_type_;
 
-  // Last known value of the wireless signal strength. Set to INT32_MIN if
-  // unavailable. |signal_strength_dbm_| is reset to INT32_MIN on connection
-  // change events.
-  int32_t signal_strength_dbm_;
+  // Last known value of the wireless signal strength level. Set to INT32_MIN if
+  // unavailable. |signal_strength_| is reset to INT32_MIN on connection
+  // change events. If the signal strength level is available, the value is set
+  // to between 0 and 4, both inclusive.
+  base::Optional<int32_t> signal_strength_;
 
-  // Minimum and maximum signal strength (in dBm) observed since last connection
+  // Minimum and maximum signal strength level observed since last connection
   // change. Updated on connection change and main frame requests.
-  int32_t min_signal_strength_since_connection_change_;
-  int32_t max_signal_strength_since_connection_change_;
+  base::Optional<int32_t> min_signal_strength_since_connection_change_;
+  base::Optional<int32_t> max_signal_strength_since_connection_change_;
 
   // It is costlier to add values to a sparse histogram. So, the correlation UMA
   // is recorded with |correlation_uma_logging_probability_| since recording it
   // in a sparse histogram for each request is unnecessary and cost-prohibitive.
   // e.g., if it is 0.0, then the UMA will never be recorded. On the other hand,
   // if it is 1.0, then it will be recorded for all valid HTTP requests.
   const double correlation_uma_logging_probability_;
 
   // Stores the qualities of different networks.
   std::unique_ptr<nqe::internal::NetworkQualityStore> network_quality_store_;
@@ skipping 15 matching lines @@
   // Vector that contains observation sources that should not be used when
   // computing the estimate at HTTP layer.
   const std::vector<NetworkQualityObservationSource>
       disallowed_observation_sources_for_http_;
 
   // Vector that contains observation sources that should not be used when
   // computing the estimate at transport layer.
   const std::vector<NetworkQualityObservationSource>
       disallowed_observation_sources_for_transport_;
 
+#if defined(OS_ANDROID)
+  // Initialized only if the experiment to use the cellular signal strength
+  // is enabled.
+  std::unique_ptr<android::CellularSignalStrength> cellular_signal_strength_;
+#endif  // OS_ANDROID
+
   base::WeakPtrFactory<NetworkQualityEstimator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_