Add support for cellular geolocation

chromeos/geolocation/simple_geolocation_request.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 "chromeos/geolocation/simple_geolocation_request.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 24 matching lines @@
                              sample,                                \
                              base::TimeDelta::FromMilliseconds(10), \
                              base::TimeDelta::FromMinutes(2),       \
                              50)
 
 namespace chromeos {
 
 namespace {
 
 // The full request text. (no parameters are supported by now)
-const char kSimpleGeolocationRequestBody[] = "{\"considerIp\": \"true\"}";
+constexpr char kSimpleGeolocationRequestBody[] = "{\"considerIp\": \"true\"}";
 
-// Request data
-const char kConsiderIp[] = "considerIp";
-const char kWifiAccessPoints[] = "wifiAccessPoints";
+// TODO(skylarc): kill these and use dbus-constants instead?

[Alexander Alekseev, 2017/02/06 23:24:53]

I think that dbus-constants could be used for DBUS requests only.
But this are Google Maps API request/response keys.
Should we move them to dbus-constants ?

[can Skylar cook, 2017/02/07 21:32:39]

Good point -- they're technically *not* dbus constants, there's just currently
overlap between the two sets of strings (dbus and geolocation keys). Since
they're only used here, I think it's OK to have them defined in the file. If we
begin sharing them, then we should definitely move to a constants file.

Comment added to reflect this.

[stevenjb, 2017/02/07 21:39:38]

I agree that dbus-constants should be used for keys sent over dbus (i.e. keys
provided by Shill) and other constants should be defined separately.

+// Top-level request data fields
+constexpr char kConsiderIp[] = "considerIp";
+constexpr char kWifiAccessPoints[] = "wifiAccessPoints";
+constexpr char kCellTowers[] = "cellTowers";
+
+// Shared Wifi and Cell Tower objects
+constexpr char kAge[] = "age";
+constexpr char kSignalStrength[] = "signalStrength";
 
 // WiFi access point objects.
-const char kMacAddress[] = "macAddress";
-const char kSignalStrength[] = "signalStrength";
-const char kAge[] = "age";
-const char kChannel[] = "channel";
-const char kSignalToNoiseRatio[] = "signalToNoiseRatio";
+constexpr char kMacAddress[] = "macAddress";
+constexpr char kChannel[] = "channel";
+constexpr char kSignalToNoiseRatio[] = "signalToNoiseRatio";
+
+// Cell tower objects
+constexpr char kCellId[] = "cellId";
+constexpr char kLocationAreaCode[] = "locationAreaCode";
+constexpr char kMobileCountryCode[] = "mobileCountryCode";
+constexpr char kMobileNetworkCode[] = "mobileNetworkCode";
 
 // Response data.
-const char kLocationString[] = "location";
-const char kLatString[] = "lat";
-const char kLngString[] = "lng";
-const char kAccuracyString[] = "accuracy";
+constexpr char kLocationString[] = "location";
+constexpr char kLatString[] = "lat";
+constexpr char kLngString[] = "lng";
+constexpr char kAccuracyString[] = "accuracy";
 // Error object and its contents.
-const char kErrorString[] = "error";
+constexpr char kErrorString[] = "error";
 // "errors" array in "erorr" object is ignored.
-const char kCodeString[] = "code";
-const char kMessageString[] = "message";
+constexpr char kCodeString[] = "code";
+constexpr char kMessageString[] = "message";
 
 // We are using "sparse" histograms for the number of retry attempts,
 // so we need to explicitly limit maximum value (in case something goes wrong).
 const size_t kMaxRetriesValueInHistograms = 20;
 
 // Sleep between geolocation request retry on HTTP error.
 const unsigned int kResolveGeolocationRetrySleepOnServerErrorSeconds = 5;
 
 // Sleep between geolocation request retry on bad server response.
 const unsigned int kResolveGeolocationRetrySleepBadResponseSeconds = 10;
@@ skipping 206 matching lines @@
     RecordUmaEvent(SIMPLE_GEOLOCATION_REQUEST_EVENT_RESPONSE_NOT_OK);
     return false;
   }
 
   return ParseServerResponse(server_url, response_body, position);
 }
 
 void ReportUmaHasWiFiAccessPoints(bool value) {
   UMA_HISTOGRAM_BOOLEAN("SimpleGeolocation.Request.HasWiFiAccessPoints", value);
 }
+void ReportUmaHasCellTowers(bool value) {
+  UMA_HISTOGRAM_BOOLEAN("SimpleGeolocation.Request.HasCellTowers", value);
+}
 
 }  // namespace
 
 SimpleGeolocationRequest::SimpleGeolocationRequest(
     net::URLRequestContextGetter* url_context_getter,
     const GURL& service_url,
     base::TimeDelta timeout,
-    std::unique_ptr<WifiAccessPointVector> wifi_data)
+    std::unique_ptr<WifiAccessPointVector> wifi_data,
+    std::unique_ptr<CellTowerVector> cell_tower_data)
     : url_context_getter_(url_context_getter),
       service_url_(service_url),
       retry_sleep_on_server_error_(base::TimeDelta::FromSeconds(
           kResolveGeolocationRetrySleepOnServerErrorSeconds)),
       retry_sleep_on_bad_response_(base::TimeDelta::FromSeconds(
           kResolveGeolocationRetrySleepBadResponseSeconds)),
       timeout_(timeout),
       retries_(0),
-      wifi_data_(wifi_data.release()) {}
+      wifi_data_(wifi_data.release()),
+      cell_tower_data_(cell_tower_data.release()) {}
 
 SimpleGeolocationRequest::~SimpleGeolocationRequest() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If callback is not empty, request is cancelled.
   if (!callback_.is_null()) {
     RecordUmaResponseTime(base::Time::Now() - request_started_at_, false);
     RecordUmaResult(SIMPLE_GEOLOCATION_REQUEST_RESULT_CANCELLED, retries_);
   }
 
   if (g_test_request_hook)
     g_test_request_hook->OnRequestCreated(this);
 }
 
 std::string SimpleGeolocationRequest::FormatRequestBody() const {
-  if (!wifi_data_) {
+  if (!wifi_data_)
     ReportUmaHasWiFiAccessPoints(false);
+
+  if (!cell_tower_data_)
+    ReportUmaHasCellTowers(false);
+
+  if (!cell_tower_data_ && !wifi_data_)
     return std::string(kSimpleGeolocationRequestBody);
-  }
 
   std::unique_ptr<base::DictionaryValue> request(new base::DictionaryValue);
   request->SetBooleanWithoutPathExpansion(kConsiderIp, true);
 
-  base::ListValue* wifi_access_points(new base::ListValue);
-  request->SetWithoutPathExpansion(kWifiAccessPoints, wifi_access_points);
+  if (wifi_data_) {
+    auto wifi_access_points = base::MakeUnique<base::ListValue>();
+    for (const WifiAccessPoint& access_point : *wifi_data_) {
+      wifi_access_points->Append(CreateAccessPointDictionary(access_point));
+    }
+    request->SetWithoutPathExpansion(kWifiAccessPoints,
+                                     std::move(wifi_access_points));
+  }
 
-  for (const WifiAccessPoint& access_point : *wifi_data_) {
-    auto access_point_dictionary = base::MakeUnique<base::DictionaryValue>();
+  if (cell_tower_data_) {
+    auto cell_towers = base::MakeUnique<base::ListValue>();
+    for (const CellTower& cell_tower : *cell_tower_data_) {
+      cell_towers->Append(CreateCellTowerDictionary(cell_tower));
+    }
+    request->SetWithoutPathExpansion(kCellTowers, std::move(cell_towers));
+  }
 
-    access_point_dictionary->SetStringWithoutPathExpansion(
-        kMacAddress, access_point.mac_address);
-    access_point_dictionary->SetIntegerWithoutPathExpansion(
-        kSignalStrength, access_point.signal_strength);
-    if (!access_point.timestamp.is_null()) {
-      access_point_dictionary->SetStringWithoutPathExpansion(
-          kAge,
-          base::Int64ToString(
-              (base::Time::Now() - access_point.timestamp).InMilliseconds()));
-    }
-
-    access_point_dictionary->SetIntegerWithoutPathExpansion(
-        kChannel, access_point.channel);
-    access_point_dictionary->SetIntegerWithoutPathExpansion(
-        kSignalToNoiseRatio, access_point.signal_to_noise);
-
-    wifi_access_points->Append(std::move(access_point_dictionary));
-  }
   std::string result;
   if (!base::JSONWriter::Write(*request, &result)) {
-    ReportUmaHasWiFiAccessPoints(false);
+    // If there's no data for a network type, we will have already reported
+    // false above
+    if (wifi_data_)
+      ReportUmaHasWiFiAccessPoints(false);
+    if (cell_tower_data_)
+      ReportUmaHasCellTowers(false);
+
     return std::string(kSimpleGeolocationRequestBody);
   }
-  ReportUmaHasWiFiAccessPoints(wifi_data_->size());
+
+  if (wifi_data_)
+    ReportUmaHasWiFiAccessPoints(wifi_data_->size());
+  if (cell_tower_data_)
+    ReportUmaHasCellTowers(cell_tower_data_->size());
 
   return result;
 }
 
+std::unique_ptr<base::DictionaryValue>
+SimpleGeolocationRequest::CreateAccessPointDictionary(
+    WifiAccessPoint access_point) const {
+  auto access_point_dictionary = base::MakeUnique<base::DictionaryValue>();
+
+  access_point_dictionary->SetStringWithoutPathExpansion(
+      kMacAddress, access_point.mac_address);
+  access_point_dictionary->SetIntegerWithoutPathExpansion(
+      kSignalStrength, access_point.signal_strength);
+  if (!access_point.timestamp.is_null()) {
+    access_point_dictionary->SetStringWithoutPathExpansion(
+        kAge,
+        base::Int64ToString(
+            (base::Time::Now() - access_point.timestamp).InMilliseconds()));
+  }
+
+  access_point_dictionary->SetIntegerWithoutPathExpansion(kChannel,
+                                                          access_point.channel);
+  access_point_dictionary->SetIntegerWithoutPathExpansion(
+      kSignalToNoiseRatio, access_point.signal_to_noise);
+
+  return access_point_dictionary;
+}
+
+std::unique_ptr<base::DictionaryValue>
+SimpleGeolocationRequest::CreateCellTowerDictionary(
+    CellTower cell_tower) const {
+  auto cell_tower_dictionary = base::MakeUnique<base::DictionaryValue>();
+  cell_tower_dictionary->SetStringWithoutPathExpansion(kCellId, cell_tower.ci);
+  cell_tower_dictionary->SetStringWithoutPathExpansion(kLocationAreaCode,
+                                                       cell_tower.lac);
+  cell_tower_dictionary->SetStringWithoutPathExpansion(kMobileCountryCode,
+                                                       cell_tower.mcc);
+  cell_tower_dictionary->SetStringWithoutPathExpansion(kMobileNetworkCode,
+                                                       cell_tower.mnc);
+
+  if (!cell_tower.timestamp.is_null()) {
+    cell_tower_dictionary->SetStringWithoutPathExpansion(
+        kAge, base::Int64ToString(
+                  (base::Time::Now() - cell_tower.timestamp).InMilliseconds()));
+  }
+  return cell_tower_dictionary;
+}
+
 void SimpleGeolocationRequest::StartRequest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   RecordUmaEvent(SIMPLE_GEOLOCATION_REQUEST_EVENT_REQUEST_START);
   ++retries_;
 
   const std::string request_body = FormatRequestBody();
   VLOG(1) << "SimpleGeolocationRequest::StartRequest(): request body:\n"
           << request_body;
 
   url_fetcher_ =
@@ skipping 96 matching lines @@
            ? SIMPLE_GEOLOCATION_REQUEST_RESULT_SERVER_ERROR
            : SIMPLE_GEOLOCATION_REQUEST_RESULT_FAILURE);
   RecordUmaResult(result, retries_);
   position_.status = Geoposition::STATUS_TIMEOUT;
   const base::TimeDelta elapsed = base::Time::Now() - request_started_at_;
   ReplyAndDestroySelf(elapsed, true /* server_error */);
   // "this" is already destroyed here.
 }
 
 }  // namespace chromeos