Add support for cellular geolocation

chromeos/geolocation/simple_geolocation_unittest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/geolocation/simple_geolocation_provider.h"
 #include "chromeos/geolocation/simple_geolocation_request_test_monitor.h"
 #include "chromeos/network/geolocation_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_impl.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
-const int kRequestRetryIntervalMilliSeconds = 200;
+constexpr int kRequestRetryIntervalMilliSeconds = 200;
 
 // This should be different from default to prevent SimpleGeolocationRequest
 // from modifying it.
-const char kTestGeolocationProviderUrl[] =
+constexpr char kTestGeolocationProviderUrl[] =
     "https://localhost/geolocation/v1/geolocate?";
 
-const char kSimpleResponseBody[] =
+constexpr char kSimpleResponseBody[] =
     "{\n"
     "  \"location\": {\n"
     "    \"lat\": 51.0,\n"
     "    \"lng\": -0.1\n"
     "  },\n"
     "  \"accuracy\": 1200.4\n"
     "}";
-const char kIPOnlyRequestBody[] = "{\"considerIp\": \"true\"}";
-const char kOneWiFiAPRequestBody[] =
+constexpr char kIPOnlyRequestBody[] = "{\"considerIp\": \"true\"}";
+constexpr char kOneWiFiAPRequestBody[] =
     "{"
-      "\"considerIp\":true,"
-      "\"wifiAccessPoints\":["
-        "{"
-          "\"channel\":1,"
-          "\"macAddress\":\"01:00:00:00:00:00\","
-          "\"signalStrength\":10,"
-          "\"signalToNoiseRatio\":0"
-        "}"
-      "]"
+    "\"considerIp\":true,"
+    "\"wifiAccessPoints\":["
+    "{"
+    "\"channel\":1,"
+    "\"macAddress\":\"01:00:00:00:00:00\","
+    "\"signalStrength\":10,"
+    "\"signalToNoiseRatio\":0"
+    "}"
+    "]"
     "}";
-const char kExpectedPosition[] =
+constexpr char kOneCellTowerRequestBody[] =
+    "{"
+    "\"cellTowers\":["
+    "{"
+    "\"cellId\":\"1\","
+    "\"locationAreaCode\":\"10\","
+    "\"mobileCountryCode\":\"100\","
+    "\"mobileNetworkCode\":\"101\""
+    "}"
+    "],"
+    "\"considerIp\":true"
+    "}";
+constexpr char kExpectedPosition[] =
     "latitude=51.000000, longitude=-0.100000, accuracy=1200.400000, "
     "error_code=0, error_message='', status=1 (OK)";
 
-const char kWiFiAP1MacAddress[] = "01:00:00:00:00:00";
+constexpr char kWiFiAP1MacAddress[] = "01:00:00:00:00:00";
+constexpr char kCellTower1MNC[] = "101";
 }  // anonymous namespace
 
 namespace chromeos {
 
 // This is helper class for net::FakeURLFetcherFactory.
 class TestGeolocationAPIURLFetcherCallback {
  public:
   TestGeolocationAPIURLFetcherCallback(const GURL& url,
                                        const size_t require_retries,
                                        const std::string& response,
@@ skipping 111 matching lines @@
   bool server_error() const { return server_error_; }
   base::TimeDelta elapsed() const { return elapsed_; }
 
  private:
   Geoposition position_;
   bool server_error_;
   base::TimeDelta elapsed_;
   std::unique_ptr<base::RunLoop> message_loop_runner_;
 };
 
-class WiFiTestMonitor : public SimpleGeolocationRequestTestMonitor {
+class WirelessTestMonitor : public SimpleGeolocationRequestTestMonitor {
  public:
-  WiFiTestMonitor() {}
+  WirelessTestMonitor() {}
 
   void OnRequestCreated(SimpleGeolocationRequest* request) override {}
   void OnStart(SimpleGeolocationRequest* request) override {
     last_request_body_ = request->FormatRequestBodyForTesting();
   }
 
   const std::string& last_request_body() const { return last_request_body_; }
 
  private:
   std::string last_request_body_;
 
-  DISALLOW_COPY_AND_ASSIGN(WiFiTestMonitor);
+  DISALLOW_COPY_AND_ASSIGN(WirelessTestMonitor);
 };
 
 class SimpleGeolocationTest : public testing::Test {
  private:
   base::MessageLoop message_loop_;
 };
 
 TEST_F(SimpleGeolocationTest, ResponseOK) {
   SimpleGeolocationProvider provider(nullptr,
                                      GURL(kTestGeolocationProviderUrl));
 
   GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
                                            std::string(kSimpleResponseBody),
                                            0 /* require_retries */,
                                            &provider);
 
   GeolocationReceiver receiver;
-  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false,
+  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false, false,
                               base::Bind(&GeolocationReceiver::OnRequestDone,
                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
 
   EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
   EXPECT_FALSE(receiver.server_error());
   EXPECT_EQ(1U, url_factory.attempts());
 }
 
 TEST_F(SimpleGeolocationTest, ResponseOKWithRetries) {
   SimpleGeolocationProvider provider(nullptr,
                                      GURL(kTestGeolocationProviderUrl));
 
   GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
                                            std::string(kSimpleResponseBody),
                                            3 /* require_retries */,
                                            &provider);
 
   GeolocationReceiver receiver;
-  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false,
+  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false, false,
                               base::Bind(&GeolocationReceiver::OnRequestDone,
                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
   EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
   EXPECT_FALSE(receiver.server_error());
   EXPECT_EQ(4U, url_factory.attempts());
 }
 
 TEST_F(SimpleGeolocationTest, InvalidResponse) {
   SimpleGeolocationProvider provider(nullptr,
                                      GURL(kTestGeolocationProviderUrl));
 
   GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
                                            "invalid JSON string",
                                            0 /* require_retries */,
                                            &provider);
 
   GeolocationReceiver receiver;
 
   const int timeout_seconds = 1;
   size_t expected_retries = static_cast<size_t>(
       timeout_seconds * 1000 / kRequestRetryIntervalMilliSeconds);
   ASSERT_GE(expected_retries, 2U);
 
   provider.RequestGeolocation(base::TimeDelta::FromSeconds(timeout_seconds),
-                              false,
+                              false, false,
                               base::Bind(&GeolocationReceiver::OnRequestDone,
                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
 
   EXPECT_EQ(
       "latitude=200.000000, longitude=200.000000, accuracy=-1.000000, "
       "error_code=0, error_message='SimpleGeolocation provider at "
       "'https://localhost/' : JSONReader failed: Line: 1, column: 1, "
       "Unexpected token..', status=4 (TIMEOUT)",
       receiver.position().ToString());
@@ skipping 11 matching lines @@
         << url_factory.attempts() << "), greater than " << expected_retries - 1
         << " expected.";
   }
 }
 
 TEST_F(SimpleGeolocationTest, NoWiFi) {
   // This initializes DBusThreadManager and markes it "for tests only".
   DBusThreadManager::GetSetterForTesting();
   NetworkHandler::Initialize();
 
-  WiFiTestMonitor requests_monitor;
+  WirelessTestMonitor requests_monitor;
   SimpleGeolocationRequest::SetTestMonitor(&requests_monitor);
 
   SimpleGeolocationProvider provider(nullptr,
                                      GURL(kTestGeolocationProviderUrl));
 
   GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
                                            std::string(kSimpleResponseBody),
                                            0 /* require_retries */, &provider);
 
   GeolocationReceiver receiver;
-  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), true,
+  provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), true, false,
                               base::Bind(&GeolocationReceiver::OnRequestDone,
                                          base::Unretained(&receiver)));
   receiver.WaitUntilRequestDone();
   EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
 
   EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
   EXPECT_FALSE(receiver.server_error());
   EXPECT_EQ(1U, url_factory.attempts());
 
   NetworkHandler::Shutdown();
   DBusThreadManager::Shutdown();
 }
 
-// Test sending of WiFi Access points.
+// Test sending of WiFi Access points and Cell Towers.
 // (This is mostly derived from GeolocationHandlerTest.)
-class SimpleGeolocationWiFiTest : public ::testing::TestWithParam<bool> {
+class SimpleGeolocationWirelessTest : public ::testing::TestWithParam<bool> {
  public:
-  SimpleGeolocationWiFiTest() : manager_test_(nullptr) {}
+  SimpleGeolocationWirelessTest() : manager_test_(nullptr) {}
 
-  ~SimpleGeolocationWiFiTest() override {}
+  ~SimpleGeolocationWirelessTest() override {}
 
   void SetUp() override {
     // This initializes DBusThreadManager and markes it "for tests only".
     DBusThreadManager::GetSetterForTesting();
     // Get the test interface for manager / device.
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
     ASSERT_TRUE(manager_test_);
     geolocation_handler_.reset(new GeolocationHandler());
     geolocation_handler_->Init();
     base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     geolocation_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
   bool GetWifiAccessPoints() {
     return geolocation_handler_->GetWifiAccessPoints(&wifi_access_points_,
                                                      nullptr);
   }
 
+  bool GetCellTowers() {
+    return geolocation_handler_->GetNetworkInformation(nullptr, &cell_towers_);
+  }
+
+  // This should remain in sync with the format of shill (chromeos) dict entries
   void AddAccessPoint(int idx) {
     base::DictionaryValue properties;
     std::string mac_address =
         base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X", idx, 0, 0, 0, 0, 0);
     std::string channel = base::IntToString(idx);
     std::string strength = base::IntToString(idx * 10);
     properties.SetStringWithoutPathExpansion(shill::kGeoMacAddressProperty,
                                              mac_address);
     properties.SetStringWithoutPathExpansion(shill::kGeoChannelProperty,
                                              channel);
     properties.SetStringWithoutPathExpansion(shill::kGeoSignalStrengthProperty,
                                              strength);
-    manager_test_->AddGeoNetwork(shill::kTypeWifi, properties);
+    manager_test_->AddGeoNetwork(shill::kGeoWifiAccessPointsProperty,
+                                 properties);
     base::RunLoop().RunUntilIdle();
   }
 
+  // This should remain in sync with the format of shill (chromeos) dict entries
+  void AddCellTower(int idx) {
+    base::DictionaryValue properties;
+    std::string ci = base::IntToString(idx);
+    std::string lac = base::IntToString(idx * 10);
+    std::string mcc = base::IntToString(idx * 100);
+    std::string mnc = base::IntToString(idx * 100 + 1);
+
+    properties.SetStringWithoutPathExpansion(shill::kGeoCellIdProperty, ci);
+    properties.SetStringWithoutPathExpansion(
+        shill::kGeoLocationAreaCodeProperty, lac);
+    properties.SetStringWithoutPathExpansion(
+        shill::kGeoMobileCountryCodeProperty, mcc);
+    properties.SetStringWithoutPathExpansion(
+        shill::kGeoMobileNetworkCodeProperty, mnc);
+
+    manager_test_->AddGeoNetwork(shill::kGeoCellTowersProperty, properties);
+    base::RunLoop().RunUntilIdle();
+  }
+
  protected:
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<GeolocationHandler> geolocation_handler_;
   ShillManagerClient::TestInterface* manager_test_;
   WifiAccessPointVector wifi_access_points_;
+  CellTowerVector cell_towers_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(SimpleGeolocationWiFiTest);
+  DISALLOW_COPY_AND_ASSIGN(SimpleGeolocationWirelessTest);
 };
 
 // Parameter is enable/disable sending of WiFi data.
-TEST_P(SimpleGeolocationWiFiTest, WiFiExists) {
+TEST_P(SimpleGeolocationWirelessTest, WiFiExists) {
   NetworkHandler::Initialize();
 
-  WiFiTestMonitor requests_monitor;
+  WirelessTestMonitor requests_monitor;
   SimpleGeolocationRequest::SetTestMonitor(&requests_monitor);
 
   SimpleGeolocationProvider provider(nullptr,
                                      GURL(kTestGeolocationProviderUrl));
 
   GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
                                            std::string(kSimpleResponseBody),
                                            0 /* require_retries */, &provider);
   {
     GeolocationReceiver receiver;
     provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), GetParam(),
+                                false,
                                 base::Bind(&GeolocationReceiver::OnRequestDone,
                                            base::Unretained(&receiver)));
     receiver.WaitUntilRequestDone();
     EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
 
     EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
     EXPECT_FALSE(receiver.server_error());
     EXPECT_EQ(1U, url_factory.attempts());
   }
 
-  // Add an acces point.
+  // Add an access point.
   AddAccessPoint(1);
   base::RunLoop().RunUntilIdle();
-  // Inititial call should return false and request access points.
+  // Initial call should return false and request access points.
   EXPECT_FALSE(GetWifiAccessPoints());
   base::RunLoop().RunUntilIdle();
   // Second call should return true since we have an access point.
   EXPECT_TRUE(GetWifiAccessPoints());

[Alexander Alekseev, 2017/02/08 22:43:55]

Could we also Add Cell tower here and check that it is not sent to the server
since we supply false to "send cell towers" parameter of RequestGeolocation() ?

[can Skylar cook, 2017/02/09 19:44:30]

Done.

[Alexander Alekseev, 2017/02/09 19:54:56]

I cannot find a check itself here, like:
   EXPECT_FALSE(GetCellTowers());

[can Skylar cook, 2017/02/09 19:59:35]

The `EXPECT_EQ(kOneWiFiAPRequestBody, requests_monitor.last_request_body())`
below is the definitive test for what we care about: does the sent request only
contain the WiFi AP?

[Alexander Alekseev, 2017/02/09 20:30:39]

Yes, thank you, I missed this.

   ASSERT_EQ(1u, wifi_access_points_.size());
   EXPECT_EQ(kWiFiAP1MacAddress, wifi_access_points_[0].mac_address);
   EXPECT_EQ(1, wifi_access_points_[0].channel);
 
   {
     GeolocationReceiver receiver;
     provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), GetParam(),
+                                false,
                                 base::Bind(&GeolocationReceiver::OnRequestDone,
                                            base::Unretained(&receiver)));
     receiver.WaitUntilRequestDone();
     if (GetParam()) {
       // Sending WiFi data is enabled.
       EXPECT_EQ(kOneWiFiAPRequestBody, requests_monitor.last_request_body());
     } else {
       // Sending WiFi data is disabled.
       EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
     }
 
     EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
     EXPECT_FALSE(receiver.server_error());
     // This is total.
     EXPECT_EQ(2U, url_factory.attempts());
   }
   NetworkHandler::Shutdown();
 }
 
 // This test verifies that WiFi data is sent only if sending was requested.
 INSTANTIATE_TEST_CASE_P(EnableDisableSendingWifiData,
-                        SimpleGeolocationWiFiTest,
+                        SimpleGeolocationWirelessTest,
                         testing::Bool());
 
+TEST_P(SimpleGeolocationWirelessTest, CellularExists) {
+  NetworkHandler::Initialize();
+
+  WirelessTestMonitor requests_monitor;
+  SimpleGeolocationRequest::SetTestMonitor(&requests_monitor);
+
+  SimpleGeolocationProvider provider(nullptr,
+                                     GURL(kTestGeolocationProviderUrl));
+
+  GeolocationAPIFetcherFactory url_factory(GURL(kTestGeolocationProviderUrl),
+                                           std::string(kSimpleResponseBody),
+                                           0 /* require_retries */, &provider);
+  {
+    GeolocationReceiver receiver;
+    provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false,
+                                GetParam(),
+                                base::Bind(&GeolocationReceiver::OnRequestDone,
+                                           base::Unretained(&receiver)));
+    receiver.WaitUntilRequestDone();
+    EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
+
+    EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
+    EXPECT_FALSE(receiver.server_error());
+    EXPECT_EQ(1U, url_factory.attempts());
+  }
+
+  // Add a cell tower.
+  AddCellTower(1);
+  base::RunLoop().RunUntilIdle();
+  // Initial call should return false and request cell towers.
+  EXPECT_FALSE(GetCellTowers());
+  base::RunLoop().RunUntilIdle();
+  // Second call should return true since we have a tower.
+  EXPECT_TRUE(GetCellTowers());
+  ASSERT_EQ(1u, cell_towers_.size());
+  EXPECT_EQ(kCellTower1MNC, cell_towers_[0].mnc);
+  EXPECT_EQ(base::IntToString(1), cell_towers_[0].ci);
+
+  {
+    GeolocationReceiver receiver;
+    provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), false,
+                                GetParam(),
+                                base::Bind(&GeolocationReceiver::OnRequestDone,
+                                           base::Unretained(&receiver)));
+    receiver.WaitUntilRequestDone();
+    if (GetParam()) {
+      // Sending Cellular data is enabled.
+      EXPECT_EQ(kOneCellTowerRequestBody, requests_monitor.last_request_body());
+    } else {
+      // Sending Cellular data is disabled.
+      EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
+    }
+
+    EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
+    EXPECT_FALSE(receiver.server_error());
+    // This is total.
+    EXPECT_EQ(2U, url_factory.attempts());
+  }
+  NetworkHandler::Shutdown();
+}
+
 }  // namespace chromeos