Gets rid of LocationProviderBase.

device/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 "device/geolocation/network_location_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 75 matching lines @@
     *key += separator;
     *key += access_point_data.mac_address;
     *key += separator;
   }
   // If the key is the empty string, return false, as we don't want to cache a
   // position for such data.
   return !key->empty();
 }
 
 // NetworkLocationProvider factory function
-LocationProviderBase* NewNetworkLocationProvider(
+LocationProvider* NewNetworkLocationProvider(
     const scoped_refptr<AccessTokenStore>& access_token_store,
     const scoped_refptr<net::URLRequestContextGetter>& context,
     const GURL& url,
     const base::string16& access_token) {
   return new NetworkLocationProvider(access_token_store, context, url,
                                      access_token);
 }
 
 // NetworkLocationProvider
 NetworkLocationProvider::NetworkLocationProvider(
@@ skipping 20 matching lines @@
 
 NetworkLocationProvider::~NetworkLocationProvider() {
   StopProvider();
 }
 
 // LocationProvider implementation
 const Geoposition& NetworkLocationProvider::GetPosition() {
   return position_;
 }
 
+void NetworkLocationProvider::SetUpdateCallback(
+    const LocationProvider::LocationProviderUpdateCallback& callback) {
+  location_provider_update_callback_ = callback;
+}
+
 void NetworkLocationProvider::OnPermissionGranted() {
   const bool was_permission_granted = is_permission_granted_;
   is_permission_granted_ = true;
   if (!was_permission_granted && IsStarted()) {
     RequestPosition();
   }
 }
 
 void NetworkLocationProvider::OnWifiDataUpdate() {
   DCHECK(wifi_data_provider_manager_);
@@ skipping 13 matching lines @@
     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_);
+  if (!location_provider_update_callback_.is_null())
+    location_provider_update_callback_.Run(this, position_);
 }
 
 bool NetworkLocationProvider::StartProvider(bool high_accuracy) {
   DCHECK(CalledOnValidThread());
   if (IsStarted())
     return true;
   DCHECK(!wifi_data_provider_manager_);
   if (!request_->url().is_valid()) {
     LOG(WARNING) << "StartProvider() : Failed, Bad URL: "
                  << request_->url().possibly_invalid_spec();
@@ skipping 53 matching lines @@
     // Record the position and update its timestamp.
     position_ = *cached_position;
 
     // The timestamp of a position fix is determined by the timestamp
     // of the source data update. (The value of position_.timestamp from
     // the cache could be from weeks ago!)
     position_.timestamp = wifi_timestamp_;
     is_new_data_available_ = false;
 
     // Let listeners know that we now have a position available.
-    NotifyCallback(position_);
+    if (!location_provider_update_callback_.is_null())
+      location_provider_update_callback_.Run(this, position_);
     return;
   }
   // Don't send network requests until authorized. http://crbug.com/39171
   if (!is_permission_granted_)
     return;
 
   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_, wifi_data_, wifi_timestamp_);
 }
 
 bool NetworkLocationProvider::IsStarted() const {
   return wifi_data_provider_manager_ != nullptr;
 }
 
 }  // namespace device