Split out of reverted change http://src.chromium.org/viewvc/chrome?view=rev&r...

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_util.h"
 #include "base/values.h"
@@ skipping 48 matching lines @@
 void AddRadioData(const RadioData& radio_data, DictionaryValue* body_object);
 void AddWifiData(const WifiData& wifi_data, DictionaryValue* body_object);
 }  // namespace
 
 NetworkLocationRequest::NetworkLocationRequest(URLRequestContextGetter* context,
                                                const GURL& url,
                                                const string16& host_name,
                                                ListenerInterface* listener)
     : url_context_(context), timestamp_(kint64min), listener_(listener),
       url_(url), host_name_(host_name) {
-//  DCHECK(url_context_);
   DCHECK(listener);
 }
 
 NetworkLocationRequest::~NetworkLocationRequest() {
 }
 
 bool NetworkLocationRequest::MakeRequest(const string16& access_token,
                                          const RadioData& radio_data,
                                          const WifiData& wifi_data,
                                          int64 timestamp) {
   if (url_fetcher_ != NULL) {
     DLOG(INFO) << "NetworkLocationRequest : Cancelling pending request";
     url_fetcher_.reset();
   }
   std::string post_body;
   if (!FormRequestBody(host_name_, access_token, radio_data, wifi_data,
                        &post_body)) {
     return false;
   }
   timestamp_ = timestamp;
 
   url_fetcher_.reset(URLFetcher::Create(
-      host_name_.size(),  // Used for testing
+      wifi_data.access_point_data.size(),  // Used for testing
       url_, URLFetcher::POST, this));
   url_fetcher_->set_upload_data(kMimeApplicationJson, post_body);
   url_fetcher_->set_request_context(url_context_);
   url_fetcher_->Start();
   return true;
 }
 
 void NetworkLocationRequest::OnURLFetchComplete(const URLFetcher* source,
                                                 const GURL& url,
                                                 const URLRequestStatus& status,
@@ skipping 202 matching lines @@
               << response_value->GetType() <<  ".\n";
     return false;
   }
   const DictionaryValue* response_object =
       static_cast<DictionaryValue*>(response_value.get());
 
   // Get the access token, if any.
   response_object->GetStringAsUTF16(kAccessTokenString, access_token);
 
   // Get the location
-  DictionaryValue* location_object;
-  if (!response_object->GetDictionary(kLocationString, &location_object)) {
-    Value* value = NULL;
-    // If the network provider was unable to provide a position fix, it should
-    // return a 200 with location == null. Otherwise it's an error.
-    return response_object->Get(kLocationString, &value)
-           && value && value->IsType(Value::TYPE_NULL);
+  Value* location_value = NULL;
+  if (!response_object->Get(kLocationString, &location_value)) {
+    LOG(INFO) << "ParseServerResponse() : Missing location attribute.\n";
+    return false;
   }
-  DCHECK(location_object);
+  DCHECK(location_value);
+
+  if (!location_value->IsType(Value::TYPE_DICTIONARY)) {
+    if (!location_value->IsType(Value::TYPE_NULL)) {
+      LOG(INFO) << "ParseServerResponse() : Unexpected location type"
+                << location_value->GetType() << ".\n";
+      // 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.
+  }
+  DictionaryValue* location_object =
+      static_cast<DictionaryValue*>(location_value);
 
   // latitude and longitude fields are always required.
   double latitude, longitude;
   if (!GetAsDouble(*location_object, kLatitudeString, &latitude) ||
       !GetAsDouble(*location_object, kLongitudeString, &longitude)) {
+    LOG(INFO) << "ParseServerResponse() : location lacks lat and/or long.\n";
     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(*location_object, kAccuracyString, &position->accuracy);
   GetAsDouble(*location_object, kAltitudeString, &position->altitude);
@@ skipping 56 matching lines @@
     AddInteger(L"signal_strength", iter->radio_signal_strength, wifi_tower);
     AddInteger(L"age", iter->age, wifi_tower);
     AddInteger(L"channel", iter->channel, wifi_tower);
     AddInteger(L"signal_to_noise", iter->signal_to_noise, wifi_tower);
     AddString(L"ssid", iter->ssid, wifi_tower);
     wifi_towers->Append(wifi_tower);
   }
   body_object->Set(L"wifi_towers", wifi_towers);
 }
 }  // namespace