Geolocation cleanup: run clang-format

device/geolocation/wifi_data_provider_common_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/wifi_data_provider_common.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 31 matching lines @@
   bool GetAccessPointDataInternal(WifiData::AccessPointDataSet* data) {
     ++calls_;
     *data = data_out_;
     return bool_return_;
   }
 };
 
 class MockPollingPolicy : public WifiPollingPolicy {
  public:
   MockPollingPolicy() {
-    ON_CALL(*this,PollingInterval())
-        .WillByDefault(Return(1));
-    ON_CALL(*this,NoWifiInterval())
-        .WillByDefault(Return(1));
+    ON_CALL(*this, PollingInterval()).WillByDefault(Return(1));
+    ON_CALL(*this, NoWifiInterval()).WillByDefault(Return(1));
   }
 
   MOCK_METHOD0(PollingInterval, int());
   MOCK_METHOD0(NoWifiInterval, int());
 
   virtual void UpdatePollingInterval(bool) {}
 };
 
 class WifiDataProviderCommonWithMock : public WifiDataProviderCommon {
  public:
@@ skipping 68 matching lines @@
 };
 
 TEST_F(GeolocationWifiDataProviderCommonTest, CreateDestroy) {
   // Test fixture members were SetUp correctly.
   EXPECT_TRUE(main_task_runner_->BelongsToCurrentThread());
   EXPECT_TRUE(NULL != provider_.get());
   EXPECT_TRUE(NULL != wlan_api_);
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, RunNormal) {
-  EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
-      .Times(AtLeast(1));
-  EXPECT_CALL(*polling_policy_, PollingInterval())
-      .Times(AtLeast(1));
+  EXPECT_CALL(*wlan_api_, GetAccessPointData(_)).Times(AtLeast(1));
+  EXPECT_CALL(*polling_policy_, PollingInterval()).Times(AtLeast(1));
   provider_->StartDataProvider();
   RunLoop();
   SUCCEED();
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, NoWifi) {
-  EXPECT_CALL(*polling_policy_, NoWifiInterval())
-      .Times(AtLeast(1));
-  EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
-      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*polling_policy_, NoWifiInterval()).Times(AtLeast(1));
+  EXPECT_CALL(*wlan_api_, GetAccessPointData(_)).WillRepeatedly(Return(false));
   provider_->StartDataProvider();
   RunLoop();
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, IntermittentWifi) {
-  EXPECT_CALL(*polling_policy_, PollingInterval())
-      .Times(AtLeast(1));
-  EXPECT_CALL(*polling_policy_, NoWifiInterval())
-      .Times(1);
+  EXPECT_CALL(*polling_policy_, PollingInterval()).Times(AtLeast(1));
+  EXPECT_CALL(*polling_policy_, NoWifiInterval()).Times(1);
   EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
       .WillOnce(Return(true))
       .WillOnce(Return(false))
       .WillRepeatedly(DoDefault());
 
   AccessPointData single_access_point;
   single_access_point.channel = 2;
   single_access_point.mac_address = 3;
   single_access_point.radio_signal_strength = 4;
   single_access_point.signal_to_noise = 5;
   single_access_point.ssid = base::ASCIIToUTF16("foossid");
   wlan_api_->data_out_.insert(single_access_point);
 
   provider_->StartDataProvider();
   RunLoop();
   RunLoop();
 }
 
 #if defined(OS_MACOSX)
 #define MAYBE_DoAnEmptyScan DISABLED_DoAnEmptyScan
 #else
 #define MAYBE_DoAnEmptyScan DoAnEmptyScan
 #endif
 TEST_F(GeolocationWifiDataProviderCommonTest, MAYBE_DoAnEmptyScan) {
-  EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
-      .Times(AtLeast(1));
-  EXPECT_CALL(*polling_policy_, PollingInterval())
-      .Times(AtLeast(1));
+  EXPECT_CALL(*wlan_api_, GetAccessPointData(_)).Times(AtLeast(1));
+  EXPECT_CALL(*polling_policy_, PollingInterval()).Times(AtLeast(1));
   provider_->StartDataProvider();
   RunLoop();
   EXPECT_EQ(wlan_api_->calls_, 1);
   WifiData data;
   EXPECT_TRUE(provider_->GetData(&data));
   EXPECT_EQ(0, static_cast<int>(data.access_point_data.size()));
 }
 
 #if defined(OS_MACOSX)
 #define MAYBE_DoScanWithResults DISABLED_DoScanWithResults
 #else
 #define MAYBE_DoScanWithResults DoScanWithResults
 #endif
 TEST_F(GeolocationWifiDataProviderCommonTest, MAYBE_DoScanWithResults) {
-  EXPECT_CALL(*wlan_api_, GetAccessPointData(_))
-      .Times(AtLeast(1));
-  EXPECT_CALL(*polling_policy_, PollingInterval())
-      .Times(AtLeast(1));
+  EXPECT_CALL(*wlan_api_, GetAccessPointData(_)).Times(AtLeast(1));
+  EXPECT_CALL(*polling_policy_, PollingInterval()).Times(AtLeast(1));
   AccessPointData single_access_point;
   single_access_point.channel = 2;
   single_access_point.mac_address = 3;
   single_access_point.radio_signal_strength = 4;
   single_access_point.signal_to_noise = 5;
   single_access_point.ssid = base::ASCIIToUTF16("foossid");
   wlan_api_->data_out_.insert(single_access_point);
 
   provider_->StartDataProvider();
   RunLoop();
   EXPECT_EQ(wlan_api_->calls_, 1);
   WifiData data;
   EXPECT_TRUE(provider_->GetData(&data));
   EXPECT_EQ(1, static_cast<int>(data.access_point_data.size()));
   EXPECT_EQ(single_access_point.ssid, data.access_point_data.begin()->ssid);
 }
 
 TEST_F(GeolocationWifiDataProviderCommonTest, RegisterUnregister) {
   WifiDataProviderManager::SetFactoryForTesting(
       CreateWifiDataProviderCommonWithMock);
   WifiDataProviderManager::Register(&wifi_data_callback_);
   RunLoop();
   WifiDataProviderManager::Unregister(&wifi_data_callback_);
   WifiDataProviderManager::ResetFactoryForTesting();
 }
 
 }  // namespace device