Hooks together Geolocation Feature in the Client and Engine.

device/geolocation/location_arbitrator_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 "device/geolocation/location_arbitrator.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 "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 LocationProvider*, const Geoposition& position) {
+  void OnLocationUpdate(const LocationProvider* provider,
+                        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 44 matching lines @@
 
  private:
   bool use_network_ = true;
   FakeLocationProvider* mock_location_provider_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 }  // namespace
 
-class TestingLocationArbitrator : public LocationArbitratorImpl {
+class TestingLocationArbitrator : public LocationArbitrator {
  public:
   TestingLocationArbitrator(
       const LocationProviderUpdateCallback& callback,
       const scoped_refptr<AccessTokenStore>& access_token_store,
       GeolocationDelegate* delegate)
-      : LocationArbitratorImpl(delegate),
+      : LocationArbitrator(delegate),
         cell_(nullptr),
         gps_(nullptr),
         access_token_store_(access_token_store) {
     SetUpdateCallback(callback);
   }
 
   base::Time GetTimeNow() const override { return GetTimeNowForTest(); }
 
   scoped_refptr<AccessTokenStore> NewAccessTokenStore() override {
     return access_token_store_;
@@ skipping 52 matching lines @@
     Geoposition geoposition = observer_->last_position_;
     EXPECT_TRUE(geoposition.Validate());
     EXPECT_DOUBLE_EQ(latitude, geoposition.latitude);
     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);
+        LocationArbitrator::kFixStaleTimeoutMilliseconds + 1);
   }
 
   FakeLocationProvider* cell() { return arbitrator_->cell_; }
 
   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_;
@@ skipping 245 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 device