Geolocation: Extract GeolocationProvider::Delegate into GeolocationDelegate (no new code)

content/browser/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 "content/browser/geolocation/location_arbitrator_impl.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/geolocation/fake_access_token_store.h"
 #include "content/browser/geolocation/mock_location_provider.h"
+#include "content/public/browser/geolocation_delegate.h"
 #include "content/public/common/geoposition.h"
 #include "content/test/test_content_browser_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::NiceMock;
 
 namespace content {
 
 class MockLocationObserver {
@@ skipping 36 matching lines @@
   ASSERT_TRUE(position.Validate());
   provider->HandlePositionChanged(position);
 }
 
 void SetReferencePosition(MockLocationProvider* provider) {
   SetPositionFix(provider, 51.0, -0.1, 400);
 }
 
 namespace {
 
-class FakeDelegate : public GeolocationProvider::Delegate {
+class FakeGeolocationDelegate : public GeolocationDelegate {
  public:
-  FakeDelegate() = default;
+  FakeGeolocationDelegate() = default;
 
   bool UseNetworkLocationProviders() override { return use_network_; }
   void set_use_network(bool use_network) { use_network_ = use_network; }
 
   LocationProvider* OverrideSystemLocationProvider() override {
     if (!system_location_provider_)
       system_location_provider_ = base::WrapUnique(new MockLocationProvider);
     return system_location_provider_.get();
   }
 
   LocationProvider* system_location_provider() const {
     return system_location_provider_.get();
   }
 
  private:
   bool use_network_ = true;
   std::unique_ptr<LocationProvider> system_location_provider_;
 
-  DISALLOW_COPY_AND_ASSIGN(FakeDelegate);
+  DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 class TestingLocationArbitrator : public LocationArbitratorImpl {
  public:
   TestingLocationArbitrator(
       const LocationArbitratorImpl::LocationUpdateCallback& callback,
       AccessTokenStore* access_token_store,
-      GeolocationProvider::Delegate* delegate,
+      GeolocationDelegate* delegate,
       bool is_fake_delegate)
       : LocationArbitratorImpl(callback, delegate),
         is_fake_delegate_(is_fake_delegate),
         cell_(nullptr),
         gps_(nullptr),
         access_token_store_(access_token_store) {}
 
   base::Time GetTimeNow() const override { return GetTimeNowForTest(); }
 
   AccessTokenStore* NewAccessTokenStore() override {
     return access_token_store_.get();
   }
 
   std::unique_ptr<LocationProvider> NewNetworkLocationProvider(
       AccessTokenStore* access_token_store,
       net::URLRequestContextGetter* context,
       const GURL& url,
       const base::string16& access_token) override {
     cell_ = new MockLocationProvider;
     return base::WrapUnique(cell_);
   }
 
   std::unique_ptr<LocationProvider> NewSystemLocationProvider() override {
     gps_ = new MockLocationProvider;
     return base::WrapUnique(gps_);
   }
 
-  FakeDelegate* GetFakeDelegate() {
+  FakeGeolocationDelegate* GetFakeGeolocationDelegate() {
     DCHECK(is_fake_delegate_);
-    return static_cast<FakeDelegate*>(GetDelegateForTesting());
+    return static_cast<FakeGeolocationDelegate*>(GetDelegateForTesting());
   }
 
   LocationProvider* GetLocationProvider() {
     if (is_fake_delegate_)
-      return GetFakeDelegate()->system_location_provider();
+      return GetFakeGeolocationDelegate()->system_location_provider();
     return GetDelegateForTesting()->OverrideSystemLocationProvider();
   }
 
   const bool is_fake_delegate_;
 
   // 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
   // observer registered (and |cell_| when there's at least one observer of any
   // type).
 
   // TODO(mvanouwerkerk): rename |cell_| to |network_location_provider_| and
   // |gps_| to |system_location_provider_|
   MockLocationProvider* cell_;
   MockLocationProvider* gps_;
   scoped_refptr<AccessTokenStore> access_token_store_;
 };
 
 }  // namespace
 
 class GeolocationLocationArbitratorTest : public testing::Test {
  protected:
   // testing::Test
   void SetUp() override {
     access_token_store_ = new NiceMock<FakeAccessTokenStore>;
     observer_.reset(new MockLocationObserver);
   }
 
-  // There are two types of test cases: those using FakeDelegate and the ones
-  // exercising whatever the embedder provides. Test cases call this method to
-  // choose the appropriate one.
+  // There are two types of test cases: those using FakeGeolocationDelegate and
+  // the ones exercising whatever the embedder provides. Test cases call this
+  // method to choose the appropriate one.
   void InitializeArbitrator(bool use_fake_delegate) {
-    delegate_.reset(use_fake_delegate ? new FakeDelegate()
-                                      : new GeolocationProvider::Delegate);
+    delegate_.reset(use_fake_delegate ? new FakeGeolocationDelegate()
+                                      : new GeolocationDelegate);
     const LocationArbitratorImpl::LocationUpdateCallback callback =
         base::Bind(&MockLocationObserver::OnLocationUpdate,
                    base::Unretained(observer_.get()));
     arbitrator_.reset(
         new TestingLocationArbitrator(callback, access_token_store_.get(),
                                       delegate_.get(), use_fake_delegate));
   }
 
   // testing::Test
   void TearDown() override {}
@@ skipping 23 matching lines @@
   }
 
   MockLocationProvider* GetSystemLocationProviderOverride() {
     return static_cast<MockLocationProvider*>(
         arbitrator_->GetLocationProvider());
   }
 
   scoped_refptr<FakeAccessTokenStore> access_token_store_;
   std::unique_ptr<MockLocationObserver> observer_;
   std::unique_ptr<TestingLocationArbitrator> arbitrator_;
-  std::unique_ptr<GeolocationProvider::Delegate> delegate_;
+  std::unique_ptr<GeolocationDelegate> delegate_;
   base::MessageLoop loop_;
 };
 
 TEST_F(GeolocationLocationArbitratorTest, CreateDestroy) {
   EXPECT_TRUE(access_token_store_.get());
   InitializeArbitrator(true /* use_fake_delegate */);
   EXPECT_TRUE(arbitrator_);
   arbitrator_.reset();
   SUCCEED();
 }
@@ skipping 42 matching lines @@
 
   EXPECT_FALSE(cell()->is_permission_granted_);
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
   arbitrator_->OnPermissionGranted();
   EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
   EXPECT_TRUE(cell()->is_permission_granted_);
 }
 
 TEST_F(GeolocationLocationArbitratorTest, CustomSystemProviderOnly) {
   InitializeArbitrator(true /* use_fake_delegate */);
-  arbitrator_->GetFakeDelegate()->set_use_network(false);
+  arbitrator_->GetFakeGeolocationDelegate()->set_use_network(false);
   ASSERT_TRUE(arbitrator_);
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
   arbitrator_->StartProviders(false);
 
   ASSERT_FALSE(cell());
   EXPECT_FALSE(gps());
   ASSERT_TRUE(GetSystemLocationProviderOverride());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY,
@@ skipping 12 matching lines @@
   EXPECT_FALSE(GetSystemLocationProviderOverride()->is_permission_granted_);
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
   arbitrator_->OnPermissionGranted();
   EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
   EXPECT_TRUE(GetSystemLocationProviderOverride()->is_permission_granted_);
 }
 
 TEST_F(GeolocationLocationArbitratorTest,
        CustomSystemAndDefaultNetworkProviders) {
   InitializeArbitrator(true /* use_fake_delegate */);
-  arbitrator_->GetFakeDelegate()->set_use_network(true);
+  arbitrator_->GetFakeGeolocationDelegate()->set_use_network(true);
   ASSERT_TRUE(arbitrator_);
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
   arbitrator_->StartProviders(false);
 
   EXPECT_TRUE(access_token_store_->access_token_map_.empty());
 
   access_token_store_->NotifyDelegateTokensLoaded();
 
@@ skipping 141 matching lines @@
 
   // 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 content