Geolocation cleanup: run clang-format

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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 using testing::MatchResultListener;
 
 namespace device {
 
 class LocationProviderForTestArbitrator : public GeolocationProviderImpl {
  public:
   LocationProviderForTestArbitrator() : mock_arbitrator_(NULL) {}
   ~LocationProviderForTestArbitrator() override {}
 
   // Only valid for use on the geolocation thread.
-  MockLocationArbitrator* mock_arbitrator() const {
-    return mock_arbitrator_;
-  }
+  MockLocationArbitrator* mock_arbitrator() const { return mock_arbitrator_; }
 
  protected:
   // GeolocationProviderImpl implementation:
   std::unique_ptr<LocationArbitrator> CreateArbitrator() override;
 
  private:
   // An alias to the arbitrator stored in the super class, where it is owned.
   MockLocationArbitrator* mock_arbitrator_;
 };
 
@@ skipping 21 matching lines @@
     MockGeolocationObserver::OnLocationUpdate(position);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 };
 
 class MockGeolocationCallbackWrapper {
  public:
   MOCK_METHOD1(Callback, void(const Geoposition& position));
 };
 
-class GeopositionEqMatcher
-    : public MatcherInterface<const Geoposition&> {
+class GeopositionEqMatcher : public MatcherInterface<const Geoposition&> {
  public:
   explicit GeopositionEqMatcher(const Geoposition& expected)
       : expected_(expected) {}
 
   bool MatchAndExplain(const Geoposition& actual,
                        MatchResultListener* listener) const override {
     return actual.latitude == expected_.latitude &&
            actual.longitude == expected_.longitude &&
            actual.altitude == expected_.altitude &&
            actual.accuracy == expected_.accuracy &&
@@ skipping 19 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GeopositionEqMatcher);
 };
 
 Matcher<const Geoposition&> GeopositionEq(const Geoposition& expected) {
   return MakeMatcher(new GeopositionEqMatcher(expected));
 }
 
 class GeolocationProviderTest : public testing::Test {
  protected:
   GeolocationProviderTest()
-      : message_loop_(),
-        provider_(new LocationProviderForTestArbitrator) {
-  }
+      : message_loop_(), provider_(new LocationProviderForTestArbitrator) {}
 
   ~GeolocationProviderTest() override {}
 
   LocationProviderForTestArbitrator* provider() { return provider_.get(); }
 
   // Called on test thread.
   bool ProvidersStarted();
   void SendMockLocation(const Geoposition& position);
 
  private:
   // Called on provider thread.
   void GetProvidersStarted(bool* started);
 
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<LocationProviderForTestArbitrator> provider_;
 };
 
-
 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::MessageLoop::QuitWhenIdleClosure());
   base::RunLoop().Run();
   return started;
@@ skipping 12 matching lines @@
                             base::Unretained(provider_.get()), position));
 }
 
 // Regression test for http://crbug.com/59377
 TEST_F(GeolocationProviderTest, OnPermissionGrantedWithoutObservers) {
   EXPECT_FALSE(provider()->user_did_opt_into_location_services_for_testing());
   provider()->UserDidOptIntoLocationServices();
   EXPECT_TRUE(provider()->user_did_opt_into_location_services_for_testing());
 }
 
-void DummyFunction(const Geoposition& position) {
-}
+void DummyFunction(const Geoposition& position) {}
 
 TEST_F(GeolocationProviderTest, StartStop) {
   EXPECT_FALSE(provider()->IsRunning());
   GeolocationProviderImpl::LocationUpdateCallback callback =
       base::Bind(&DummyFunction);
   std::unique_ptr<GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(callback, false);
   EXPECT_TRUE(provider()->IsRunning());
   EXPECT_TRUE(ProvidersStarted());
 
   subscription.reset();
 
   EXPECT_FALSE(ProvidersStarted());
   EXPECT_TRUE(provider()->IsRunning());
 }
 
 TEST_F(GeolocationProviderTest, StalePositionNotSent) {
   Geoposition first_position;
   first_position.latitude = 12;
   first_position.longitude = 34;
   first_position.accuracy = 56;
   first_position.timestamp = base::Time::Now();
 
   AsyncMockGeolocationObserver first_observer;
-  GeolocationProviderImpl::LocationUpdateCallback first_callback = base::Bind(
-      &MockGeolocationObserver::OnLocationUpdate,
-      base::Unretained(&first_observer));
+  GeolocationProviderImpl::LocationUpdateCallback first_callback =
+      base::Bind(&MockGeolocationObserver::OnLocationUpdate,
+                 base::Unretained(&first_observer));
   EXPECT_CALL(first_observer, OnLocationUpdate(GeopositionEq(first_position)));
   std::unique_ptr<GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(first_callback, false);
   SendMockLocation(first_position);
   base::RunLoop().Run();
 
   subscription.reset();
 
   Geoposition second_position;
   second_position.latitude = 13;
   second_position.longitude = 34;
   second_position.accuracy = 56;
   second_position.timestamp = base::Time::Now();
 
   AsyncMockGeolocationObserver second_observer;
 
   // After adding a second observer, check that no unexpected position update
   // is sent.
   EXPECT_CALL(second_observer, OnLocationUpdate(testing::_)).Times(0);
-  GeolocationProviderImpl::LocationUpdateCallback second_callback = base::Bind(
-      &MockGeolocationObserver::OnLocationUpdate,
-      base::Unretained(&second_observer));
+  GeolocationProviderImpl::LocationUpdateCallback second_callback =
+      base::Bind(&MockGeolocationObserver::OnLocationUpdate,
+                 base::Unretained(&second_observer));
   std::unique_ptr<GeolocationProvider::Subscription> subscription2 =
       provider()->AddLocationUpdateCallback(second_callback, false);
   base::RunLoop().RunUntilIdle();
 
   // The second observer should receive the new position now.
   EXPECT_CALL(second_observer,
               OnLocationUpdate(GeopositionEq(second_position)));
   SendMockLocation(second_position);
   base::RunLoop().Run();
 
   subscription2.reset();
   EXPECT_FALSE(ProvidersStarted());
 }
 
 TEST_F(GeolocationProviderTest, OverrideLocationForTesting) {
   Geoposition position;
   position.error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
   provider()->OverrideLocationForTesting(position);
   // Adding an observer when the location is overridden should synchronously
   // update the observer with our overridden position.
   MockGeolocationObserver mock_observer;
   EXPECT_CALL(mock_observer, OnLocationUpdate(GeopositionEq(position)));
-  GeolocationProviderImpl::LocationUpdateCallback callback = base::Bind(
-      &MockGeolocationObserver::OnLocationUpdate,
-      base::Unretained(&mock_observer));
+  GeolocationProviderImpl::LocationUpdateCallback callback =
+      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