Geolocation cleanup: make GeolocationDelegate::OverrideSystemLocationProvider return unique_ptr

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 56 matching lines @@
 
 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; }
 
-  LocationProvider* OverrideSystemLocationProvider() override {
-    if (!system_location_provider_)
-      system_location_provider_ = base::WrapUnique(new MockLocationProvider);
-    return system_location_provider_.get();
+  std::unique_ptr<LocationProvider> OverrideSystemLocationProvider() override {
+    std::unique_ptr<LocationProvider> provider(new MockLocationProvider);
+    system_location_provider_ = provider.get();
+    return provider;
   }
 
   LocationProvider* system_location_provider() const {
-    return system_location_provider_.get();
+    return system_location_provider_;
   }
 
  private:
   bool use_network_ = true;
-  std::unique_ptr<LocationProvider> system_location_provider_;
+  LocationProvider* system_location_provider_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGeolocationDelegate);
 };
 
 class TestingLocationArbitrator : public LocationArbitratorImpl {
  public:
   TestingLocationArbitrator(
       const LocationArbitratorImpl::LocationUpdateCallback& callback,
       AccessTokenStore* access_token_store,
       GeolocationDelegate* delegate,
@@ skipping 18 matching lines @@
     cell_ = new MockLocationProvider;
     return base::WrapUnique(cell_);
   }
 
   std::unique_ptr<LocationProvider> NewSystemLocationProvider() override {
     gps_ = new MockLocationProvider;
     return base::WrapUnique(gps_);
   }
 
   FakeGeolocationDelegate* GetFakeGeolocationDelegate() {
     DCHECK(is_fake_delegate_);

[Wez, 2016/07/08 23:12:57]

You don't want to remove this, otherwise someone will end up calling it when the
delegate isn't fake, surely?

See below, though, re InitializeArbitrator().

     return static_cast<FakeGeolocationDelegate*>(GetDelegateForTesting());
   }
 
   LocationProvider* GetLocationProvider() {
     if (is_fake_delegate_)
       return GetFakeGeolocationDelegate()->system_location_provider();
-    return GetDelegateForTesting()->OverrideSystemLocationProvider();
+    system_location_provider_ =
+        GetDelegateForTesting()->OverrideSystemLocationProvider();
+    return system_location_provider_.get();
   }
 
   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_|
+  // |gps_| to |gps_location_provider_|
   MockLocationProvider* cell_;
   MockLocationProvider* gps_;
+  std::unique_ptr<LocationProvider> system_location_provider_;
   scoped_refptr<AccessTokenStore> access_token_store_;
 };
 
 }  // namespace
 
 class GeolocationLocationArbitratorTest : public testing::Test {
  protected:
   // testing::Test
   void SetUp() override {
     access_token_store_ = new NiceMock<FakeAccessTokenStore>;
@@ skipping 300 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