Add support for cellular geolocation

chromeos/network/geolocation_handler.h

 // Copyright (c) 2013 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 CHROMEOS_NETWORK_GEOLOCATION_HANDLER_H_
 #define CHROMEOS_NETWORK_GEOLOCATION_HANDLER_H_
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_util.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace chromeos {
 
-// This class provices Shill Wifi Access Point data. It currently relies on
-// polling because that is the usage model in content::WifiDataProvider. This
-// class requests data asynchronously, returning the most recent available data.
-// A typical usage pattern, assuming a wifi device is enabled, is:
+// This class provices Shill Wifi Access Point and Cell Tower data. It
+// currently relies on polling because that is the usage model in
+// content::WifiDataProvider. This class requests data asynchronously,
+// returning the most recent available data. A typical usage pattern,
+// assuming a wifi device is enabled, is:
 //   Initialize();  // Makes an initial request
 //   GetWifiAccessPoints();  // returns true + inital data, requests update
 //   (Delay some amount of time, ~10s)
 //   GetWifiAccessPoints();  // returns true + updated data, requests update
 //   (Delay some amount of time after data changed, ~10s)
 //   GetWifiAccessPoints();  // returns true + same data, requests update
 //   (Delay some amount of time after data did not change, ~2 mins)
 
 class CHROMEOS_EXPORT GeolocationHandler : public ShillPropertyChangedObserver {
  public:
   ~GeolocationHandler() override;
 
-  // This sends a request for wifi access point data. If data is already
-  // available, returns |true|, fills |access_points| with the latest access
-  // point data, and sets |age_ms| to the time since the last update in MS.
+  // This sends a request for geolocation (both wifi AP and cell tower) data.
+  // If AP data is already available, fills |access_points| with the latest
+  // access point data, and similarly for cell tower data and |cell_towers|.
+  // Returns |true| if either type of data is already available upon call.
+  bool GetNetworkInformation(WifiAccessPointVector* access_points,
+                             CellTowerVector* cell_towers);
+
+  // This sends a request for geolocation (both wifi AP and cell tower) data.
+  // If wifi data is already available, returns |true|, fills |access_points|
+  // with the latest access point data, and sets |age_ms| to the time
+  // since the last update in MS.
   bool GetWifiAccessPoints(WifiAccessPointVector* access_points,
                            int64_t* age_ms);
 
+  // This sends a request for geolocation (both wifi AP and cell tower) data.
+  // If cell data is already available, returns |true|, fills |cell_towers|
+  // with the latest cell tower data, and sets |age_ms| to the time
+  // since the last update in MS.
+  bool GetCellTowers(CellTowerVector* cell_towers, int64_t* age_ms);

[Alexander Alekseev, 2017/02/07 22:15:38]

It looks like GetWifiAccessPoints()/GetCellTowers() are only used in tests.

Could we update tests to use GetNetworkInformation() instead (for example, by
allowing nullptr in place of unneeded data) ?

Alternatively, we can rename these to
GetWifiAccessPointsForTesting()/GetCellTowersForTesting(), but they seem to be a
bit complicate for test methods.

[can Skylar cook, 2017/02/07 22:29:59]

GetWifiAccessPoints() is used in a few locations, notably in
WifiDataProviderChromeOs, where the age value is actually used. 

After talking this out with Steven, I'm going to drop GetCellTowers() and do as
you suggest for tests (use GetNetworkInformation()).

[Alexander Alekseev, 2017/02/08 22:10:32]

WifiDataProviderChromeOs is a completely different code which is used for Web
location only. ChromeOS geolocation code is separate and it does not seem to use
this ;)

+
+  bool cellular_enabled() const { return cellular_enabled_; }
+
   bool wifi_enabled() const { return wifi_enabled_; }
 
   // ShillPropertyChangedObserver overrides
   void OnPropertyChanged(const std::string& key,
                          const base::Value& value) override;
 
  private:
   friend class NetworkHandler;
   friend class GeolocationHandlerTest;
-  friend class SimpleGeolocationWiFiTest;
+  friend class SimpleGeolocationWirelessTest;
 
   GeolocationHandler();
 
   void Init();
 
   // ShillManagerClient callback
   void ManagerPropertiesCallback(DBusMethodCallStatus call_status,
                                  const base::DictionaryValue& properties);
 
   // Called from OnPropertyChanged or ManagerPropertiesCallback.
   void HandlePropertyChanged(const std::string& key, const base::Value& value);
 
-  // Asynchronously request wifi access points from Shill.Manager.
-  void RequestWifiAccessPoints();
+  // Asynchronously request geolocation objects (wifi access points and
+  // cell towers) from Shill.Manager.
+  void RequestGeolocationObjects();
 
   // Callback for receiving Geolocation data.
   void GeolocationCallback(DBusMethodCallStatus call_status,
                            const base::DictionaryValue& properties);
 
-  // Wifi enabled state
+  bool cellular_enabled_;
   bool wifi_enabled_;
 
+  void AddCellTowerFromDict(const base::DictionaryValue* entry);
+  void AddAccessPointFromDict(const base::DictionaryValue* entry);
+
   // Cached wifi access points and update time
   WifiAccessPointVector wifi_access_points_;
-  base::Time geolocation_received_time_;
+  base::Time access_point_received_time_;
+
+  // Cached cell towers and update time
+  CellTowerVector cell_towers_;
+  base::Time cell_towers_received_time_;
 
   // For Shill client callbacks
   base::WeakPtrFactory<GeolocationHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GeolocationHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_GEOLOCATION_HANDLER_H_