Reapply geolocation network protocol changes.

content/browser/geolocation/network_location_request.cc

 // Copyright (c) 2012 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 "content/browser/geolocation/network_location_request.h"
 
 #include <set>
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "content/browser/geolocation/location_arbitrator.h"
 #include "content/public/common/geoposition.h"
+#include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
 
 const size_t kMaxRequestLength = 2048;
 
-const char kAccessTokenString[] = "access_token";
+const char kAccessTokenString[] = "accessToken";
 const char kLocationString[] = "location";
 const char kLatitudeString[] = "lat";
 const char kLongitudeString[] = "lng";
 const char kAccuracyString[] = "accuracy";
 const char kStatusString[] = "status";
 const char kStatusOKString[] = "OK";
 
 // Local functions
 // Creates the request url to send to the server.
-GURL FormRequestURL(const std::string& url,
+GURL FormRequestURL(const GURL& url);
+
+void FormUploadData(const WifiData& wifi_data,
+                    const base::Time& timestamp,
                     const string16& access_token,
-                    const WifiData& wifi_data,
-                    const base::Time& timestamp);
+                    std::string* upload_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,
                              content::Geoposition* position,
                              string16* access_token);
 
 // 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.
 bool ParseServerResponse(const std::string& response_body,
                          const base::Time& timestamp,
                          content::Geoposition* position,
                          string16* access_token);
 void AddWifiData(const WifiData& wifi_data,
                  int age_milliseconds,
-                 std::vector<std::string>* params);
+                 base::DictionaryValue* request);
 }  // namespace
 
 int NetworkLocationRequest::url_fetcher_id_for_tests = 0;
 
 NetworkLocationRequest::NetworkLocationRequest(
     net::URLRequestContextGetter* context,
     const GURL& url,
     ListenerInterface* listener)
         : url_context_(context), listener_(listener),
           url_(url) {
   DCHECK(listener);
 }
 
 NetworkLocationRequest::~NetworkLocationRequest() {
 }
 
 bool NetworkLocationRequest::MakeRequest(const string16& access_token,
                                          const WifiData& wifi_data,
                                          const base::Time& timestamp) {
   if (url_fetcher_ != NULL) {
     DVLOG(1) << "NetworkLocationRequest : Cancelling pending request";
     url_fetcher_.reset();
   }
   wifi_data_ = wifi_data;
   timestamp_ = timestamp;
 
-  GURL request_url = FormRequestURL(url_.spec(), access_token,
-                                    wifi_data, timestamp_);
+  GURL request_url = FormRequestURL(url_);
   url_fetcher_.reset(net::URLFetcher::Create(
-      url_fetcher_id_for_tests, request_url, net::URLFetcher::GET, this));
+      url_fetcher_id_for_tests, request_url, net::URLFetcher::POST, this));
   url_fetcher_->SetRequestContext(url_context_);
+  std::string upload_data;
+  FormUploadData(wifi_data, timestamp, access_token, &upload_data);
+  url_fetcher_->SetUploadData("application/json", upload_data);
   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);
 
   url_fetcher_->Start();
   return true;
 }
 
 void NetworkLocationRequest::OnURLFetchComplete(
@@ skipping 27 matching lines @@
 // Local functions.
 namespace {
 
 struct AccessPointLess {
   bool operator()(const AccessPointData* ap1,
                   const AccessPointData* ap2) const {
     return ap2->radio_signal_strength < ap1->radio_signal_strength;
   }
 };
 
-GURL FormRequestURL(const std::string& url,
+GURL FormRequestURL(const GURL& url) {
+  if (url == GeolocationArbitrator::DefaultNetworkProviderURL()) {
+    std::string api_key = google_apis::GetAPIKey();
+    if (!api_key.empty()) {
+      std::string query(url.query());
+      if (!query.empty())
+        query += "&";
+      query += "key=" + net::EscapeQueryParamValue(api_key, true);
+      GURL::Replacements replacements;
+      replacements.SetQueryStr(query);
+      return url.ReplaceComponents(replacements);
+    }
+  }
+  return url;
+}
+
+void FormUploadData(const WifiData& wifi_data,
+                    const base::Time& timestamp,
                     const string16& access_token,
-                    const WifiData& wifi_data,
-                    const base::Time& timestamp) {
+                    std::string* upload_data) {
   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);
   }
 
-  std::vector<std::string> params;
-#if defined(GOOGLE_CHROME_BUILD)
-  params.push_back("browser=googlechrome");
-#else
-  params.push_back("browser=chromium");
-#endif
-
-  params.push_back("sensor=true");
+  base::DictionaryValue request;
+  AddWifiData(wifi_data, age, &request);
   if (!access_token.empty())
-    params.push_back("token=" + UTF16ToUTF8(access_token));
-  AddWifiData(wifi_data, age, &params);
-
-  std::string request_string = url + '?' + JoinString(params, '&');
-  if (request_string.length() > kMaxRequestLength) {
-    size_t last_param_pos =
-        request_string.find_last_of('&', kMaxRequestLength);
-    CHECK_NE(std::string::npos, last_param_pos);
-    request_string.erase(last_param_pos);
-  }
-
-  return GURL(request_string);
+    request.SetString(kAccessTokenString, access_token);
+  base::JSONWriter::Write(&request, upload_data);
 }
 
 void AddString(const std::string& property_name, const std::string& value,
-               std::string* wifi_params) {
-  DCHECK(wifi_params);
-  if (!value.empty()) {
-    if (!wifi_params->empty())
-      *wifi_params += '|';
-    *wifi_params += property_name;
-    *wifi_params += value;
-  }
+               base::DictionaryValue* dict) {
+  DCHECK(dict);
+  if (!value.empty())
+    dict->SetString(property_name, value);
 }
 
 void AddInteger(const std::string& property_name, int value,
-                std::string* wifi_params) {
-  DCHECK(wifi_params);
-  if (value != kint32min) {
-    if (!wifi_params->empty())
-        *wifi_params += '|';
-      *wifi_params += property_name;
-      *wifi_params += base::IntToString(value);
-  }
+                base::DictionaryValue* dict) {
+  DCHECK(dict);
+  if (value != kint32min)
+    dict->SetInteger(property_name, value);
 }
 
 void AddWifiData(const WifiData& wifi_data,
                  int age_milliseconds,
-                 std::vector<std::string>* params) {
-  DCHECK(params);
+                 base::DictionaryValue* request) {
+  DCHECK(request);
 
   if (wifi_data.access_point_data.empty())
     return;
 
   typedef std::multiset<const AccessPointData*, AccessPointLess> AccessPointSet;
   AccessPointSet access_points_by_signal_strength;
 
   for (WifiData::AccessPointDataSet::const_iterator iter =
        wifi_data.access_point_data.begin();
        iter != wifi_data.access_point_data.end();
        ++iter) {
     access_points_by_signal_strength.insert(&(*iter));
   }
 
+  base::ListValue* wifi_access_point_list = new base::ListValue();
   for (AccessPointSet::iterator iter =
       access_points_by_signal_strength.begin();
       iter != access_points_by_signal_strength.end();
       ++iter) {
-    std::string wifi_params;
-    AddString("mac:", UTF16ToUTF8((*iter)->mac_address), &wifi_params);
-    AddInteger("ss:", (*iter)->radio_signal_strength, &wifi_params);
-    AddInteger("age:", age_milliseconds, &wifi_params);
-    AddInteger("chan:", (*iter)->channel, &wifi_params);
-    AddInteger("snr:", (*iter)->signal_to_noise, &wifi_params);
-    std::string ssid = UTF16ToUTF8((*iter)->ssid);
-    // Backslash characters in the ssid need backslash-escaping to avoid
-    // escaping a following wifi parameter separator.
-    ReplaceSubstringsAfterOffset(&ssid, 0, "\\", "\\\\");
-    // Pipe characters in the ssid need backslash-escaping to avoid being
-    // interpreted as the wifi parameter separator.
-    ReplaceSubstringsAfterOffset(&ssid, 0, "|", "\\|");
-    AddString("ssid:", ssid, &wifi_params);
-    params->push_back(
-        "wifi=" + net::EscapeQueryParamValue(wifi_params, false));
+    base::DictionaryValue* wifi_dict = new base::DictionaryValue();
+    AddString("macAddress", UTF16ToUTF8((*iter)->mac_address), wifi_dict);
+    AddInteger("signalStrength", (*iter)->radio_signal_strength, wifi_dict);
+    AddInteger("age", age_milliseconds, wifi_dict);
+    AddInteger("channel", (*iter)->channel, wifi_dict);
+    AddInteger("signalToNoiseRatio", (*iter)->signal_to_noise, wifi_dict);
+    wifi_access_point_list->Append(wifi_dict);
   }
+  request->Set("wifiAccessPoints", wifi_access_point_list);
 }
 
 void FormatPositionError(const GURL& server_url,
                          const std::string& message,
                          content::Geoposition* position) {
     position->error_code =
         content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
     position->error_message = "Network location provider at '";
-    position->error_message += server_url.possibly_invalid_spec();
+    position->error_message += server_url.GetOrigin().spec();
     position->error_message += "' : ";
     position->error_message += message;
     position->error_message += ".";
     VLOG(1) << "NetworkLocationRequest::GetLocationFromResponse() : "
             << position->error_message;
 }
 
 void GetLocationFromResponse(bool http_post_result,
                              int status_code,
                              const std::string& response_body,
@@ skipping 29 matching lines @@
     FormatPositionError(server_url,
                         "Did not provide a good position fix", position);
     return;
   }
 }
 
 // Numeric values without a decimal point have type integer and IsDouble() will
 // return false. This is convenience function for detecting integer or floating
 // point numeric values. Note that isIntegral() includes boolean values, which
 // is not what we want.
-bool GetAsDouble(const DictionaryValue& object,
+bool GetAsDouble(const base::DictionaryValue& object,
                  const std::string& property_name,
                  double* out) {
   DCHECK(out);
   const Value* value = NULL;
   if (!object.Get(property_name, &value))
     return false;
   int value_as_int;
   DCHECK(value);
   if (value->GetAsInteger(&value_as_int)) {
     *out = value_as_int;
@@ skipping 26 matching lines @@
     LOG(WARNING) << "ParseServerResponse() : JSONReader failed : "
                  << error_msg;
     return false;
   }
 
   if (!response_value->IsType(Value::TYPE_DICTIONARY)) {
     VLOG(1) << "ParseServerResponse() : Unexpected response type "
             << response_value->GetType();
     return false;
   }
-  const DictionaryValue* response_object =
-      static_cast<DictionaryValue*>(response_value.get());
-
-  // Check the status code.
-  const Value* status_value = NULL;
-  if (!response_object->Get(kStatusString, &status_value)) {
-    VLOG(1) << "ParseServerResponse() : Missing status attribute.";
-    // The status attribute is required.
-    return false;
-  }
-  DCHECK(status_value);
-
-  if (!status_value->IsType(Value::TYPE_STRING)) {
-    VLOG(1) << "ParseServerResponse() : Unexpected status type "
-            << status_value->GetType();
-    // The status attribute is required to be a string.
-    return false;
-  }
-  const StringValue* status_object =
-      static_cast<const StringValue*>(status_value);
-
-  std::string status;
-  if (!status_object->GetAsString(&status)) {
-    VLOG(1) << "ParseServerResponse() : Error parsing the status value.";
-    return false;
-  }
-
-  if (status != kStatusOKString) {
-    VLOG(1) << "ParseServerResponse() : Request failed with status "
-            << status;
-    return false;
-  }
+  const base::DictionaryValue* response_object =
+      static_cast<base::DictionaryValue*>(response_value.get());
 
   // Get the access token, if any.
   response_object->GetString(kAccessTokenString, access_token);
 
   // Get the location
   const Value* location_value = NULL;
   if (!response_object->Get(kLocationString, &location_value)) {
     VLOG(1) << "ParseServerResponse() : Missing location attribute.";
     // GLS returns a response with no location property to represent
     // no fix available; return true to indicate successful parse.
     return true;
   }
   DCHECK(location_value);
 
   if (!location_value->IsType(Value::TYPE_DICTIONARY)) {
     if (!location_value->IsType(Value::TYPE_NULL)) {
       VLOG(1) << "ParseServerResponse() : Unexpected location type "
               << location_value->GetType();
       // If the network provider was unable to provide a position fix, it should
       // return a HTTP 200, with "location" : null. Otherwise it's an error.
       return false;
     }
     return true;  // Successfully parsed response containing no fix.
   }
-  const DictionaryValue* location_object =
-      static_cast<const DictionaryValue*>(location_value);
+  const base::DictionaryValue* location_object =
+      static_cast<const base::DictionaryValue*>(location_value);
 
   // latitude and longitude fields are always required.
   double latitude, longitude;
   if (!GetAsDouble(*location_object, kLatitudeString, &latitude) ||
       !GetAsDouble(*location_object, kLongitudeString, &longitude)) {
     VLOG(1) << "ParseServerResponse() : location lacks lat and/or long.";
     return false;
   }
   // All error paths covered: now start actually modifying postion.
   position->latitude = latitude;
   position->longitude = longitude;
   position->timestamp = timestamp;
 
   // Other fields are optional.
   GetAsDouble(*response_object, kAccuracyString, &position->accuracy);
 
   return true;
 }
 
 }  // namespace
+