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

device/geolocation/location_arbitrator_impl_unittest.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/location_arbitrator_impl.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "device/geolocation/fake_access_token_store.h"
 #include "device/geolocation/geolocation_delegate.h"
 #include "device/geolocation/geoposition.h"
 #include "device/geolocation/mock_location_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::NiceMock;
 
 namespace device {
 
 class MockLocationObserver {
  public:
   // Need a vtable for GMock.
   virtual ~MockLocationObserver() {}
   void InvalidateLastPosition() {
     last_position_.latitude = 100;
     last_position_.error_code = Geoposition::ERROR_CODE_NONE;
     ASSERT_FALSE(last_position_.Validate());
   }
   // Delegate
-  void OnLocationUpdate(const Geoposition& position) {
+  void OnLocationUpdate(const LocationProvider*, const Geoposition& position) {
     last_position_ = position;
   }
 
   Geoposition last_position_;
 };
 
 double g_fake_time_now_secs = 1;
 
 base::Time GetTimeNowForTest() {
   return base::Time::FromDoubleT(g_fake_time_now_secs);
@@ skipping 45 matching lines @@
   MockLocationProvider* mock_location_provider_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 }  // namespace
 
 class TestingLocationArbitrator : public LocationArbitratorImpl {
  public:
   TestingLocationArbitrator(
-      const LocationArbitratorImpl::LocationUpdateCallback& callback,
+      const LocationProviderUpdateCallback& callback,
       const scoped_refptr<AccessTokenStore>& access_token_store,
       GeolocationDelegate* delegate)
-      : LocationArbitratorImpl(callback, delegate),
+      : LocationArbitratorImpl(delegate),
         cell_(nullptr),
         gps_(nullptr),
-        access_token_store_(access_token_store) {}
+        access_token_store_(access_token_store) {
+    SetUpdateCallback(callback);
+  }
 
   base::Time GetTimeNow() const override { return GetTimeNowForTest(); }
 
   scoped_refptr<AccessTokenStore> NewAccessTokenStore() override {
     return access_token_store_;
   }
 
   std::unique_ptr<LocationProvider> NewNetworkLocationProvider(
       const scoped_refptr<AccessTokenStore>& access_token_store,
       const scoped_refptr<net::URLRequestContextGetter>& context,
@@ skipping 24 matching lines @@
   GeolocationLocationArbitratorTest()
       : access_token_store_(new NiceMock<FakeAccessTokenStore>),
         observer_(new MockLocationObserver),
         delegate_(new GeolocationDelegate) {}
 
   // Initializes |arbitrator_|, with the possibility of injecting a specific
   // |delegate|, otherwise a default, no-op GeolocationDelegate is used.
   void InitializeArbitrator(std::unique_ptr<GeolocationDelegate> delegate) {
     if (delegate)
       delegate_ = std::move(delegate);
-    const LocationArbitratorImpl::LocationUpdateCallback callback =
+    const LocationProvider::LocationProviderUpdateCallback callback =
         base::Bind(&MockLocationObserver::OnLocationUpdate,
                    base::Unretained(observer_.get()));
     arbitrator_.reset(new TestingLocationArbitrator(
         callback, access_token_store_, delegate_.get()));
   }
 
   // testing::Test
   void TearDown() override {}
 
   void CheckLastPositionInfo(double latitude,
@@ skipping 26 matching lines @@
 TEST_F(GeolocationLocationArbitratorTest, CreateDestroy) {
   EXPECT_TRUE(access_token_store_.get());
   InitializeArbitrator(nullptr);
   EXPECT_TRUE(arbitrator_);
   arbitrator_.reset();
   SUCCEED();
 }
 
 TEST_F(GeolocationLocationArbitratorTest, OnPermissionGranted) {
   InitializeArbitrator(nullptr);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
   // Can't check the provider has been notified without going through the
   // motions to create the provider (see next test).
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
 }
 
 TEST_F(GeolocationLocationArbitratorTest, NormalUsage) {
   InitializeArbitrator(nullptr);
   ASSERT_TRUE(access_token_store_.get());
   ASSERT_TRUE(arbitrator_);
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
 
   EXPECT_TRUE(access_token_store_->access_token_map_.empty());
 
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   EXPECT_TRUE(gps());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, gps()->state_);
   EXPECT_FALSE(observer_->last_position_.Validate());
   EXPECT_EQ(Geoposition::ERROR_CODE_NONE, observer_->last_position_.error_code);
 
   SetReferencePosition(cell());
 
   EXPECT_TRUE(observer_->last_position_.Validate() ||
               observer_->last_position_.error_code !=
                   Geoposition::ERROR_CODE_NONE);
-  EXPECT_EQ(cell()->position_.latitude, observer_->last_position_.latitude);
+  EXPECT_EQ(cell()->position().latitude, observer_->last_position_.latitude);
 
-  EXPECT_FALSE(cell()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(cell()->is_permission_granted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
-  EXPECT_TRUE(cell()->is_permission_granted_);
+  EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
+  EXPECT_TRUE(cell()->is_permission_granted());
 }
 
 TEST_F(GeolocationLocationArbitratorTest, CustomSystemProviderOnly) {
   FakeGeolocationDelegate* fake_delegate = new FakeGeolocationDelegate;
   fake_delegate->set_use_network(false);
 
   std::unique_ptr<GeolocationDelegate> delegate(fake_delegate);
   InitializeArbitrator(std::move(delegate));
   ASSERT_TRUE(arbitrator_);
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
 
   ASSERT_FALSE(cell());
   EXPECT_FALSE(gps());
   ASSERT_TRUE(fake_delegate->mock_location_provider());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY,
             fake_delegate->mock_location_provider()->state_);
   EXPECT_FALSE(observer_->last_position_.Validate());
   EXPECT_EQ(Geoposition::ERROR_CODE_NONE, observer_->last_position_.error_code);
 
   SetReferencePosition(fake_delegate->mock_location_provider());
 
   EXPECT_TRUE(observer_->last_position_.Validate() ||
               observer_->last_position_.error_code !=
                   Geoposition::ERROR_CODE_NONE);
-  EXPECT_EQ(fake_delegate->mock_location_provider()->position_.latitude,
+  EXPECT_EQ(fake_delegate->mock_location_provider()->position().latitude,
             observer_->last_position_.latitude);
 
-  EXPECT_FALSE(fake_delegate->mock_location_provider()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(
+      fake_delegate->mock_location_provider()->is_permission_granted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
-  EXPECT_TRUE(fake_delegate->mock_location_provider()->is_permission_granted_);
+  EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
+  EXPECT_TRUE(fake_delegate->mock_location_provider()->is_permission_granted());
 }
 
 TEST_F(GeolocationLocationArbitratorTest,
        CustomSystemAndDefaultNetworkProviders) {
   FakeGeolocationDelegate* fake_delegate = new FakeGeolocationDelegate;
   fake_delegate->set_use_network(true);
 
   std::unique_ptr<GeolocationDelegate> delegate(fake_delegate);
   InitializeArbitrator(std::move(delegate));
   ASSERT_TRUE(arbitrator_);
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
 
   EXPECT_TRUE(access_token_store_->access_token_map_.empty());
 
   access_token_store_->NotifyDelegateTokensLoaded();
 
   ASSERT_TRUE(cell());
   EXPECT_FALSE(gps());
   ASSERT_TRUE(fake_delegate->mock_location_provider());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY,
             fake_delegate->mock_location_provider()->state_);
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
   EXPECT_FALSE(observer_->last_position_.Validate());
   EXPECT_EQ(Geoposition::ERROR_CODE_NONE, observer_->last_position_.error_code);
 
   SetReferencePosition(cell());
 
   EXPECT_TRUE(observer_->last_position_.Validate() ||
               observer_->last_position_.error_code !=
                   Geoposition::ERROR_CODE_NONE);
-  EXPECT_EQ(cell()->position_.latitude, observer_->last_position_.latitude);
+  EXPECT_EQ(cell()->position().latitude, observer_->last_position_.latitude);
 
-  EXPECT_FALSE(cell()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(cell()->is_permission_granted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
-  EXPECT_TRUE(cell()->is_permission_granted_);
+  EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
+  EXPECT_TRUE(cell()->is_permission_granted());
 }
 
 TEST_F(GeolocationLocationArbitratorTest, SetObserverOptions) {
   InitializeArbitrator(nullptr);
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   ASSERT_TRUE(gps());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, gps()->state_);
   SetReferencePosition(cell());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, gps()->state_);
-  arbitrator_->StartProviders(true);
+  arbitrator_->StartProvider(true);
   EXPECT_EQ(MockLocationProvider::HIGH_ACCURACY, cell()->state_);
   EXPECT_EQ(MockLocationProvider::HIGH_ACCURACY, gps()->state_);
 }
 
 TEST_F(GeolocationLocationArbitratorTest, Arbitration) {
   InitializeArbitrator(nullptr);
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   ASSERT_TRUE(gps());
 
   SetPositionFix(cell(), 1, 2, 150);
 
   // First position available
   EXPECT_TRUE(observer_->last_position_.Validate());
   CheckLastPositionInfo(1, 2, 150);
 
   SetPositionFix(gps(), 3, 4, 50);
 
   // More accurate fix available
   CheckLastPositionInfo(3, 4, 50);
 
   SetPositionFix(cell(), 5, 6, 150);
 
   // New fix is available but it's less accurate, older fix should be kept.
   CheckLastPositionInfo(3, 4, 50);
 
   // Advance time, and notify once again
   AdvanceTimeNow(SwitchOnFreshnessCliff());
-  cell()->HandlePositionChanged(cell()->position_);
+  cell()->HandlePositionChanged(cell()->position());
 
   // New fix is available, less accurate but fresher
   CheckLastPositionInfo(5, 6, 150);
 
   // Advance time, and set a low accuracy position
   AdvanceTimeNow(SwitchOnFreshnessCliff());
   SetPositionFix(cell(), 5.676731, 139.629385, 1000);
   CheckLastPositionInfo(5.676731, 139.629385, 1000);
 
   // 15 secs later, step outside. Switches to gps signal.
@@ skipping 33 matching lines @@
 
   // 2 minutes later
   AdvanceTimeNow(base::TimeDelta::FromMinutes(2));
   // Arrive in station. Cell moves but GPS is stale. Switch to fresher cell.
   SetPositionFix(cell(), 3.5658700, 139.069979, 1000);
   CheckLastPositionInfo(3.5658700, 139.069979, 1000);
 }
 
 TEST_F(GeolocationLocationArbitratorTest, TwoOneShotsIsNewPositionBetter) {
   InitializeArbitrator(nullptr);
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   ASSERT_TRUE(gps());
 
   // Set the initial position.
   SetPositionFix(cell(), 3, 139, 100);
   CheckLastPositionInfo(3, 139, 100);
 
   // Restart providers to simulate a one-shot request.
-  arbitrator_->StopProviders();
+  arbitrator_->StopProvider();
 
   // To test 240956, perform a throwaway alloc.
   // This convinces the allocator to put the providers in a new memory location.
   std::unique_ptr<MockLocationProvider> dummy_provider(
       new MockLocationProvider);
 
-  arbitrator_->StartProviders(false);
+  arbitrator_->StartProvider(false);
   access_token_store_->NotifyDelegateTokensLoaded();
 
   // Advance the time a short while to simulate successive calls.
   AdvanceTimeNow(base::TimeDelta::FromMilliseconds(5));
 
   // Update with a less accurate position to verify 240956.
   SetPositionFix(cell(), 3, 139, 150);
   CheckLastPositionInfo(3, 139, 150);
 }
 
 }  // namespace device