Adds GeolocationFeature for Blimp Geolocation project.

device/geolocation/geolocation_provider_impl_unittest.cc

 // Copyright 2014 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/geolocation_provider_impl.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "device/geolocation/access_token_store.h"
-#include "device/geolocation/mock_location_provider.h"
+#include "device/geolocation/fake_location_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::MakeMatcher;
 using testing::Matcher;
 using testing::MatcherInterface;
 using testing::MatchResultListener;
 
 namespace device {
 namespace {
@@ skipping 59 matching lines @@
   return MakeMatcher(new GeopositionEqMatcher(expected));
 }
 
 void DummyFunction(const LocationProvider* provider,
                    const Geoposition& position) {}
 
 }  // namespace
 
 class GeolocationProviderTest : public testing::Test {
  protected:
-  GeolocationProviderTest() : arbitrator_(new MockLocationProvider) {
+  GeolocationProviderTest() : arbitrator_(new FakeLocationProvider) {
     provider()->SetArbitratorForTesting(base::WrapUnique(arbitrator_));
   }
 
   ~GeolocationProviderTest() override {}
 
   GeolocationProviderImpl* provider() {
     return GeolocationProviderImpl::GetInstance();
   }
 
-  MockLocationProvider* arbitrator() { return arbitrator_; }
+  FakeLocationProvider* arbitrator() { return arbitrator_; }
 
   // Called on test thread.
   bool ProvidersStarted();
   void SendMockLocation(const Geoposition& position);
 
  private:
   // Called on provider thread.
-  void GetProvidersStarted(bool* started);
+  void GetProvidersStarted();
 
   // |at_exit| must be initialized before all other variables so that it is
   // available to register with Singletons and can handle tear down when the
   // test completes.
   base::ShadowingAtExitManager at_exit_;
 
   base::MessageLoopForUI message_loop_;
 
   // Owned by the GeolocationProviderImpl class.
-  MockLocationProvider* arbitrator_;
+  FakeLocationProvider* arbitrator_;
+
+  // True if |arbitrator_| is started.
+  bool started_;

[Wez, 2016/08/24 04:25:50]

nit: Prefer is_started_ in cases like this.

[CJ, 2016/08/24 20:37:10]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(GeolocationProviderTest);
 };
 
 bool GeolocationProviderTest::ProvidersStarted() {
   DCHECK(provider()->IsRunning());
   DCHECK(base::MessageLoop::current() == &message_loop_);
 
-  bool started;
   provider()->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&GeolocationProviderTest::GetProvidersStarted,
-                            base::Unretained(this), &started),
+                            base::Unretained(this)),
       base::MessageLoop::QuitWhenIdleClosure());
   base::RunLoop().Run();
-  return started;
+  return started_;
 }
 
-void GeolocationProviderTest::GetProvidersStarted(bool* started) {
+void GeolocationProviderTest::GetProvidersStarted() {
   DCHECK(provider()->task_runner()->BelongsToCurrentThread());
-  *started = arbitrator()->is_started();
+  started_ = arbitrator()->state() != FakeLocationProvider::STOPPED;
 }
 
 void GeolocationProviderTest::SendMockLocation(const Geoposition& position) {
   DCHECK(provider()->IsRunning());
   DCHECK(base::MessageLoop::current() == &message_loop_);
   provider()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&GeolocationProviderImpl::OnLocationUpdate,
                  base::Unretained(provider()), arbitrator_, position));
 }
 
 // Regression test for http://crbug.com/59377
 TEST_F(GeolocationProviderTest, OnPermissionGrantedWithoutObservers) {
   // Clear |provider|'s arbitrator so the default arbitrator can be used.
   provider()->SetArbitratorForTesting(nullptr);
   EXPECT_FALSE(provider()->user_did_opt_into_location_services_for_testing());
   provider()->UserDidOptIntoLocationServices();
   EXPECT_TRUE(provider()->user_did_opt_into_location_services_for_testing());
 }
 
 TEST_F(GeolocationProviderTest, StartStop) {
   EXPECT_FALSE(provider()->IsRunning());
   LocationProvider::LocationProviderUpdateCallback callback =
       base::Bind(&DummyFunction);

[Wez, 2016/08/24 04:25:50]

No need for this line; just pass &DummyFunction directly in place of |callback|
below.

[CJ, 2016/08/24 20:37:10]

Done.

   std::unique_ptr<GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(base::Bind(callback, arbitrator()),
                                             false);
   EXPECT_TRUE(provider()->IsRunning());
   EXPECT_TRUE(ProvidersStarted());
 
   subscription.reset();
 
   EXPECT_FALSE(ProvidersStarted());
   EXPECT_TRUE(provider()->IsRunning());
@@ skipping 58 matching lines @@
       base::Bind(&MockGeolocationObserver::OnLocationUpdate,
                  base::Unretained(&mock_observer));
   std::unique_ptr<GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(callback, false);
   subscription.reset();
   // Wait for the providers to be stopped now that all clients are gone.
   EXPECT_FALSE(ProvidersStarted());
 }
 
 }  // namespace device