Cleaner organization of WifiDataProvider code.

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/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/public/browser/access_token_store.h"
@@ skipping 90 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 base::string16& access_token)
     : access_token_store_(access_token_store),
-      wifi_data_provider_(NULL),
+      wifi_data_provider_manager_(NULL),
       wifi_data_update_callback_(
           base::Bind(&NetworkLocationProvider::OnWifiDataUpdate,
                      base::Unretained(this))),
       is_wifi_data_complete_(false),
       access_token_(access_token),
       is_permission_granted_(false),
       is_new_data_available_(false),
       weak_factory_(this) {
   // Create the position cache.
   position_cache_.reset(new PositionCache());
@@ skipping 25 matching lines @@
 }
 
 void NetworkLocationProvider::OnPermissionGranted() {
   const bool was_permission_granted = is_permission_granted_;
   is_permission_granted_ = true;
   if (!was_permission_granted && IsStarted()) {
     RequestRefresh();
   }
 }
 
-void NetworkLocationProvider::OnWifiDataUpdate(WifiDataProvider* provider) {
-  DCHECK(provider == wifi_data_provider_);
-  is_wifi_data_complete_ = wifi_data_provider_->GetData(&wifi_data_);
+void NetworkLocationProvider::OnWifiDataUpdate(
+    WifiDataProviderManager* manager) {
+  DCHECK(manager == wifi_data_provider_manager_);
+  is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_);
   OnWifiDataUpdated();
 }
 
 void NetworkLocationProvider::OnLocationResponse(
     const Geoposition& position,
     bool server_error,
     const base::string16& access_token,
     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) {
     access_token_ = access_token;
     access_token_store_->SaveAccessToken(request_->url(), access_token);
   }
 
   // Let listeners know that we now have a position available.
   NotifyCallback(position_);
 }
 
 bool NetworkLocationProvider::StartProvider(bool high_accuracy) {
   DCHECK(CalledOnValidThread());
   if (IsStarted())
     return true;
-  DCHECK(wifi_data_provider_ == NULL);
+  DCHECK(wifi_data_provider_manager_ == NULL);
   if (!request_->url().is_valid()) {
     LOG(WARNING) << "StartProvider() : Failed, Bad URL: "
                  << request_->url().possibly_invalid_spec();
     return false;
   }
 
   // Registers a callback with the data provider. The first call to Register
   // will create a singleton data provider and it will be deleted when the last
   // callback is removed with Unregister.
-  wifi_data_provider_ = WifiDataProvider::Register(&wifi_data_update_callback_);
+  wifi_data_provider_manager_ =
+      WifiDataProviderManager::Register(&wifi_data_update_callback_);
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&NetworkLocationProvider::RequestPosition,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kDataCompleteWaitSeconds));
   // Get the wifi data.
-  is_wifi_data_complete_ = wifi_data_provider_->GetData(&wifi_data_);
+  is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_);
   if (is_wifi_data_complete_)
     OnWifiDataUpdated();
   return true;
 }
 
 void NetworkLocationProvider::OnWifiDataUpdated() {
   DCHECK(CalledOnValidThread());
   wifi_data_updated_timestamp_ = base::Time::Now();
 
   is_new_data_available_ = is_wifi_data_complete_;
   RequestRefresh();
 }
 
 void NetworkLocationProvider::StopProvider() {
   DCHECK(CalledOnValidThread());
   if (IsStarted()) {
-    wifi_data_provider_->Unregister(&wifi_data_update_callback_);
+    wifi_data_provider_manager_->Unregister(&wifi_data_update_callback_);
   }
-  wifi_data_provider_ = NULL;
+  wifi_data_provider_manager_ = NULL;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 // Other methods
 void NetworkLocationProvider::RequestPosition() {
   DCHECK(CalledOnValidThread());
   if (!is_new_data_available_)
     return;
 
   const Geoposition* cached_position =
@@ skipping 25 matching lines @@
   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_, wifi_data_,
                         wifi_data_updated_timestamp_);
 }
 
 bool NetworkLocationProvider::IsStarted() const {
-  return wifi_data_provider_ != NULL;
+  return wifi_data_provider_manager_ != NULL;
 }
 
 }  // namespace content