1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "content/browser/geolocation/network_location_request.h" 6 7 #include <set> 8 #include <string> 9 10 #include "base/json/json_reader.h" 11 #include "base/json/json_writer.h" 12 #include "base/metrics/histogram.h" 13 #include "base/metrics/sparse_histogram.h" 14 #include "base/strings/string_number_conversions.h" 15 #include "base/strings/utf_string_conversions.h" 16 #include "base/values.h" 17 #include "content/browser/geolocation/location_arbitrator_impl.h" 18 #include "content/public/common/geoposition.h" 19 #include "google_apis/google_api_keys.h" 20 #include "net/base/escape.h" 21 #include "net/base/load_flags.h" 22 #include "net/url_request/url_fetcher.h" 23 #include "net/url_request/url_request_context_getter.h" 24 #include "net/url_request/url_request_status.h" 25 26 namespace content { 27 namespace { 28 29 const char kAccessTokenString[] = "accessToken"; 30 const char kLocationString[] = "location"; 31 const char kLatitudeString[] = "lat"; 32 const char kLongitudeString[] = "lng"; 33 const char kAccuracyString[] = "accuracy"; 34 35 enum NetworkLocationRequestEvent { 36 // NOTE: Do not renumber these as that would confuse interpretation of 37 // previously logged data. When making changes, also update the enum list 38 // in tools/metrics/histograms/histograms.xml to keep it in sync. 39 NETWORK_LOCATION_REQUEST_EVENT_REQUEST_START = 0, 40 NETWORK_LOCATION_REQUEST_EVENT_REQUEST_CANCEL = 1, 41 NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_SUCCESS = 2, 42 NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_NOT_OK = 3, 43 NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_EMPTY = 4, 44 NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_MALFORMED = 5, 45 NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_INVALID_FIX = 6, 46 47 // NOTE: Add entries only immediately above this line. 48 NETWORK_LOCATION_REQUEST_EVENT_COUNT = 7 49 }; 50 51 void RecordUmaEvent(NetworkLocationRequestEvent event) { 52 UMA_HISTOGRAM_ENUMERATION("Geolocation.NetworkLocationRequest.Event", 53 event, NETWORK_LOCATION_REQUEST_EVENT_COUNT); 54 } 55 56 void RecordUmaResponseCode(int code) { 57 UMA_HISTOGRAM_SPARSE_SLOWLY("Geolocation.NetworkLocationRequest.ResponseCode", 58 code); 59 } 60 61 void RecordUmaAccessPoints(int count) { 62 const int min = 0; 63 const int max = 20; 64 const int buckets = 21; 65 UMA_HISTOGRAM_CUSTOM_COUNTS("Geolocation.NetworkLocationRequest.AccessPoints", 66 count, min, max, buckets); 67 } 68 69 // Local functions 70 // Creates the request url to send to the server. 71 GURL FormRequestURL(const GURL& url); 72 73 void FormUploadData(const WifiData& wifi_data, 74 const base::Time& timestamp, 75 const base::string16& access_token, 76 std::string* upload_data); 77 78 // Attempts to extract a position from the response. Detects and indicates 79 // various failure cases. 80 void GetLocationFromResponse(bool http_post_result, 81 int status_code, 82 const std::string& response_body, 83 const base::Time& timestamp, 84 const GURL& server_url, 85 Geoposition* position, 86 base::string16* access_token); 87 88 // Parses the server response body. Returns true if parsing was successful. 89 // Sets |*position| to the parsed location if a valid fix was received, 90 // otherwise leaves it unchanged. 91 bool ParseServerResponse(const std::string& response_body, 92 const base::Time& timestamp, 93 Geoposition* position, 94 base::string16* access_token); 95 void AddWifiData(const WifiData& wifi_data, 96 int age_milliseconds, 97 base::DictionaryValue* request); 98 } // namespace 99 100 int NetworkLocationRequest::url_fetcher_id_for_tests = 0; 101 102 NetworkLocationRequest::NetworkLocationRequest( 103 net::URLRequestContextGetter* context, 104 const GURL& url, 105 LocationResponseCallback callback) 106 : url_context_(context), 107 callback_(callback), 108 url_(url) { 109 } 110 111 NetworkLocationRequest::~NetworkLocationRequest() { 112 } 113 114 bool NetworkLocationRequest::MakeRequest(const base::string16& access_token, 115 const WifiData& wifi_data, 116 const base::Time& timestamp) { 117 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_REQUEST_START); 118 RecordUmaAccessPoints(wifi_data.access_point_data.size()); 119 if (url_fetcher_ != NULL) { 120 DVLOG(1) << "NetworkLocationRequest : Cancelling pending request"; 121 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_REQUEST_CANCEL); 122 url_fetcher_.reset(); 123 } 124 wifi_data_ = wifi_data; 125 timestamp_ = timestamp; 126 127 GURL request_url = FormRequestURL(url_); 128 url_fetcher_.reset(net::URLFetcher::Create( 129 url_fetcher_id_for_tests, request_url, net::URLFetcher::POST, this)); 130 url_fetcher_->SetRequestContext(url_context_.get()); 131 std::string upload_data; 132 FormUploadData(wifi_data, timestamp, access_token, &upload_data); 133 url_fetcher_->SetUploadData("application/json", upload_data); 134 url_fetcher_->SetLoadFlags( 135 net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE | 136 net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_DO_NOT_SEND_COOKIES | 137 net::LOAD_DO_NOT_SEND_AUTH_DATA); 138 139 start_time_ = base::TimeTicks::Now(); 140 url_fetcher_->Start(); 141 return true; 142 } 143 144 void NetworkLocationRequest::OnURLFetchComplete( 145 const net::URLFetcher* source) { 146 DCHECK_EQ(url_fetcher_.get(), source); 147 148 net::URLRequestStatus status = source->GetStatus(); 149 int response_code = source->GetResponseCode(); 150 RecordUmaResponseCode(response_code); 151 152 Geoposition position; 153 base::string16 access_token; 154 std::string data; 155 source->GetResponseAsString(&data); 156 GetLocationFromResponse(status.is_success(), 157 response_code, 158 data, 159 timestamp_, 160 source->GetURL(), 161 &position, 162 &access_token); 163 const bool server_error = 164 !status.is_success() || (response_code >= 500 && response_code < 600); 165 url_fetcher_.reset(); 166 167 if (!server_error) { 168 const base::TimeDelta request_time = base::TimeTicks::Now() - start_time_; 169 170 UMA_HISTOGRAM_CUSTOM_TIMES( 171 "Net.Wifi.LbsLatency", 172 request_time, 173 base::TimeDelta::FromMilliseconds(1), 174 base::TimeDelta::FromSeconds(10), 175 100); 176 } 177 178 DVLOG(1) << "NetworkLocationRequest::OnURLFetchComplete() : run callback."; 179 callback_.Run(position, server_error, access_token, wifi_data_); 180 } 181 182 // Local functions. 183 namespace { 184 185 struct AccessPointLess { 186 bool operator()(const AccessPointData* ap1, 187 const AccessPointData* ap2) const { 188 return ap2->radio_signal_strength < ap1->radio_signal_strength; 189 } 190 }; 191 192 GURL FormRequestURL(const GURL& url) { 193 if (url == LocationArbitratorImpl::DefaultNetworkProviderURL()) { 194 std::string api_key = google_apis::GetAPIKey(); 195 if (!api_key.empty()) { 196 std::string query(url.query()); 197 if (!query.empty()) 198 query += "&"; 199 query += "key=" + net::EscapeQueryParamValue(api_key, true); 200 GURL::Replacements replacements; 201 replacements.SetQueryStr(query); 202 return url.ReplaceComponents(replacements); 203 } 204 } 205 return url; 206 } 207 208 void FormUploadData(const WifiData& wifi_data, 209 const base::Time& timestamp, 210 const base::string16& access_token, 211 std::string* upload_data) { 212 int age = kint32min; // Invalid so AddInteger() will ignore. 213 if (!timestamp.is_null()) { 214 // Convert absolute timestamps into a relative age. 215 int64 delta_ms = (base::Time::Now() - timestamp).InMilliseconds(); 216 if (delta_ms >= 0 && delta_ms < kint32max) 217 age = static_cast<int>(delta_ms); 218 } 219 220 base::DictionaryValue request; 221 AddWifiData(wifi_data, age, &request); 222 if (!access_token.empty()) 223 request.SetString(kAccessTokenString, access_token); 224 base::JSONWriter::Write(&request, upload_data); 225 } 226 227 void AddString(const std::string& property_name, const std::string& value, 228 base::DictionaryValue* dict) { 229 DCHECK(dict); 230 if (!value.empty()) 231 dict->SetString(property_name, value); 232 } 233 234 void AddInteger(const std::string& property_name, int value, 235 base::DictionaryValue* dict) { 236 DCHECK(dict); 237 if (value != kint32min) 238 dict->SetInteger(property_name, value); 239 } 240 241 void AddWifiData(const WifiData& wifi_data, 242 int age_milliseconds, 243 base::DictionaryValue* request) { 244 DCHECK(request); 245 246 if (wifi_data.access_point_data.empty()) 247 return; 248 249 typedef std::multiset<const AccessPointData*, AccessPointLess> AccessPointSet; 250 AccessPointSet access_points_by_signal_strength; 251 252 for (WifiData::AccessPointDataSet::const_iterator iter = 253 wifi_data.access_point_data.begin(); 254 iter != wifi_data.access_point_data.end(); 255 ++iter) { 256 access_points_by_signal_strength.insert(&(*iter)); 257 } 258 259 base::ListValue* wifi_access_point_list = new base::ListValue(); 260 for (AccessPointSet::iterator iter = 261 access_points_by_signal_strength.begin(); 262 iter != access_points_by_signal_strength.end(); 263 ++iter) { 264 base::DictionaryValue* wifi_dict = new base::DictionaryValue(); 265 AddString("macAddress", base::UTF16ToUTF8((*iter)->mac_address), wifi_dict); 266 AddInteger("signalStrength", (*iter)->radio_signal_strength, wifi_dict); 267 AddInteger("age", age_milliseconds, wifi_dict); 268 AddInteger("channel", (*iter)->channel, wifi_dict); 269 AddInteger("signalToNoiseRatio", (*iter)->signal_to_noise, wifi_dict); 270 wifi_access_point_list->Append(wifi_dict); 271 } 272 request->Set("wifiAccessPoints", wifi_access_point_list); 273 } 274 275 void FormatPositionError(const GURL& server_url, 276 const std::string& message, 277 Geoposition* position) { 278 position->error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE; 279 position->error_message = "Network location provider at '"; 280 position->error_message += server_url.GetOrigin().spec(); 281 position->error_message += "' : "; 282 position->error_message += message; 283 position->error_message += "."; 284 VLOG(1) << "NetworkLocationRequest::GetLocationFromResponse() : " 285 << position->error_message; 286 } 287 288 void GetLocationFromResponse(bool http_post_result, 289 int status_code, 290 const std::string& response_body, 291 const base::Time& timestamp, 292 const GURL& server_url, 293 Geoposition* position, 294 base::string16* access_token) { 295 DCHECK(position); 296 DCHECK(access_token); 297 298 // HttpPost can fail for a number of reasons. Most likely this is because 299 // we're offline, or there was no response. 300 if (!http_post_result) { 301 FormatPositionError(server_url, "No response received", position); 302 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_EMPTY); 303 return; 304 } 305 if (status_code != 200) { // HTTP OK. 306 std::string message = "Returned error code "; 307 message += base::IntToString(status_code); 308 FormatPositionError(server_url, message, position); 309 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_NOT_OK); 310 return; 311 } 312 // We use the timestamp from the wifi data that was used to generate 313 // this position fix. 314 if (!ParseServerResponse(response_body, timestamp, position, access_token)) { 315 // We failed to parse the repsonse. 316 FormatPositionError(server_url, "Response was malformed", position); 317 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_MALFORMED); 318 return; 319 } 320 // The response was successfully parsed, but it may not be a valid 321 // position fix. 322 if (!position->Validate()) { 323 FormatPositionError(server_url, 324 "Did not provide a good position fix", position); 325 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_INVALID_FIX); 326 return; 327 } 328 RecordUmaEvent(NETWORK_LOCATION_REQUEST_EVENT_RESPONSE_SUCCESS); 329 } 330 331 // Numeric values without a decimal point have type integer and IsDouble() will 332 // return false. This is convenience function for detecting integer or floating 333 // point numeric values. Note that isIntegral() includes boolean values, which 334 // is not what we want. 335 bool GetAsDouble(const base::DictionaryValue& object, 336 const std::string& property_name, 337 double* out) { 338 DCHECK(out); 339 const base::Value* value = NULL; 340 if (!object.Get(property_name, &value)) 341 return false; 342 int value_as_int; 343 DCHECK(value); 344 if (value->GetAsInteger(&value_as_int)) { 345 *out = value_as_int; 346 return true; 347 } 348 return value->GetAsDouble(out); 349 } 350 351 bool ParseServerResponse(const std::string& response_body, 352 const base::Time& timestamp, 353 Geoposition* position, 354 base::string16* access_token) { 355 DCHECK(position); 356 DCHECK(!position->Validate()); 357 DCHECK(position->error_code == Geoposition::ERROR_CODE_NONE); 358 DCHECK(access_token); 359 DCHECK(!timestamp.is_null()); 360 361 if (response_body.empty()) { 362 LOG(WARNING) << "ParseServerResponse() : Response was empty."; 363 return false; 364 } 365 DVLOG(1) << "ParseServerResponse() : Parsing response " << response_body; 366 367 // Parse the response, ignoring comments. 368 std::string error_msg; 369 scoped_ptr<base::Value> response_value(base::JSONReader::ReadAndReturnError( 370 response_body, base::JSON_PARSE_RFC, NULL, &error_msg)); 371 if (response_value == NULL) { 372 LOG(WARNING) << "ParseServerResponse() : JSONReader failed : " 373 << error_msg; 374 return false; 375 } 376 377 if (!response_value->IsType(base::Value::TYPE_DICTIONARY)) { 378 VLOG(1) << "ParseServerResponse() : Unexpected response type " 379 << response_value->GetType(); 380 return false; 381 } 382 const base::DictionaryValue* response_object = 383 static_cast<base::DictionaryValue*>(response_value.get()); 384 385 // Get the access token, if any. 386 response_object->GetString(kAccessTokenString, access_token); 387 388 // Get the location 389 const base::Value* location_value = NULL; 390 if (!response_object->Get(kLocationString, &location_value)) { 391 VLOG(1) << "ParseServerResponse() : Missing location attribute."; 392 // GLS returns a response with no location property to represent 393 // no fix available; return true to indicate successful parse. 394 return true; 395 } 396 DCHECK(location_value); 397 398 if (!location_value->IsType(base::Value::TYPE_DICTIONARY)) { 399 if (!location_value->IsType(base::Value::TYPE_NULL)) { 400 VLOG(1) << "ParseServerResponse() : Unexpected location type " 401 << location_value->GetType(); 402 // If the network provider was unable to provide a position fix, it should 403 // return a HTTP 200, with "location" : null. Otherwise it's an error. 404 return false; 405 } 406 return true; // Successfully parsed response containing no fix. 407 } 408 const base::DictionaryValue* location_object = 409 static_cast<const base::DictionaryValue*>(location_value); 410 411 // latitude and longitude fields are always required. 412 double latitude, longitude; 413 if (!GetAsDouble(*location_object, kLatitudeString, &latitude) || 414 !GetAsDouble(*location_object, kLongitudeString, &longitude)) { 415 VLOG(1) << "ParseServerResponse() : location lacks lat and/or long."; 416 return false; 417 } 418 // All error paths covered: now start actually modifying postion. 419 position->latitude = latitude; 420 position->longitude = longitude; 421 position->timestamp = timestamp; 422 423 // Other fields are optional. 424 GetAsDouble(*response_object, kAccuracyString, &position->accuracy); 425 426 return true; 427 } 428 429 } // namespace 430 431 } // namespace content 432
