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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
@@ skipping 86 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(
+    LocationProvider* arbitrator) {
+  arbitrator_ = base::WrapUnique(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_) {
+    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);
+
+    arbitrator_ = base::WrapUnique(
+        new LocationArbitratorImpl(callback, g_delegate.Get().get()));

[Wez, 2016/08/12 00:33:44]

nit: You can use MakeUnique here. :)

[CJ, 2016/08/12 20:22:46]

Done.

+  }
 }
 
 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::WrapUnique(
-      new LocationArbitratorImpl(callback, g_delegate.Get().get()));
-}
-
 }  // namespace device