SimpleGeolocation should support sending WiFi AP data.

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>
 
 #include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/geolocation/simple_geolocation_provider.h"
+#include "chromeos/geolocation/simple_geolocation_request_test_monitor.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 // Location resolve timeout is usually 1 minute, so 2 minutes with 50 buckets
 // should be enough.
 #define UMA_HISTOGRAM_LOCATION_RESPONSE_TIMES(name, sample)         \
   UMA_HISTOGRAM_CUSTOM_TIMES(name,                                  \
                              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\"}";
+const char kSimpleGeolocationRequestBody[] = "{\"considerIp\": \"true\"}";
+
+// Request data
+const char kConsiderIp[] = "considerIp";
+const char kWifiAccessPoints[] = "wifiAccessPoints";
+
+// WiFi access point objects.
+const char kMacAddress[] = "macAddress";
+const char kSignalStrength[] = "signalStrength";
+const char kAge[] = "age";
+const char kChannel[] = "channel";
+const char kSignalToNoiseRatio[] = "signalToNoiseRatio";
 
 // Response data.
 const char kLocationString[] = "location";
 const char kLatString[] = "lat";
 const char kLngString[] = "lng";
 const char kAccuracyString[] = "accuracy";
 // Error object and its contents.
 const char kErrorString[] = "error";
 // "errors" array in "erorr" object is ignored.
 const char kCodeString[] = "code";
@@ skipping 29 matching lines @@
   // in tools/metrics/histograms/histograms.xml to keep it in sync.
   SIMPLE_GEOLOCATION_REQUEST_RESULT_SUCCESS = 0,
   SIMPLE_GEOLOCATION_REQUEST_RESULT_FAILURE = 1,
   SIMPLE_GEOLOCATION_REQUEST_RESULT_SERVER_ERROR = 2,
   SIMPLE_GEOLOCATION_REQUEST_RESULT_CANCELLED = 3,
 
   // NOTE: Add entries only immediately above this line.
   SIMPLE_GEOLOCATION_REQUEST_RESULT_COUNT = 4
 };
 
+SimpleGeolocationRequestTestMonitor* g_test_request_hook = nullptr;
+
 // Too many requests (more than 1) mean there is a problem in implementation.
 void RecordUmaEvent(SimpleGeolocationRequestEvent event) {
   UMA_HISTOGRAM_ENUMERATION("SimpleGeolocation.Request.Event",
                             event,
                             SIMPLE_GEOLOCATION_REQUEST_EVENT_COUNT);
 }
 
 void RecordUmaResponseCode(int code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("SimpleGeolocation.Request.ResponseCode", code);
 }
@@ skipping 139 matching lines @@
   return true;
 }
 
 // Attempts to extract a position from the response. Detects and indicates
 // various failure cases.
 bool GetGeolocationFromResponse(bool http_success,
                                 int status_code,
                                 const std::string& response_body,
                                 const GURL& server_url,
                                 Geoposition* position) {
+  VLOG(1) << "GetGeolocationFromResponse(http_success=" << http_success
+          << ", status_code=" << status_code << "): response_body:\n"
+          << response_body;
 
   // HttpPost can fail for a number of reasons. Most likely this is because
   // we're offline, or there was no response.
   if (!http_success) {
     PrintGeolocationError(server_url, "No response received", position);
     RecordUmaEvent(SIMPLE_GEOLOCATION_REQUEST_EVENT_RESPONSE_EMPTY);
     return false;
   }
   if (status_code != net::HTTP_OK) {
     std::string message = "Returned error code ";
     message += base::IntToString(status_code);
     PrintGeolocationError(server_url, message, position);
     RecordUmaEvent(SIMPLE_GEOLOCATION_REQUEST_EVENT_RESPONSE_NOT_OK);
     return false;
   }
 
   return ParseServerResponse(server_url, response_body, position);
 }
 
 }  // namespace
 
 SimpleGeolocationRequest::SimpleGeolocationRequest(
     net::URLRequestContextGetter* url_context_getter,
     const GURL& service_url,
-    base::TimeDelta timeout)
+    base::TimeDelta timeout,
+    scoped_ptr<WifiAccessPointVector> wifi_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) {
-}
+      retries_(0),
+      wifi_data_(wifi_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_) {
+    UMA_HISTOGRAM_BOOLEAN("SimpleGeolocation.Request.HasWiFiAccessPoints",

[Steven Holte, 2016/03/23 18:41:46]

It would be better to wrap a function call around this macro invocation, since
it will create a static variable pointing at the Histogram object.

[Alexander Alekseev, 2016/03/23 22:08:23]

Done.

+                          false);
+    return std::string(kSimpleGeolocationRequestBody);
+  }
+
+  scoped_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);
+
+  for (const WifiAccessPoint& access_point : *wifi_data_) {
+    base::DictionaryValue* access_point_dictionary = new base::DictionaryValue;
+    wifi_access_points->Append(access_point_dictionary);
+
+    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);
+  }
+  std::string result;
+  if (!base::JSONWriter::Write(*request, &result)) {
+    UMA_HISTOGRAM_BOOLEAN("SimpleGeolocation.Request.HasWiFiAccessPoints",
+                          false);
+    return std::string(kSimpleGeolocationRequestBody);
+  }
+  UMA_HISTOGRAM_BOOLEAN("SimpleGeolocation.Request.HasWiFiAccessPoints",
+                        wifi_data_->size());
+
+  return result;
 }
 
 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_ =
       net::URLFetcher::Create(request_url_, net::URLFetcher::POST, this);
   url_fetcher_->SetRequestContext(url_context_getter_.get());
-  url_fetcher_->SetUploadData("application/json",
-                              std::string(kSimpleGeolocationRequestBody));
+  url_fetcher_->SetUploadData("application/json", request_body);
   url_fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE |
                              net::LOAD_DISABLE_CACHE |
                              net::LOAD_DO_NOT_SAVE_COOKIES |
                              net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SEND_AUTH_DATA);
+
+  // Call test hook before asynchronous request actually starts.
+  if (g_test_request_hook)
+    g_test_request_hook->OnStart(this);
+
   url_fetcher_->Start();
 }
 
 void SimpleGeolocationRequest::MakeRequest(const ResponseCallback& callback) {
   callback_ = callback;
   request_url_ = GeolocationRequestURL(service_url_);
   timeout_timer_.Start(
       FROM_HERE, timeout_, this, &SimpleGeolocationRequest::OnTimeout);
   request_started_at_ = base::Time::Now();
   StartRequest();
 }
 
+// static
+void SimpleGeolocationRequest::SetTestMonitor(
+    SimpleGeolocationRequestTestMonitor* monitor) {
+  g_test_request_hook = monitor;
+}
+
+std::string SimpleGeolocationRequest::FormatRequestBodyForTesting() const {
+  return FormatRequestBody();
+}
+
 void SimpleGeolocationRequest::Retry(bool server_error) {
   base::TimeDelta delay(server_error ? retry_sleep_on_server_error_
                                      : retry_sleep_on_bad_response_);
   request_scheduled_.Start(
       FROM_HERE, delay, this, &SimpleGeolocationRequest::StartRequest);
 }
 
 void SimpleGeolocationRequest::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK_EQ(url_fetcher_.get(), source);
@@ skipping 51 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