Geolocation cleanup: run clang-format

device/geolocation/wifi_data_provider_linux.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.
 
 // Provides wifi scan API binding for suitable for typical linux distributions.
 // Currently, only the NetworkManager API is used, accessed via D-Bus (in turn
 // accessed via the GLib wrapper).
 
 #include "device/geolocation/wifi_data_provider_linux.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "device/geolocation/wifi_data_provider_manager.h"
 
 namespace device {
 namespace {
 // The time periods between successive polls of the wifi data.
-const int kDefaultPollingIntervalMilliseconds = 10 * 1000;  // 10s
-const int kNoChangePollingIntervalMilliseconds = 2 * 60 * 1000;  // 2 mins
+const int kDefaultPollingIntervalMilliseconds = 10 * 1000;           // 10s
+const int kNoChangePollingIntervalMilliseconds = 2 * 60 * 1000;      // 2 mins
 const int kTwoNoChangePollingIntervalMilliseconds = 10 * 60 * 1000;  // 10 mins
-const int kNoWifiPollingIntervalMilliseconds = 20 * 1000; // 20s
+const int kNoWifiPollingIntervalMilliseconds = 20 * 1000;            // 20s
 
 const char kNetworkManagerServiceName[] = "org.freedesktop.NetworkManager";
 const char kNetworkManagerPath[] = "/org/freedesktop/NetworkManager";
 const char kNetworkManagerInterface[] = "org.freedesktop.NetworkManager";
 
 // From http://projects.gnome.org/NetworkManager/developers/spec.html
 enum { NM_DEVICE_TYPE_WIFI = 2 };
 
 // Wifi API binding to NetworkManager, to allow reuse of the polling behavior
 // defined in WifiDataProviderCommon.
@@ skipping 49 matching lines @@
   if (frequency_khz >= 2412000 && frequency_khz <= 2472000)  // Channels 1-13.
     return (frequency_khz - 2407000) / 5000;
   if (frequency_khz == 2484000)
     return 14;
   if (frequency_khz > 5000000 && frequency_khz < 6000000)  // .11a bands.
     return (frequency_khz - 5000000) / 5000;
   // Ignore everything else.
   return AccessPointData().channel;  // invalid channel
 }
 
-NetworkManagerWlanApi::NetworkManagerWlanApi()
-    : network_manager_proxy_(NULL) {
-}
+NetworkManagerWlanApi::NetworkManagerWlanApi() : network_manager_proxy_(NULL) {}
 
 NetworkManagerWlanApi::~NetworkManagerWlanApi() {
   // Close the connection.
   system_bus_->ShutdownAndBlock();
 }
 
 bool NetworkManagerWlanApi::Init() {
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SYSTEM;
   options.connection_type = dbus::Bus::PRIVATE;
   return InitWithBus(new dbus::Bus(options));
 }
 
 bool NetworkManagerWlanApi::InitWithBus(dbus::Bus* bus) {
   system_bus_ = bus;
   // system_bus_ will own all object proxies created from the bus.
-  network_manager_proxy_ =
-      system_bus_->GetObjectProxy(kNetworkManagerServiceName,
-                                  dbus::ObjectPath(kNetworkManagerPath));
+  network_manager_proxy_ = system_bus_->GetObjectProxy(
+      kNetworkManagerServiceName, dbus::ObjectPath(kNetworkManagerPath));
   // Validate the proxy object by checking we can enumerate devices.
   std::vector<dbus::ObjectPath> adapter_paths;
   const bool success = GetAdapterDeviceList(&adapter_paths);
   VLOG(1) << "Init() result:  " << success;
   return success;
 }
 
 bool NetworkManagerWlanApi::GetAccessPointData(
     WifiData::AccessPointDataSet* data) {
   std::vector<dbus::ObjectPath> device_paths;
   if (!GetAdapterDeviceList(&device_paths)) {
     LOG(WARNING) << "Could not enumerate access points";
     return false;
   }
   int success_count = 0;
   int fail_count = 0;
 
   // Iterate the devices, getting APs for each wireless adapter found
   for (size_t i = 0; i < device_paths.size(); ++i) {
     const dbus::ObjectPath& device_path = device_paths[i];
     VLOG(1) << "Checking device: " << device_path.value();
 
     dbus::ObjectProxy* device_proxy =
-        system_bus_->GetObjectProxy(kNetworkManagerServiceName,
-                                    device_path);
+        system_bus_->GetObjectProxy(kNetworkManagerServiceName, device_path);
 
     dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
     dbus::MessageWriter builder(&method_call);
     builder.AppendString("org.freedesktop.NetworkManager.Device");
     builder.AppendString("DeviceType");
     std::unique_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response) {
       LOG(WARNING) << "Failed to get the device type for "
                    << device_path.value();
@@ skipping 31 matching lines @@
   }
 
   dbus::MessageReader reader(response.get());
   if (!reader.PopArrayOfObjectPaths(device_paths)) {
     LOG(WARNING) << "Unexpected response: " << response->ToString();
     return false;
   }
   return true;
 }
 
-
 bool NetworkManagerWlanApi::GetAccessPointsForAdapter(
-    const dbus::ObjectPath& adapter_path, WifiData::AccessPointDataSet* data) {
+    const dbus::ObjectPath& adapter_path,
+    WifiData::AccessPointDataSet* data) {
   // Create a proxy object for this wifi adapter, and ask it to do a scan
   // (or at least, dump its scan results).
   dbus::ObjectProxy* device_proxy =
-      system_bus_->GetObjectProxy(kNetworkManagerServiceName,
-                                  adapter_path);
-  dbus::MethodCall method_call(
-      "org.freedesktop.NetworkManager.Device.Wireless",
-      "GetAccessPoints");
+      system_bus_->GetObjectProxy(kNetworkManagerServiceName, adapter_path);
+  dbus::MethodCall method_call("org.freedesktop.NetworkManager.Device.Wireless",
+                               "GetAccessPoints");
   std::unique_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response) {
     LOG(WARNING) << "Failed to get access points data for "
                  << adapter_path.value();
     return false;
   }
   dbus::MessageReader reader(response.get());
   std::vector<dbus::ObjectPath> access_point_paths;
   if (!reader.PopArrayOfObjectPaths(&access_point_paths)) {
     LOG(WARNING) << "Unexpected response for " << adapter_path.value() << ": "
                  << response->ToString();
     return false;
   }
 
   VLOG(1) << "Wireless adapter " << adapter_path.value() << " found "
           << access_point_paths.size() << " access points.";
 
   for (size_t i = 0; i < access_point_paths.size(); ++i) {
     const dbus::ObjectPath& access_point_path = access_point_paths[i];
     VLOG(1) << "Checking access point: " << access_point_path.value();
 
-    dbus::ObjectProxy* access_point_proxy =
-        system_bus_->GetObjectProxy(kNetworkManagerServiceName,
-                                    access_point_path);
+    dbus::ObjectProxy* access_point_proxy = system_bus_->GetObjectProxy(
+        kNetworkManagerServiceName, access_point_path);
 
     AccessPointData access_point_data;
     {
       std::unique_ptr<dbus::Response> response(
           GetAccessPointProperty(access_point_proxy, "Ssid"));
       if (!response)
         continue;
       // The response should contain a variant that contains an array of bytes.
       dbus::MessageReader reader(response.get());
       dbus::MessageReader variant_reader(response.get());
       if (!reader.PopVariant(&variant_reader)) {
         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
                      << ": " << response->ToString();
         continue;
       }
       const uint8_t* ssid_bytes = NULL;
       size_t ssid_length = 0;
       if (!variant_reader.PopArrayOfBytes(&ssid_bytes, &ssid_length)) {
         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
                      << ": " << response->ToString();
         continue;
       }
       std::string ssid(ssid_bytes, ssid_bytes + ssid_length);
       access_point_data.ssid = base::UTF8ToUTF16(ssid);
     }
 
-    { // Read the mac address
+    {  // Read the mac address
       std::unique_ptr<dbus::Response> response(
           GetAccessPointProperty(access_point_proxy, "HwAddress"));
       if (!response)
         continue;
       dbus::MessageReader reader(response.get());
       std::string mac;
       if (!reader.PopVariantOfString(&mac)) {
         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
                      << ": " << response->ToString();
         continue;
@@ skipping 19 matching lines @@
       uint8_t strength = 0;
       if (!reader.PopVariantOfByte(&strength)) {
         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
                      << ": " << response->ToString();
         continue;
       }
       // Convert strength as a percentage into dBs.
       access_point_data.radio_signal_strength = -100 + strength / 2;
     }
 
-    { // Read the channel
+    {  // Read the channel
       std::unique_ptr<dbus::Response> response(
           GetAccessPointProperty(access_point_proxy, "Frequency"));
       if (!response)
         continue;
       dbus::MessageReader reader(response.get());
       uint32_t frequency = 0;
       if (!reader.PopVariantOfUint32(&frequency)) {
         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
                      << ": " << response->ToString();
         continue;
       }
 
       // NetworkManager returns frequency in MHz.
-      access_point_data.channel =
-          frquency_in_khz_to_channel(frequency * 1000);
+      access_point_data.channel = frquency_in_khz_to_channel(frequency * 1000);
     }
     VLOG(1) << "Access point data of " << access_point_path.value() << ": "
             << "SSID: " << access_point_data.ssid << ", "
             << "MAC: " << access_point_data.mac_address << ", "
             << "Strength: " << access_point_data.radio_signal_strength << ", "
             << "Channel: " << access_point_data.channel;
 
     data->insert(access_point_data);
   }
   return true;
@@ skipping 15 matching lines @@
   return response;
 }
 
 }  // namespace
 
 // static
 WifiDataProvider* WifiDataProviderManager::DefaultFactoryFunction() {
   return new WifiDataProviderLinux();
 }
 
-WifiDataProviderLinux::WifiDataProviderLinux() {
-}
+WifiDataProviderLinux::WifiDataProviderLinux() {}
 
-WifiDataProviderLinux::~WifiDataProviderLinux() {
-}
+WifiDataProviderLinux::~WifiDataProviderLinux() {}
 
-WifiDataProviderCommon::WlanApiInterface*
-WifiDataProviderLinux::NewWlanApi() {
+WifiDataProviderCommon::WlanApiInterface* WifiDataProviderLinux::NewWlanApi() {
   std::unique_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
   if (wlan_api->Init())
     return wlan_api.release();
   return NULL;
 }
 
 WifiPollingPolicy* WifiDataProviderLinux::NewPollingPolicy() {
   return new GenericWifiPollingPolicy<kDefaultPollingIntervalMilliseconds,
                                       kNoChangePollingIntervalMilliseconds,
                                       kTwoNoChangePollingIntervalMilliseconds,
                                       kNoWifiPollingIntervalMilliseconds>;
 }
 
 WifiDataProviderCommon::WlanApiInterface*
 WifiDataProviderLinux::NewWlanApiForTesting(dbus::Bus* bus) {
   std::unique_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
   if (wlan_api->InitWithBus(bus))
     return wlan_api.release();
   return NULL;
 }
 
 }  // namespace device