Adds GeolocationFeature for Blimp Geolocation project.

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/fake_location_provider.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.
@@ skipping 14 matching lines @@
 double g_fake_time_now_secs = 1;
 
 base::Time GetTimeNowForTest() {
   return base::Time::FromDoubleT(g_fake_time_now_secs);
 }
 
 void AdvanceTimeNow(const base::TimeDelta& delta) {
   g_fake_time_now_secs += delta.InSecondsF();
 }
 
-void SetPositionFix(MockLocationProvider* provider,
+void SetPositionFix(FakeLocationProvider* provider,
                     double latitude,
                     double longitude,
                     double accuracy) {
   Geoposition position;
   position.error_code = Geoposition::ERROR_CODE_NONE;
   position.latitude = latitude;
   position.longitude = longitude;
   position.accuracy = accuracy;
   position.timestamp = GetTimeNowForTest();
   ASSERT_TRUE(position.Validate());
   provider->HandlePositionChanged(position);
 }
 
-void SetReferencePosition(MockLocationProvider* provider) {
+// TODO(lethalantidote): Populate a Geoposition in the class from kConstants
+// and then just copy that with "=" versus using a helper function.
+void SetReferencePosition(FakeLocationProvider* provider) {
   SetPositionFix(provider, 51.0, -0.1, 400);
 }
 
 namespace {
 
 class FakeGeolocationDelegate : public GeolocationDelegate {
  public:
   FakeGeolocationDelegate() = default;
 
   bool UseNetworkLocationProviders() override { return use_network_; }
   void set_use_network(bool use_network) { use_network_ = use_network; }
 
   std::unique_ptr<LocationProvider> OverrideSystemLocationProvider() override {
     DCHECK(!mock_location_provider_);
-    mock_location_provider_ = new MockLocationProvider;
+    mock_location_provider_ = new FakeLocationProvider;
     return base::WrapUnique(mock_location_provider_);
   }
 
-  MockLocationProvider* mock_location_provider() const {
+  FakeLocationProvider* mock_location_provider() const {
     return mock_location_provider_;
   }
 
  private:
   bool use_network_ = true;
-  MockLocationProvider* mock_location_provider_ = nullptr;
+  FakeLocationProvider* mock_location_provider_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 }  // namespace
 
 class TestingLocationArbitrator : public LocationArbitratorImpl {
  public:
   TestingLocationArbitrator(
       const LocationProviderUpdateCallback& callback,
@@ skipping 10 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;
+    cell_ = new FakeLocationProvider;
     return base::WrapUnique(cell_);
   }
 
   std::unique_ptr<LocationProvider> NewSystemLocationProvider() override {
-    gps_ = new MockLocationProvider;
+    gps_ = new FakeLocationProvider;
     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
   // 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 |gps_location_provider_|
-  MockLocationProvider* cell_;
-  MockLocationProvider* gps_;
+  FakeLocationProvider* cell_;
+  FakeLocationProvider* gps_;
   const scoped_refptr<AccessTokenStore> access_token_store_;
 };
 
 class GeolocationLocationArbitratorTest : public testing::Test {
  protected:
   GeolocationLocationArbitratorTest()
       : access_token_store_(new NiceMock<FakeAccessTokenStore>),
         observer_(new MockLocationObserver),
         delegate_(new GeolocationDelegate) {}
 
@@ skipping 21 matching lines @@
     EXPECT_DOUBLE_EQ(longitude, geoposition.longitude);
     EXPECT_DOUBLE_EQ(accuracy, geoposition.accuracy);
   }
 
   base::TimeDelta SwitchOnFreshnessCliff() {
     // Add 1, to ensure it meets any greater-than test.
     return base::TimeDelta::FromMilliseconds(
         LocationArbitratorImpl::kFixStaleTimeoutMilliseconds + 1);
   }
 
-  MockLocationProvider* cell() { return arbitrator_->cell_; }
+  FakeLocationProvider* cell() { return arbitrator_->cell_; }
 
-  MockLocationProvider* gps() { return arbitrator_->gps_; }
+  FakeLocationProvider* gps() { return arbitrator_->gps_; }
 
   const scoped_refptr<FakeAccessTokenStore> access_token_store_;
   const std::unique_ptr<MockLocationObserver> observer_;
   std::unique_ptr<TestingLocationArbitrator> arbitrator_;
   std::unique_ptr<GeolocationDelegate> delegate_;
   const base::MessageLoop loop_;
 };
 
 TEST_F(GeolocationLocationArbitratorTest, CreateDestroy) {
   EXPECT_TRUE(access_token_store_.get());
@@ skipping 21 matching lines @@
 
   EXPECT_FALSE(cell());
   EXPECT_FALSE(gps());
   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_EQ(FakeLocationProvider::LOW_ACCURACY, cell()->state_);
+  EXPECT_EQ(FakeLocationProvider::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()->GetPosition().latitude, observer_->last_position_.latitude);
 
   EXPECT_FALSE(cell()->is_permission_granted());
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
   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_->StartProvider(false);
 
   ASSERT_FALSE(cell());
   EXPECT_FALSE(gps());
   ASSERT_TRUE(fake_delegate->mock_location_provider());
-  EXPECT_EQ(MockLocationProvider::LOW_ACCURACY,
+  EXPECT_EQ(FakeLocationProvider::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()->GetPosition().latitude,
             observer_->last_position_.latitude);
 
   EXPECT_FALSE(
       fake_delegate->mock_location_provider()->is_permission_granted());
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
   EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
   EXPECT_TRUE(fake_delegate->mock_location_provider()->is_permission_granted());
 }
 
@@ skipping 10 matching lines @@
   EXPECT_FALSE(gps());
   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,
+  EXPECT_EQ(FakeLocationProvider::LOW_ACCURACY,
             fake_delegate->mock_location_provider()->state_);
-  EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
+  EXPECT_EQ(FakeLocationProvider::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()->GetPosition().latitude, observer_->last_position_.latitude);
 
   EXPECT_FALSE(cell()->is_permission_granted());
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGrantedForTest());
   arbitrator_->OnPermissionGranted();
   EXPECT_TRUE(arbitrator_->HasPermissionBeenGrantedForTest());
   EXPECT_TRUE(cell()->is_permission_granted());
 }
 
 TEST_F(GeolocationLocationArbitratorTest, SetObserverOptions) {
   InitializeArbitrator(nullptr);
   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_);
+  EXPECT_EQ(FakeLocationProvider::LOW_ACCURACY, cell()->state_);
+  EXPECT_EQ(FakeLocationProvider::LOW_ACCURACY, gps()->state_);
   SetReferencePosition(cell());
-  EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
-  EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, gps()->state_);
+  EXPECT_EQ(FakeLocationProvider::LOW_ACCURACY, cell()->state_);
+  EXPECT_EQ(FakeLocationProvider::LOW_ACCURACY, gps()->state_);
   arbitrator_->StartProvider(true);
-  EXPECT_EQ(MockLocationProvider::HIGH_ACCURACY, cell()->state_);
-  EXPECT_EQ(MockLocationProvider::HIGH_ACCURACY, gps()->state_);
+  EXPECT_EQ(FakeLocationProvider::HIGH_ACCURACY, cell()->state_);
+  EXPECT_EQ(FakeLocationProvider::HIGH_ACCURACY, gps()->state_);
 }
 
 TEST_F(GeolocationLocationArbitratorTest, Arbitration) {
   InitializeArbitrator(nullptr);
   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()->GetPosition());
 
   // 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 47 matching lines @@
 
   // Set the initial position.
   SetPositionFix(cell(), 3, 139, 100);
   CheckLastPositionInfo(3, 139, 100);
 
   // Restart providers to simulate a one-shot request.
   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);
+  std::unique_ptr<FakeLocationProvider> dummy_provider(
+      new FakeLocationProvider);
 
   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