Geolocation cleanup: run clang-format

device/geolocation/network_location_provider_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/network_location_provider.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 127 matching lines @@
     // TODO(joth): Really these should be in SetUp, not here, but they take no
     // effect on Mac OS Release builds if done there. I kid not. Figure out why.
     WifiDataProviderManager::SetFactoryForTesting(
         MockWifiDataProvider::GetInstance);
   }
 
   // Returns the current url fetcher (if any) and advances the id ready for the
   // next test step.
   net::TestURLFetcher* get_url_fetcher_and_advance_id() {
     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(
-            NetworkLocationRequest::url_fetcher_id_for_tests);
+        NetworkLocationRequest::url_fetcher_id_for_tests);
     if (fetcher)
       ++NetworkLocationRequest::url_fetcher_id_for_tests;
     return fetcher;
   }
 
   static int IndexToChannel(int index) { return index + 4; }
 
   // Creates wifi data containing the specified number of access points, with
   // some differentiating charactistics in each.
   static WifiData CreateReferenceWifiScanData(int ap_count) {
     WifiData data;
     for (int i = 0; i < ap_count; ++i) {
       AccessPointData ap;
       ap.mac_address =
           base::ASCIIToUTF16(base::StringPrintf("%02d-34-56-78-54-32", i));
       ap.radio_signal_strength = ap_count - i;
       ap.channel = IndexToChannel(i);
       ap.signal_to_noise = i + 42;
       ap.ssid = base::ASCIIToUTF16("Some nice+network|name\\");
       data.access_point_data.insert(ap);
     }
     return data;
   }
 
   static void CreateReferenceWifiScanDataJson(
-      int ap_count, int start_index, base::ListValue* wifi_access_point_list) {
+      int ap_count,
+      int start_index,
+      base::ListValue* wifi_access_point_list) {
     std::vector<std::string> wifi_data;
     for (int i = 0; i < ap_count; ++i) {
       std::unique_ptr<base::DictionaryValue> ap(new base::DictionaryValue());
       ap->SetString("macAddress", base::StringPrintf("%02d-34-56-78-54-32", i));
       ap->SetInteger("signalStrength", start_index + ap_count - i);
       ap->SetInteger("age", 0);
       ap->SetInteger("channel", IndexToChannel(i));
       ap->SetInteger("signalToNoiseRatio", i + 42);
       wifi_access_point_list->Append(std::move(ap));
     }
@@ skipping 25 matching lines @@
     return testing::AssertionSuccess();
   }
 
   static testing::AssertionResult JsonFieldEquals(
       const std::string& field,
       const base::DictionaryValue& expected,
       const base::DictionaryValue& actual) {
     const base::Value* expected_value;
     const base::Value* actual_value;
     if (!expected.Get(field, &expected_value))
-      return testing::AssertionFailure()
-          << "Expected dictionary " << PrettyJson(expected)
-          << " is missing field " << field;
+      return testing::AssertionFailure() << "Expected dictionary "
+                                         << PrettyJson(expected)
+                                         << " is missing field " << field;
     if (!expected.Get(field, &actual_value))
-      return testing::AssertionFailure()
-          << "Actual dictionary " << PrettyJson(actual)
-          << " is missing field " << field;
+      return testing::AssertionFailure() << "Actual dictionary "
+                                         << PrettyJson(actual)
+                                         << " is missing field " << field;
     if (!expected_value->Equals(actual_value))
       return testing::AssertionFailure()
-          << "Field " << field << " mismatch: " << PrettyJson(*expected_value)
-          << " != " << PrettyJson(*actual_value);
+             << "Field " << field
+             << " mismatch: " << PrettyJson(*expected_value)
+             << " != " << PrettyJson(*actual_value);
     return testing::AssertionSuccess();
   }
 
   static GURL UrlWithoutQuery(const GURL& url) {
     url::Replacements<char> replacements;
     replacements.ClearQuery();
     return url.ReplaceComponents(replacements);
   }
 
   testing::AssertionResult IsTestServerUrl(const GURL& request_url) {
     const GURL a(UrlWithoutQuery(test_server_url_));
     const GURL b(UrlWithoutQuery(request_url));
     if (a == b)
       return testing::AssertionSuccess();
     return testing::AssertionFailure() << a << " != " << b;
   }
 
   void CheckRequestIsValid(const net::TestURLFetcher& request,
                            int expected_routers,
                            int expected_wifi_aps,
                            int wifi_start_index,
                            const std::string& expected_access_token) {
     const GURL& request_url = request.GetOriginalURL();
 
     EXPECT_TRUE(IsTestServerUrl(request_url));
 
     // Check to see that the api key is being appended for the default
     // network provider url.
-    bool is_default_url = UrlWithoutQuery(request_url) ==
+    bool is_default_url =
+        UrlWithoutQuery(request_url) ==
         UrlWithoutQuery(LocationArbitratorImpl::DefaultNetworkProviderURL());
     EXPECT_EQ(is_default_url, !request_url.query().empty());
 
     const std::string& upload_data = request.upload_data();
     ASSERT_FALSE(upload_data.empty());
     std::string json_parse_error_msg;
     std::unique_ptr<base::Value> parsed_json =
         base::JSONReader::ReadAndReturnError(upload_data, base::JSON_PARSE_RFC,
                                              nullptr, &json_parse_error_msg);
     EXPECT_TRUE(json_parse_error_msg.empty());
     ASSERT_TRUE(parsed_json);
 
     const base::DictionaryValue* request_json;
     ASSERT_TRUE(parsed_json->GetAsDictionary(&request_json));
 
     if (!is_default_url) {
       if (expected_access_token.empty())
         ASSERT_FALSE(request_json->HasKey(kAccessTokenString));
       else {
         std::string access_token;
         EXPECT_TRUE(request_json->GetString(kAccessTokenString, &access_token));
         EXPECT_EQ(expected_access_token, access_token);
       }
     }
 
     if (expected_wifi_aps) {
       base::ListValue expected_wifi_aps_json;
-      CreateReferenceWifiScanDataJson(
-          expected_wifi_aps,
-          wifi_start_index,
-          &expected_wifi_aps_json);
+      CreateReferenceWifiScanDataJson(expected_wifi_aps, wifi_start_index,
+                                      &expected_wifi_aps_json);
       EXPECT_EQ(size_t(expected_wifi_aps), expected_wifi_aps_json.GetSize());
 
       const base::ListValue* wifi_aps_json;
-      ASSERT_TRUE(JsonGetList("wifiAccessPoints", *request_json,
-                              &wifi_aps_json));
-      for (size_t i = 0; i < expected_wifi_aps_json.GetSize(); ++i ) {
+      ASSERT_TRUE(
+          JsonGetList("wifiAccessPoints", *request_json, &wifi_aps_json));
+      for (size_t i = 0; i < expected_wifi_aps_json.GetSize(); ++i) {
         const base::DictionaryValue* expected_json;
         ASSERT_TRUE(expected_wifi_aps_json.GetDictionary(i, &expected_json));
         const base::DictionaryValue* actual_json;
         ASSERT_TRUE(wifi_aps_json->GetDictionary(i, &actual_json));
-        ASSERT_TRUE(JsonFieldEquals("macAddress", *expected_json,
-                                    *actual_json));
-        ASSERT_TRUE(JsonFieldEquals("signalStrength", *expected_json,
-                                    *actual_json));
+        ASSERT_TRUE(
+            JsonFieldEquals("macAddress", *expected_json, *actual_json));
+        ASSERT_TRUE(
+            JsonFieldEquals("signalStrength", *expected_json, *actual_json));
         ASSERT_TRUE(JsonFieldEquals("channel", *expected_json, *actual_json));
         ASSERT_TRUE(JsonFieldEquals("signalToNoiseRatio", *expected_json,
                                     *actual_json));
       }
     } else {
       ASSERT_FALSE(request_json->HasKey("wifiAccessPoints"));
     }
     EXPECT_TRUE(request_url.is_valid());
   }
 
@@ skipping 73 matching lines @@
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   base::RunLoop().RunUntilIdle();
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   // The request should have the wifi data.
   CheckRequestIsValid(*fetcher, 0, kFirstScanAps, 0, std::string());
 
   // Send a reply with good position fix.
   const char* kReferenceNetworkResponse =
       "{"
-      "  \"accessToken\": \"" REFERENCE_ACCESS_TOKEN "\","
+      "  \"accessToken\": \"" REFERENCE_ACCESS_TOKEN
+      "\","
       "  \"accuracy\": 1200.4,"
       "  \"location\": {"
       "    \"lat\": 51.0,"
       "    \"lng\": -0.1"
       "  }"
       "}";
   fetcher->set_url(test_server_url_);
   fetcher->set_status(net::URLRequestStatus());
   fetcher->set_response_code(200);  // OK
   fetcher->SetResponseString(kReferenceNetworkResponse);
@@ skipping 123 matching lines @@
   CheckRequestIsValid(*fetcher, 0, kScanCount, 0, REFERENCE_ACCESS_TOKEN);
 }
 
 TEST_F(GeolocationNetworkProviderTest, NetworkPositionCache) {
   NetworkLocationProvider::PositionCache cache;
 
   const int kCacheSize = NetworkLocationProvider::PositionCache::kMaximumSize;
   for (int i = 1; i < kCacheSize * 2 + 1; ++i) {
     Geoposition pos = CreateReferencePosition(i);
     bool ret = cache.CachePosition(CreateReferenceWifiScanData(i), pos);
-    EXPECT_TRUE(ret)  << i;
+    EXPECT_TRUE(ret) << i;
     const Geoposition* item =
         cache.FindPosition(CreateReferenceWifiScanData(i));
     ASSERT_TRUE(item) << i;
-    EXPECT_EQ(pos.latitude, item->latitude)  << i;
-    EXPECT_EQ(pos.longitude, item->longitude)  << i;
+    EXPECT_EQ(pos.latitude, item->latitude) << i;
+    EXPECT_EQ(pos.longitude, item->longitude) << i;
     if (i <= kCacheSize) {
       // Nothing should have spilled yet; check oldest item is still there.
       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(1)));
     } else {
       const int evicted = i - kCacheSize;
       EXPECT_FALSE(cache.FindPosition(CreateReferenceWifiScanData(evicted)));
       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(evicted + 1)));
     }
   }
 }
 
 }  // namespace device