Gateway Location Provider

chrome/browser/geolocation/network_location_request.cc

 // Copyright (c) 2010 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 "chrome/browser/geolocation/network_location_request.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 14 matching lines @@
 const char kLatitudeString[] = "latitude";
 const char kLongitudeString[] = "longitude";
 const char kAltitudeString[] = "altitude";
 const char kAccuracyString[] = "accuracy";
 const char kAltitudeAccuracyString[] = "altitude_accuracy";
 
 // Local functions
 // Creates the request payload to send to the server.
 void FormRequestBody(const std::string& host_name,
                      const string16& access_token,
+                     const GatewayData& gateway_data,
                      const RadioData& radio_data,
                      const WifiData& wifi_data,
                      const base::Time& timestamp,
                      std::string* data);
 // Parsers the server response.
 void GetLocationFromResponse(bool http_post_result,
                              int status_code,
                              const std::string& response_body,
                              const base::Time& timestamp,
                              const GURL& server_url,
                              Geoposition* position,
                              string16* access_token);
 
 const char* RadioTypeToString(RadioType type);
 // Adds a string if it's valid to the JSON object.
 void AddString(const std::string& property_name,
                const string16& value,
                DictionaryValue* object);
 // Adds an integer if it's valid to the JSON object.
 void AddInteger(const std::string& property_name,
                 int value,
                 DictionaryValue* object);
 // Parses the server response body. Returns true if parsing was successful.
 // Sets |*position| to the parsed location if a valid fix was received,
 // otherwise leaves it unchanged (i.e. IsInitialized() == false).
 bool ParseServerResponse(const std::string& response_body,
                          const base::Time& timestamp,
                          Geoposition* position,
                          string16* access_token);
+void AddGatewayData(const GatewayData& gateway_data,
+                  int age_milliseconds,
+                  DictionaryValue* body_object);
 void AddRadioData(const RadioData& radio_data,
                   int age_milliseconds,
                   DictionaryValue* body_object);
 void AddWifiData(const WifiData& wifi_data,
                  int age_milliseconds,
                  DictionaryValue* body_object);
 }  // namespace
 
 int NetworkLocationRequest::url_fetcher_id_for_tests = 0;
 
 NetworkLocationRequest::NetworkLocationRequest(URLRequestContextGetter* context,
                                                const GURL& url,
                                                ListenerInterface* listener)
     : url_context_(context), listener_(listener),
       url_(url) {
   DCHECK(listener);
 }
 
 NetworkLocationRequest::~NetworkLocationRequest() {
 }
 
 bool NetworkLocationRequest::MakeRequest(const std::string& host_name,
                                          const string16& access_token,
+                                         const GatewayData& gateway_data,
                                          const RadioData& radio_data,
                                          const WifiData& wifi_data,
                                          const base::Time& timestamp) {
   if (url_fetcher_ != NULL) {
     DLOG(INFO) << "NetworkLocationRequest : Cancelling pending request";
     url_fetcher_.reset();
   }
+  gateway_data_ = gateway_data;
   radio_data_ = radio_data;
   wifi_data_ = wifi_data;
   timestamp_ = timestamp;
   std::string post_body;
-  FormRequestBody(host_name, access_token, radio_data_, wifi_data_,
-                  timestamp_, &post_body);
+  FormRequestBody(host_name, access_token, gateway_data, radio_data_,
+                  wifi_data_, timestamp_, &post_body);
 
   url_fetcher_.reset(URLFetcher::Create(
       url_fetcher_id_for_tests, url_, URLFetcher::POST, this));
   url_fetcher_->set_upload_data(kMimeApplicationJson, post_body);
   url_fetcher_->set_request_context(url_context_);
   url_fetcher_->set_load_flags(
       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);
   url_fetcher_->Start();
@@ skipping 14 matching lines @@
   GetLocationFromResponse(status.is_success(), response_code, data,
                           timestamp_, url, &position, &access_token);
   const bool server_error =
       !status.is_success() || (response_code >= 500 && response_code < 600);
   url_fetcher_.reset();
 
   DCHECK(listener_);
   DLOG(INFO) << "NetworkLocationRequest::Run() : "
                 "Calling listener with position.\n";
   listener_->LocationResponseAvailable(position, server_error, access_token,
-                                       radio_data_, wifi_data_);
+                                       gateway_data_, radio_data_, wifi_data_);
 }
 
 // Local functions.
 namespace {
 
 void FormRequestBody(const std::string& host_name,
                      const string16& access_token,
+                     const GatewayData& gateway_data,
                      const RadioData& radio_data,
                      const WifiData& wifi_data,
                      const base::Time& timestamp,
                      std::string* data) {
   DCHECK(data);
 
   DictionaryValue body_object;
   // Version and host are required.
   COMPILE_ASSERT(sizeof(kGeoLocationNetworkProtocolVersion) > 1,
                  must_include_valid_version);
   DCHECK(!host_name.empty());
   body_object.SetString("version", kGeoLocationNetworkProtocolVersion);
   body_object.SetString("host", host_name);
 
   AddString("access_token", access_token, &body_object);
 
   body_object.SetBoolean("request_address", false);
 
   int age = kint32min;  // Invalid so AddInteger() will ignore.
   if (!timestamp.is_null()) {
     // Convert absolute timestamps into a relative age.
     int64 delta_ms = (base::Time::Now() - timestamp).InMilliseconds();
     if (delta_ms >= 0 && delta_ms < kint32max)
       age = static_cast<int>(delta_ms);
   }
   AddRadioData(radio_data, age, &body_object);
   AddWifiData(wifi_data, age, &body_object);
+  AddGatewayData(gateway_data, age, &body_object);
 
   base::JSONWriter::Write(&body_object, false, data);
   DLOG(INFO) << "NetworkLocationRequest::FormRequestBody(): Formed body "
              << *data << ".\n";
 }
 
 void FormatPositionError(const GURL& server_url,
                          const std::string& message,
                          Geoposition* position) {
     position->error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
@@ skipping 235 matching lines @@
     AddString("mac_address", iter->mac_address, wifi_tower);
     AddInteger("signal_strength", iter->radio_signal_strength, wifi_tower);
     AddInteger("age", age_milliseconds, wifi_tower);
     AddInteger("channel", iter->channel, wifi_tower);
     AddInteger("signal_to_noise", iter->signal_to_noise, wifi_tower);
     AddString("ssid", iter->ssid, wifi_tower);
     wifi_towers->Append(wifi_tower);
   }
   body_object->Set("wifi_towers", wifi_towers);
 }
+
+void AddGatewayData(const GatewayData& gateway_data,
+                    int age_milliseconds,
+                    DictionaryValue* body_object) {
+  DCHECK(body_object);
+
+  if (gateway_data.router_data.empty()) {
+    return;
+  }
+
+  ListValue* gateways = new ListValue;
+  for (GatewayData::RouterDataSet::const_iterator iter =
+       gateway_data.router_data.begin();
+       iter != gateway_data.router_data.end();
+       iter++) {
+    DictionaryValue* gateway = new DictionaryValue;
+    AddString("mac_address", iter->mac_address, gateway);
+    gateways->Append(gateway);
+  }
+  body_object->Set("gateways", gateways);
+}
 }  // namespace