Geolocation cleanup: corrects uses of content::AccessTokenStore* and net::URLRequestContextGetter*

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"
@@ skipping 79 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 }  // namespace
 
 class TestingLocationArbitrator : public LocationArbitratorImpl {
  public:
   TestingLocationArbitrator(
       const LocationArbitratorImpl::LocationUpdateCallback& callback,
-      AccessTokenStore* access_token_store,
+      const scoped_refptr<AccessTokenStore>& access_token_store,
       GeolocationDelegate* delegate)
       : LocationArbitratorImpl(callback, 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();
+  scoped_refptr<AccessTokenStore> NewAccessTokenStore() override {
+    return access_token_store_;
   }
 
   std::unique_ptr<LocationProvider> NewNetworkLocationProvider(
-      AccessTokenStore* access_token_store,
-      net::URLRequestContextGetter* context,
+      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;
     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
   // 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_;
-  std::unique_ptr<LocationProvider> system_location_provider_;
-  scoped_refptr<AccessTokenStore> access_token_store_;
+  const scoped_refptr<AccessTokenStore> access_token_store_;
 };
 
 class GeolocationLocationArbitratorTest : public testing::Test {
  protected:
-  // testing::Test
-  void SetUp() override {
-    access_token_store_ = new NiceMock<FakeAccessTokenStore>;
-    observer_.reset(new MockLocationObserver);
-    delegate_.reset(new GeolocationDelegate);
-  }
+  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 =
         base::Bind(&MockLocationObserver::OnLocationUpdate,
                    base::Unretained(observer_.get()));
     arbitrator_.reset(new TestingLocationArbitrator(
-        callback, access_token_store_.get(), delegate_.get()));
+        callback, access_token_store_, delegate_.get()));
   }
 
   // testing::Test
   void TearDown() override {}
 
   void CheckLastPositionInfo(double latitude,
                              double longitude,
                              double accuracy) {
     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);
   }
 
   MockLocationProvider* cell() {
     return arbitrator_->cell_;
   }
 
   MockLocationProvider* gps() {
     return arbitrator_->gps_;
   }
 
-  scoped_refptr<FakeAccessTokenStore> access_token_store_;
-  std::unique_ptr<MockLocationObserver> observer_;
+  const scoped_refptr<FakeAccessTokenStore> access_token_store_;
+  const std::unique_ptr<MockLocationObserver> observer_;
   std::unique_ptr<TestingLocationArbitrator> arbitrator_;
   std::unique_ptr<GeolocationDelegate> delegate_;
-  base::MessageLoop loop_;
+  const base::MessageLoop loop_;
 };
 
 TEST_F(GeolocationLocationArbitratorTest, CreateDestroy) {
   EXPECT_TRUE(access_token_store_.get());
   InitializeArbitrator(nullptr);
   EXPECT_TRUE(arbitrator_);
   arbitrator_.reset();
   SUCCEED();
 }
 
@@ skipping 235 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