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

device/geolocation/geolocation_provider_impl.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/geolocation_provider_impl.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 48 matching lines @@
     InformProvidersPermissionGranted();
 }
 
 void GeolocationProviderImpl::OverrideLocationForTesting(
     const Geoposition& position) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   ignore_location_updates_ = true;
   NotifyClients(position);
 }
 
-void GeolocationProviderImpl::OnLocationUpdate(const Geoposition& position) {
+void GeolocationProviderImpl::OnLocationUpdate(const LocationProvider* provider,
+                                               const Geoposition& position) {
   DCHECK(OnGeolocationThread());
   // Will be true only in testing.
   if (ignore_location_updates_)
     return;
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GeolocationProviderImpl::NotifyClients,
                             base::Unretained(this), position));
 }
 
 // static
@@ skipping 11 matching lines @@
       &GeolocationProviderImpl::OnClientsChanged, base::Unretained(this)));
   low_accuracy_callbacks_.set_removal_callback(base::Bind(
       &GeolocationProviderImpl::OnClientsChanged, base::Unretained(this)));
 }
 
 GeolocationProviderImpl::~GeolocationProviderImpl() {
   Stop();
   DCHECK(!arbitrator_);
 }
 
+void GeolocationProviderImpl::SetArbitratorForTesting(
+    std::unique_ptr<LocationProvider> arbitrator) {
+  arbitrator_ = std::move(arbitrator);
+}
+
 bool GeolocationProviderImpl::OnGeolocationThread() const {
   return task_runner()->BelongsToCurrentThread();
 }
 
 void GeolocationProviderImpl::OnClientsChanged() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   base::Closure task;
   if (high_accuracy_callbacks_.empty() && low_accuracy_callbacks_.empty()) {
     DCHECK(IsRunning());
     if (!ignore_location_updates_) {
@@ skipping 16 matching lines @@
     task = base::Bind(&GeolocationProviderImpl::StartProviders,
                       base::Unretained(this), enable_high_accuracy);
   }
 
   task_runner()->PostTask(FROM_HERE, task);
 }
 
 void GeolocationProviderImpl::StopProviders() {
   DCHECK(OnGeolocationThread());
   DCHECK(arbitrator_);
-  arbitrator_->StopProviders();
+  arbitrator_->StopProvider();
 }
 
 void GeolocationProviderImpl::StartProviders(bool enable_high_accuracy) {
   DCHECK(OnGeolocationThread());
   DCHECK(arbitrator_);
-  arbitrator_->StartProviders(enable_high_accuracy);
+  arbitrator_->StartProvider(enable_high_accuracy);
 }
 
 void GeolocationProviderImpl::InformProvidersPermissionGranted() {
   DCHECK(IsRunning());
   if (!OnGeolocationThread()) {
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&GeolocationProviderImpl::InformProvidersPermissionGranted,
                    base::Unretained(this)));
     return;
   }
   DCHECK(OnGeolocationThread());
   DCHECK(arbitrator_);
   arbitrator_->OnPermissionGranted();
 }
 
 void GeolocationProviderImpl::NotifyClients(const Geoposition& position) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(position.Validate() ||
          position.error_code != Geoposition::ERROR_CODE_NONE);
   position_ = position;
   high_accuracy_callbacks_.Notify(position_);
   low_accuracy_callbacks_.Notify(position_);
 }
 
 void GeolocationProviderImpl::Init() {
   DCHECK(OnGeolocationThread());
-  DCHECK(!arbitrator_);
-  arbitrator_ = CreateArbitrator();
+
+  if (!arbitrator_) {
+    LocationProvider::LocationProviderUpdateCallback callback = base::Bind(
+        &GeolocationProviderImpl::OnLocationUpdate, base::Unretained(this));
+    // Use the embedder's |g_delegate| or fall back to the default one.
+    if (!g_delegate.Get())
+      g_delegate.Get().reset(new GeolocationDelegate);
+
+    arbitrator_ =
+        base::MakeUnique<LocationArbitratorImpl>(g_delegate.Get().get());
+    arbitrator_->SetUpdateCallback(callback);
+  }
 }
 
 void GeolocationProviderImpl::CleanUp() {
   DCHECK(OnGeolocationThread());
   arbitrator_.reset();
 }
 
-std::unique_ptr<LocationArbitrator>
-GeolocationProviderImpl::CreateArbitrator() {
-  LocationArbitratorImpl::LocationUpdateCallback callback = base::Bind(
-      &GeolocationProviderImpl::OnLocationUpdate, base::Unretained(this));
-  // Use the embedder's |g_delegate| or fall back to the default one.
-  if (!g_delegate.Get())
-    g_delegate.Get().reset(new GeolocationDelegate);
-
-  return base::MakeUnique<LocationArbitratorImpl>(callback,
-                                                  g_delegate.Get().get());
-}
-
 }  // namespace device