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"
 
@@ skipping 89 matching lines @@
 
   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,
       const GURL& url,
       const base::string16& access_token) override {
     cell_ = new MockLocationProvider;

[Kevin M, 2016/08/15 21:34:54]

StrictMock here and elsewhere in this test that mock objects are created. It's
vital that we pay attention to how the arbitrator interacts with these objects.
It doesn't look like the existing tests cover this aspect, so we'll need to
backfill a few tests here.

[CJ, 2016/08/15 23:09:52]

To be noted, these are not actually mock objects, but rather fakes. Should I go
ahead and just enclose these with StrictMock or wait until an actual refactor?
Does StrictMock even do anything when the class it gets passed is not Mock? 

[Kevin M, 2016/08/17 17:44:37]

Ooh, right. No, StrictMock doesn't do anything for non-mocked classes.

I commented on this in another CL. This fake is lightweight enough that it
should be a mock. I won't hold up this CL for that cleanup, though.

[CJ, 2016/08/17 23:07:10]

Acknowledged.

     return base::WrapUnique(cell_);
   }
 
   std::unique_ptr<LocationProvider> NewSystemLocationProvider() override {
     gps_ = new MockLocationProvider;
     return base::WrapUnique(gps_);
   }
 
   // Two location providers, with nice short names to make the tests more
   // readable. Note |gps_| will only be set when there is a high accuracy
@@ skipping 58 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_FALSE(cell()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
+  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,
             observer_->last_position_.latitude);
 
   EXPECT_FALSE(fake_delegate->mock_location_provider()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
+  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_FALSE(cell()->is_permission_granted_);
-  EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
+  EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
-  EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
+  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);
 
@@ skipping 56 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