Geolocation cleanup: use unique_ptr<>s and rename New{WlanApi/PollingPolicy} to CreateBla()

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/memory/ptr_util.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 {
@@ skipping 52 matching lines @@
       dbus::ObjectProxy* proxy,
       const std::string& property_name);
 
   scoped_refptr<dbus::Bus> system_bus_;
   dbus::ObjectProxy* network_manager_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkManagerWlanApi);
 };
 
 // Convert a wifi frequency to the corresponding channel. Adapted from
-// geolocaiton/wifilib.cc in googleclient (internal to google).
+// geolocation/wifilib.cc in googleclient (internal to google).
 int frquency_in_khz_to_channel(int frequency_khz) {
   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
 }
@@ skipping 28 matching lines @@
     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];
+  for (const dbus::ObjectPath& device_path : device_paths) {
     VLOG(1) << "Checking device: " << device_path.value();
 
     dbus::ObjectProxy* device_proxy =
         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(
@@ skipping 62 matching lines @@
   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];
+  for (const dbus::ObjectPath& access_point_path : access_point_paths) {
     VLOG(1) << "Checking access point: " << access_point_path.value();
 
     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)
@@ skipping 104 matching lines @@
 
 // static
 WifiDataProvider* WifiDataProviderManager::DefaultFactoryFunction() {
   return new WifiDataProviderLinux();
 }
 
 WifiDataProviderLinux::WifiDataProviderLinux() {}
 
 WifiDataProviderLinux::~WifiDataProviderLinux() {}
 
-WifiDataProviderCommon::WlanApiInterface* WifiDataProviderLinux::NewWlanApi() {
+std::unique_ptr<WifiDataProviderCommon::WlanApiInterface>
+WifiDataProviderLinux::CreateWlanApi() {
   std::unique_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
   if (wlan_api->Init())
-    return wlan_api.release();
-  return NULL;
+    return std::move(wlan_api);
+  return nullptr;
 }
 
-WifiPollingPolicy* WifiDataProviderLinux::NewPollingPolicy() {
-  return new GenericWifiPollingPolicy<kDefaultPollingIntervalMilliseconds,
-                                      kNoChangePollingIntervalMilliseconds,
-                                      kTwoNoChangePollingIntervalMilliseconds,
-                                      kNoWifiPollingIntervalMilliseconds>;
+std::unique_ptr<WifiPollingPolicy>
+WifiDataProviderLinux::CreatePollingPolicy() {
+  return base::MakeUnique<GenericWifiPollingPolicy<
+      kDefaultPollingIntervalMilliseconds, kNoChangePollingIntervalMilliseconds,
+      kTwoNoChangePollingIntervalMilliseconds,
+      kNoWifiPollingIntervalMilliseconds>>();
 }
 
-WifiDataProviderCommon::WlanApiInterface*
-WifiDataProviderLinux::NewWlanApiForTesting(dbus::Bus* bus) {
+std::unique_ptr<WifiDataProviderCommon::WlanApiInterface>
+WifiDataProviderLinux::CreateWlanApiForTesting(dbus::Bus* bus) {
   std::unique_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
   if (wlan_api->InitWithBus(bus))
-    return wlan_api.release();
-  return NULL;
+    return std::move(wlan_api);
+  return nullptr;
+  ;
 }
 
 }  // namespace device