Remove RadioData from geolocation

content/browser/geolocation/network_location_provider.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_provider.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/access_token_store.h"
@@ skipping 58 matching lines @@
 
 // Makes the key for the map of cached positions, using a set of
 // device data. Returns true if a good key was generated, false otherwise.
 //
 // static
 bool NetworkLocationProvider::PositionCache::MakeKey(
     const WifiData& wifi_data,
     string16* key) {
   // Currently we use only the WiFi data, and base the key only on
   // the MAC addresses.
-  // TODO(joth): Make use of radio_data.
   DCHECK(key);
   key->clear();
   const size_t kCharsPerMacAddress = 6 * 3 + 1;  // e.g. "11:22:33:44:55:66|"
   key->reserve(wifi_data.access_point_data.size() * kCharsPerMacAddress);
   const string16 separator(ASCIIToUTF16("|"));
   for (WifiData::AccessPointDataSet::const_iterator iter =
        wifi_data.access_point_data.begin();
        iter != wifi_data.access_point_data.end();
        iter++) {
     *key += separator;
@@ skipping 15 matching lines @@
       access_token_store, context, url, access_token);
 }
 
 // NetworkLocationProvider
 NetworkLocationProvider::NetworkLocationProvider(
     AccessTokenStore* access_token_store,
     net::URLRequestContextGetter* url_context_getter,
     const GURL& url,
     const string16& access_token)
     : access_token_store_(access_token_store),
-      radio_data_provider_(NULL),
       wifi_data_provider_(NULL),
-      is_radio_data_complete_(false),
       is_wifi_data_complete_(false),
       access_token_(access_token),
       is_permission_granted_(false),
       is_new_data_available_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // Create the position cache.
   position_cache_.reset(new PositionCache());
 
   request_.reset(new NetworkLocationRequest(url_context_getter, url, this));
 }
 
 NetworkLocationProvider::~NetworkLocationProvider() {
   StopProvider();
 }
 
 // LocationProviderBase implementation
 void NetworkLocationProvider::GetPosition(Geoposition *position) {
   DCHECK(position);
   *position = position_;
 }
 
 void NetworkLocationProvider::UpdatePosition() {
   // TODO(joth): When called via the public (base class) interface, this should
   // poke each data provider to get them to expedite their next scan.
   // Whilst in the delayed start, only send request if all data is ready.
-  if (!weak_factory_.HasWeakPtrs() ||
-      (is_radio_data_complete_ && is_wifi_data_complete_)) {
+  if (!weak_factory_.HasWeakPtrs() || is_wifi_data_complete_) {
     RequestPosition();
   }
 }
 
 void NetworkLocationProvider::OnPermissionGranted() {
   const bool was_permission_granted = is_permission_granted_;
   is_permission_granted_ = true;
   if (!was_permission_granted && IsStarted()) {
     UpdatePosition();
   }
 }
 
 // DeviceDataProviderInterface::ListenerInterface implementation.
 void NetworkLocationProvider::DeviceDataUpdateAvailable(
-    RadioDataProvider* provider) {
-  DCHECK(provider == radio_data_provider_);
-  is_radio_data_complete_ = radio_data_provider_->GetData(&radio_data_);
-  OnDeviceDataUpdated();
-}
-
-void NetworkLocationProvider::DeviceDataUpdateAvailable(
     WifiDataProvider* provider) {
   DCHECK(provider == wifi_data_provider_);
   is_wifi_data_complete_ = wifi_data_provider_->GetData(&wifi_data_);
   OnDeviceDataUpdated();
 }
 
 // NetworkLocationRequest::ListenerInterface implementation.
 void NetworkLocationProvider::LocationResponseAvailable(
     const Geoposition& position,
     bool server_error,
     const string16& access_token,
-    const RadioData& radio_data,
     const WifiData& wifi_data) {
   DCHECK(CalledOnValidThread());
   // Record the position and update our cache.
   position_ = position;
   if (position.Validate()) {
     position_cache_->CachePosition(wifi_data, position);
   }
 
   // Record access_token if it's set.
   if (!access_token.empty() && access_token_ != access_token) {
@@ skipping 11 matching lines @@
     return true;
   DCHECK(wifi_data_provider_ == NULL);
   if (!request_->url().is_valid()) {
     LOG(WARNING) << "StartProvider() : Failed, Bad URL: "
                  << request_->url().possibly_invalid_spec();
     return false;
   }
 
   // Get the device data providers. The first call to Register will create the
   // provider and it will be deleted by ref counting.
-  radio_data_provider_ = RadioDataProvider::Register(this);
   wifi_data_provider_ = WifiDataProvider::Register(this);
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&NetworkLocationProvider::RequestPosition,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kDataCompleteWaitSeconds));
   // Get the device data.
-  is_radio_data_complete_ = radio_data_provider_->GetData(&radio_data_);
   is_wifi_data_complete_ = wifi_data_provider_->GetData(&wifi_data_);
-  if (is_radio_data_complete_ || is_wifi_data_complete_)
+  if (is_wifi_data_complete_)
     OnDeviceDataUpdated();
   return true;
 }
 
 void NetworkLocationProvider::StopProvider() {
   DCHECK(CalledOnValidThread());
   if (IsStarted()) {
-    radio_data_provider_->Unregister(this);
     wifi_data_provider_->Unregister(this);
   }
-  radio_data_provider_ = NULL;
   wifi_data_provider_ = NULL;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 // Other methods
 void NetworkLocationProvider::RequestPosition() {
   DCHECK(CalledOnValidThread());
   if (!is_new_data_available_)
     return;
 
@@ skipping 21 matching lines @@
   weak_factory_.InvalidateWeakPtrs();
   is_new_data_available_ = false;
 
   // TODO(joth): Rather than cancel pending requests, we should create a new
   // NetworkLocationRequest for each and hold a set of pending requests.
   if (request_->is_request_pending()) {
     DVLOG(1) << "NetworkLocationProvider - pre-empting pending network request "
                 "with new data. Wifi APs: "
              << wifi_data_.access_point_data.size();
   }
-  request_->MakeRequest(access_token_,
-                        radio_data_, wifi_data_,
+  request_->MakeRequest(access_token_, wifi_data_,
                         device_data_updated_timestamp_);
 }
 
 void NetworkLocationProvider::OnDeviceDataUpdated() {
   DCHECK(CalledOnValidThread());
   device_data_updated_timestamp_ = base::Time::Now();
 
-  is_new_data_available_ = is_radio_data_complete_ || is_wifi_data_complete_;
+  is_new_data_available_ = is_wifi_data_complete_;
   UpdatePosition();
 }
 
 bool NetworkLocationProvider::IsStarted() const {
-  DCHECK_EQ(!!radio_data_provider_, !!wifi_data_provider_);
   return wifi_data_provider_ != NULL;
 }