Gets rid of the LocationArbitrator interface, in preference for LocationProvider.

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"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "device/geolocation/access_token_store.h"
 
 namespace device {
 namespace {
@@ skipping 104 matching lines @@
       url_context_getter, url,
       base::Bind(&NetworkLocationProvider::OnLocationResponse,
                  base::Unretained(this))));
 }
 
 NetworkLocationProvider::~NetworkLocationProvider() {
   StopProvider();
 }
 
 // LocationProvider implementation
-void NetworkLocationProvider::GetPosition(Geoposition* position) {
-  DCHECK(position);
-  *position = position_;
-}
-
-void NetworkLocationProvider::RequestRefresh() {
-  // 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.
-  // TODO(mcasas): consider not using HasWeakPtrs() https://crbug.com/629158.
-  if (!weak_factory_.HasWeakPtrs() || is_wifi_data_complete_) {
-    RequestPosition();
-  }
+const Geoposition& NetworkLocationProvider::GetPosition() {
+  return position_;
 }
 
 void NetworkLocationProvider::OnPermissionGranted() {
   const bool was_permission_granted = is_permission_granted_;
   is_permission_granted_ = true;
   if (!was_permission_granted && IsStarted()) {
-    RequestRefresh();
+    RequestPosition();
   }
 }
 
 void NetworkLocationProvider::OnWifiDataUpdate() {
   DCHECK(wifi_data_provider_manager_);
   is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_);
   OnWifiDataUpdated();
 }
 
 void NetworkLocationProvider::OnLocationResponse(
@@ skipping 44 matching lines @@
   if (is_wifi_data_complete_)
     OnWifiDataUpdated();
   return true;
 }
 
 void NetworkLocationProvider::OnWifiDataUpdated() {
   DCHECK(CalledOnValidThread());
   wifi_timestamp_ = base::Time::Now();
 
   is_new_data_available_ = is_wifi_data_complete_;
-  RequestRefresh();
+  RequestPosition();
 }
 
 void NetworkLocationProvider::StopProvider() {
   DCHECK(CalledOnValidThread());
   if (IsStarted()) {
     wifi_data_provider_manager_->Unregister(&wifi_data_update_callback_);
   }
   wifi_data_provider_manager_ = nullptr;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 // Other methods
 void NetworkLocationProvider::RequestPosition() {
   DCHECK(CalledOnValidThread());
+
+  // TODO(mcasas): consider not using HasWeakPtrs() https://crbug.com/629158.
+  if (weak_factory_.HasWeakPtrs() && !is_wifi_data_complete_)
+    return;
   if (!is_new_data_available_)
     return;
 
   const Geoposition* cached_position =
       position_cache_->FindPosition(wifi_data_);
   DCHECK(!wifi_timestamp_.is_null())
       << "Timestamp must be set before looking up position";
   if (cached_position) {
     DCHECK(cached_position->Validate());
     // 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_);
     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