Eliminate ConenctionType, etc from chromeos_network.h

chromeos_network.cc

 // Copyright (c) 2009 The Chromium OS 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 "chromeos_network.h"  // NOLINT
 
 #include <algorithm>
 #include <cstring>
 #include <list>
 #include <set>
 #include <vector>
 
 #include "marshal.glibmarshal.h"  // NOLINT
 #include "base/scoped_ptr.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus.h"  // NOLINT
 #include "chromeos/glib/object.h"  // NOLINT
 #include "chromeos/string.h"
 
 // TODO(rtc): Unittest this code as soon as the tree is refactored.
 namespace chromeos {  // NOLINT
 
 namespace { // NOLINT
 
-// Connman D-Bus service identifiers.
-static const char* kConnmanManagerInterface = "org.chromium.flimflam.Manager";
-static const char* kConnmanServiceInterface = "org.chromium.flimflam.Service";
-static const char* kConnmanServiceName = "org.chromium.flimflam";
-static const char* kConnmanIPConfigInterface = "org.chromium.flimflam.IPConfig";
-static const char* kConnmanDeviceInterface = "org.chromium.flimflam.Device";
-static const char* kConnmanProfileInterface = "org.chromium.flimflam.Profile";
-static const char* kConnmanNetworkInterface = "org.chromium.flimflam.Network";
+// Flimflam D-Bus service identifiers.
+static const char* kFlimflamManagerInterface = "org.chromium.flimflam.Manager";
+static const char* kFlimflamServiceInterface = "org.chromium.flimflam.Service";
+static const char* kFlimflamServiceName = "org.chromium.flimflam";
+static const char* kFlimflamIPConfigInterface = "org.chromium.flimflam.IPConfig";
+static const char* kFlimflamDeviceInterface = "org.chromium.flimflam.Device";
+static const char* kFlimflamProfileInterface = "org.chromium.flimflam.Profile";
+static const char* kFlimflamNetworkInterface = "org.chromium.flimflam.Network";
 
-// Connman function names.
+// Flimflam function names.
 static const char* kGetPropertiesFunction = "GetProperties";
 static const char* kSetPropertyFunction = "SetProperty";
 static const char* kClearPropertyFunction = "ClearProperty";
 static const char* kConnectFunction = "Connect";
 static const char* kDisconnectFunction = "Disconnect";
 static const char* kRequestScanFunction = "RequestScan";
 static const char* kGetWifiServiceFunction = "GetWifiService";
 static const char* kEnableTechnologyFunction = "EnableTechnology";
 static const char* kDisableTechnologyFunction = "DisableTechnology";
 static const char* kAddIPConfigFunction = "AddIPConfig";
 static const char* kRemoveConfigFunction = "Remove";
 static const char* kGetEntryFunction = "GetEntry";
 static const char* kDeleteEntryFunction = "DeleteEntry";
 static const char* kActivateCellularModemFunction = "ActivateCellularModem";
 
-// Connman property names.
+// Flimflam property names.
 static const char* kSecurityProperty = "Security";
 static const char* kPassphraseProperty = "Passphrase";
 static const char* kIdentityProperty = "Identity";
 static const char* kCertPathProperty = "CertPath"; // DEPRECATED
 static const char* kOfflineModeProperty = "OfflineMode";
 static const char* kSignalStrengthProperty = "Strength";
 static const char* kNameProperty = "Name";
 static const char* kTypeProperty = "Type";
 static const char* kUnknownString = "UNKNOWN";
 static const char* kAutoConnectProperty = "AutoConnect";
 static const char* kModeProperty = "Mode";
 static const char* kActiveProfileProperty = "ActiveProfile";
 static const char* kSSIDProperty = "SSID";
 static const char* kDevicesProperty = "Devices";
 static const char* kNetworksProperty = "Networks";
 static const char* kConnectedProperty = "Connected";
 static const char* kWifiChannelProperty = "WiFi.Channel";
 static const char* kScanIntervalProperty = "ScanInterval";
 static const char* kPoweredProperty = "Powered";
 
-// Connman device info property names.
+// Flimflam device info property names.
 static const char* kIPConfigsProperty = "IPConfigs";
 static const char* kCertpathSettingsPrefix = "SETTINGS:";
 
-// Connman EAP service properties
+// Flimflam EAP service properties
 static const char* kEAPEAPProperty = "EAP.EAP";
 static const char* kEAPClientCertProperty = "EAP.ClientCert";
 static const char* kEAPCertIDProperty = "EAP.CertID";
 static const char* kEAPKeyIDProperty = "EAP.KeyID";
 static const char* kEAPPINProperty = "EAP.PIN";
 
-// Connman monitored properties
+// Flimflam monitored properties
 static const char* kMonitorPropertyChanged = "PropertyChanged";
 
-// Connman type options.
-static const char* kTypeEthernet = "ethernet";
+// Flimflam type options.
 static const char* kTypeWifi = "wifi";
-static const char* kTypeWimax = "wimax";
-static const char* kTypeBluetooth = "bluetooth";
-static const char* kTypeCellular = "cellular";
-static const char* kTypeUnknown = "";
 
-// Connman mode options.
+// Flimflam mode options.
 static const char* kModeManaged = "managed";
 
-// Connman security options.
-static const char* kSecurityWpa = "wpa";
-static const char* kSecurityWep = "wep";
-static const char* kSecurityRsn = "rsn";
-static const char* kSecurity8021x = "802_1x";
-static const char* kSecurityNone = "none";
-
 // Cashew D-Bus service identifiers.
 static const char* kCashewServiceName = "org.chromium.Cashew";
 static const char* kCashewServicePath = "/org/chromium/Cashew";
 static const char* kCashewServiceInterface = "org.chromium.Cashew";
 
 // Cashew function names.
 static const char* kRequestDataPlanFunction = "RequestDataPlansUpdate";
 static const char* kRetrieveDataPlanFunction = "GetDataPlans";
 
-// Connman monitored properties
+// Flimflam monitored properties
 static const char* kMonitorDataPlanUpdate = "DataPlansUpdate";
 
 // Cashew data plan properties
 static const char* kCellularPlanNameProperty = "CellularPlanName";
 static const char* kCellularPlanTypeProperty = "CellularPlanType";
 static const char* kCellularPlanUpdateTimeProperty = "CellularPlanUpdateTime";
 static const char* kCellularPlanStartProperty = "CellularPlanStart";
 static const char* kCellularPlanEndProperty = "CellularPlanEnd";
 static const char* kCellularPlanDataBytesProperty = "CellularPlanDataBytes";
 static const char* kCellularDataBytesUsedProperty = "CellularDataBytesUsed";
@@ skipping 16 matching lines @@
 
 // IPConfig type options.
 static const char* kTypeIPv4 = "ipv4";
 static const char* kTypeIPv6 = "ipv6";
 static const char* kTypeDHCP = "dhcp";
 static const char* kTypeBOOTP = "bootp";
 static const char* kTypeZeroConf = "zeroconf";
 static const char* kTypeDHCP6 = "dhcp6";
 static const char* kTypePPP = "ppp";
 
-static const char* TypeToString(ConnectionType type) {
-  switch (type) {
-    case TYPE_UNKNOWN:
-      break;
-    case TYPE_ETHERNET:
-      return kTypeEthernet;
-    case TYPE_WIFI:
-      return kTypeWifi;
-    case TYPE_WIMAX:
-      return kTypeWimax;
-    case TYPE_BLUETOOTH:
-      return kTypeBluetooth;
-    case TYPE_CELLULAR:
-      return kTypeCellular;
-  }
-  return kTypeUnknown;
-}
-
-static const char* SecurityToString(ConnectionSecurity security) {
-  switch (security) {
-    case SECURITY_UNKNOWN:
-      break;
-    case SECURITY_8021X:
-      return kSecurity8021x;
-    case SECURITY_RSN:
-      return kSecurityRsn;
-    case SECURITY_WPA:
-      return kSecurityWpa;
-    case SECURITY_WEP:
-      return kSecurityWep;
-    case SECURITY_NONE:
-      return kSecurityNone;
-  }
-  return kUnknownString;
-}

[stevenjb, 2011/03/02 23:35:57]

Moved to chromeos_network_deprecated.cc

-
 static CellularDataPlanType ParseCellularDataPlanType(const std::string& type) {
   if (type == kCellularDataPlanUnlimited)
     return CELLULAR_DATA_PLAN_UNLIMITED;
   if (type == kCellularDataPlanMeteredPaid)
     return CELLULAR_DATA_PLAN_METERED_PAID;
   if (type == kCellularDataPlanMeteredBase)
     return CELLULAR_DATA_PLAN_METERED_BASE;
   return CELLULAR_DATA_PLAN_UNKNOWN;
 }
 
@@ skipping 307 matching lines @@
 }
 
 // Returns a IPConfig object populated with data from a
 // given DBus object path.
 //
 // returns true on success.
 bool ParseIPConfig(const char* path, IPConfig *ipconfig) {
   ipconfig->path = NewStringCopy(path);
 
   dbus::Proxy config_proxy(dbus::GetSystemBusConnection(),
-                           kConnmanServiceName,
+                           kFlimflamServiceName,
                            path,
-                           kConnmanIPConfigInterface);
+                           kFlimflamIPConfigInterface);
   glib::ScopedHashTable properties;
   if (!GetProperties(config_proxy, &properties))
     return false;
   ParseIPConfigProperties(properties, ipconfig);
   return true;
 }
 
 extern "C"
 IPConfigStatus* ChromeOSListIPConfigs(const char* device_path) {
   if (!device_path || strlen(device_path) == 0)
     return NULL;
 
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy device_proxy(bus,
-                           kConnmanServiceName,
+                           kFlimflamServiceName,
                            device_path,
-                           kConnmanDeviceInterface);
+                           kFlimflamDeviceInterface);
 
   glib::ScopedHashTable properties;
   if (!GetProperties(device_proxy, &properties)) {
     return NULL;
   }
 
   GHashTable* table = properties.get();
   gpointer ptr = g_hash_table_lookup(table, kIPConfigsProperty);
   if (ptr == NULL)
     return NULL;
@@ skipping 28 matching lines @@
   properties.Retrieve(kAddressProperty, &hardware_address);
   result->hardware_address = NewStringCopy(hardware_address);
 
   return result;
 }
 
 extern "C"
 bool ChromeOSAddIPConfig(const char* device_path, IPConfigType type) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy device_proxy(bus,
-                           kConnmanServiceName,
+                           kFlimflamServiceName,
                            device_path,
-                           kConnmanDeviceInterface);
+                           kFlimflamDeviceInterface);
 
   glib::ScopedError error;
   ::DBusGProxy obj;
   const char* type_str = NULL;
   switch(type) {
     case IPCONFIG_TYPE_IPV4:
       type_str = kTypeIPv4;
       break;
     case IPCONFIG_TYPE_IPV6:
       type_str = kTypeIPv6;
@@ skipping 30 matching lines @@
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
 extern "C"
 bool ChromeOSSaveIPConfig(IPConfig* config) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy device_proxy(bus,
-                           kConnmanServiceName,
+                           kFlimflamServiceName,
                            config->path,
-                           kConnmanIPConfigInterface);
+                           kFlimflamIPConfigInterface);
 /*
   TODO(chocobo): Save all the values
 
   glib::Value value_set;
 
   glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(device_proxy.gproxy(),
                            kSetPropertyFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            key,
                            G_TYPE_VALUE,
                            &value_set,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) <<"Set IPConfig Property failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
 */
   return true;
 }
 
 extern "C"
 bool ChromeOSRemoveIPConfig(IPConfig* config) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy config_proxy(bus,
-                           kConnmanServiceName,
+                           kFlimflamServiceName,
                            config->path,
-                           kConnmanIPConfigInterface);
+                           kFlimflamIPConfigInterface);
 
   glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(config_proxy.gproxy(),
                            kRemoveConfigFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) <<"Set IPConfig Property failed: "
         << (error->message ? error->message : "Unknown Error.");
@@ skipping 35 matching lines @@
   delete status;
 
 }
 
 extern "C"
 PropertyChangeMonitor ChromeOSMonitorNetworkManager(
     MonitorPropertyCallback callback,
     void* object) {
   RegisterNetworkMarshallers();
   dbus::Proxy proxy(dbus::GetSystemBusConnection(),
-                    kConnmanServiceName,
+                    kFlimflamServiceName,
                     "/",
-                    kConnmanManagerInterface);
+                    kFlimflamManagerInterface);
   PropertyChangeMonitor monitor =
       new PropertyChangedHandler(callback, "/", object);
   monitor->set_connection(dbus::Monitor(proxy,
                                         kMonitorPropertyChanged,
                                         &PropertyChangedHandler::Run,
                                         monitor));
 
   return monitor;
 }
 
 extern "C"
 void ChromeOSDisconnectPropertyChangeMonitor(
     PropertyChangeMonitor connection) {
   dbus::Disconnect(connection->connection());
   delete connection;
 }
 
 extern "C"
 PropertyChangeMonitor ChromeOSMonitorNetworkService(
     MonitorPropertyCallback callback,
     const char* service_path,
     void* object) {
   RegisterNetworkMarshallers();
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
   PropertyChangeMonitor monitor =
       new PropertyChangedHandler(callback, service_path, object);
   monitor->set_connection(dbus::Monitor(service_proxy,
                                         kMonitorPropertyChanged,
                                         &PropertyChangedHandler::Run,
                                         monitor));
   return monitor;
 }
 
 extern "C"
 void ChromeOSDisconnectMonitorService(PropertyChangeMonitor connection) {
   dbus::Disconnect(connection->connection());
   delete connection;
 }
 
 extern "C"
-void ChromeOSRequestScan(ConnectionType type) {
-  dbus::Proxy manager_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
-                            "/",
-                            kConnmanManagerInterface);
-  gchar* device = ::g_strdup(TypeToString(type));
-  glib::ScopedError error;
-  if (!::dbus_g_proxy_call(manager_proxy.gproxy(),
-                           kRequestScanFunction,
-                           &Resetter(&error).lvalue(),
-                           G_TYPE_STRING,
-                           device,
-                           G_TYPE_INVALID,
-                           G_TYPE_INVALID)) {
-    LOG(WARNING) << "ChromeOSRequestScan failed: "
-        << (error->message ? error->message : "Unknown Error.");
-  }
-}

[stevenjb, 2011/03/02 23:35:57]

Moved to chromeos_network_deprecated.cc

-
-extern "C"
 bool ChromeOSActivateCellularModem(const char* service_path,
                                    const char* carrier) {
   if (carrier == NULL)
     carrier = "";
 
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   // Now try activating.
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kActivateCellularModemFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            carrier,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
@@ skipping 104 matching lines @@
 
 }  // namespace
 
 
 extern "C"
 bool ChromeOSConnectToNetworkWithCertInfo(const char* service_path,
                                           const char* passphrase,
                                           const char* identity,
                                           const char* certpath) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   // Set passphrase if non-null.
   if (passphrase) {
     glib::Value value_passphrase(passphrase);
     glib::ScopedError error;
     if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                              kSetPropertyFunction,
                              &Resetter(&error).lvalue(),
                              G_TYPE_STRING,
                              kPassphraseProperty,
@@ skipping 51 matching lines @@
 bool ChromeOSConnectToNetwork(const char* service_path,
                               const char* passphrase) {
 
   return ChromeOSConnectToNetworkWithCertInfo(service_path, passphrase,
                                               NULL, NULL);
 }
 
 extern "C"
 bool ChromeOSDisconnectFromNetwork(const char* service_path) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   // Now try disconnecting.
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kDisconnectFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "DisconnectFromNetwork failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
 extern "C"
 bool ChromeOSDeleteRememberedService(const char* service_path) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy manager_proxy(bus,
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             "/",
-                            kConnmanManagerInterface);
+                            kFlimflamManagerInterface);
 
   glib::ScopedHashTable properties;
   if (!GetProperties(manager_proxy, &properties)) {
     return false;
   }
 
   glib::Value profile_val;
   properties.Retrieve(kActiveProfileProperty, &profile_val);
   const gchar* profile_path =
       static_cast<const gchar*>(g_value_get_boxed(&profile_val));
 
   dbus::Proxy profile_proxy(bus,
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             profile_path,
-                            kConnmanProfileInterface);
+                            kFlimflamProfileInterface);
 
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(profile_proxy.gproxy(),
                            kDeleteEntryFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            service_path,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "DeleteEntry failed: "
                  << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
-extern "C"
-bool ChromeOSEnableNetworkDevice(ConnectionType type, bool enable) {
-  dbus::BusConnection bus = dbus::GetSystemBusConnection();
-  dbus::Proxy manager_proxy(bus,
-                            kConnmanServiceName,
-                            "/",
-                            kConnmanManagerInterface);
-  if (type == TYPE_UNKNOWN) {
-    LOG(WARNING) << "EnableNetworkDevice called with an unknown type: " << type;
-    return false;
-  }
-
-  gchar* device = ::g_strdup(TypeToString(type));
-  glib::ScopedError error;
-  if (!::dbus_g_proxy_call(manager_proxy.gproxy(),
-                           enable ? kEnableTechnologyFunction :
-                                    kDisableTechnologyFunction,
-                           &Resetter(&error).lvalue(),
-                           G_TYPE_STRING,
-                           device,
-                           G_TYPE_INVALID,
-                           G_TYPE_INVALID)) {
-    LOG(WARNING) << "EnableNetworkDevice failed: "
-        << (error->message ? error->message : "Unknown Error.");
-    ::g_free(device);
-    return false;
-  }
-
-  ::g_free(device);
-  return true;
-}

[stevenjb, 2011/03/02 23:35:57]

Moved to chromeos_network_deprecated.cc

 
 extern "C"
 bool ChromeOSSetOfflineMode(bool offline) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy manager_proxy(bus,
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             "/",
-                            kConnmanManagerInterface);
+                            kFlimflamManagerInterface);
 
   glib::Value value_offline(offline);
 
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(manager_proxy.gproxy(),
                            kSetPropertyFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            kOfflineModeProperty,
                            G_TYPE_VALUE,
                            &value_offline,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "SetOfflineMode failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
 
   return true;
 }
 
 extern "C"
 bool ChromeOSSetAutoConnect(const char* service_path, bool auto_connect) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   glib::Value value_auto_connect(auto_connect);
 
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kSetPropertyFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            kAutoConnectProperty,
                            G_TYPE_VALUE,
                            &value_auto_connect,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "SetAutoConnect failed: "
                  << (error->message ? error->message : "Unknown Error.");
     return false;
   }
 
   return true;
 }
 
 static bool ClearServiceProperty(const char* service_path,
                                  const char* property) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kClearPropertyFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            property,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "Clearing property " << property << " failed: "
                  << (error->message ? error->message : "Unknown Error.");
     return false;
   }
 
   return true;
 }
 
 static bool SetServiceStringProperty(const char* service_path,
                                      const char* property, const char* value) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             service_path,
-                            kConnmanServiceInterface);
+                            kFlimflamServiceInterface);
 
   glib::Value value_string(value);
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kSetPropertyFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_STRING,
                            property,
                            G_TYPE_VALUE,
                            &value_string,
@@ skipping 31 matching lines @@
 
 namespace {
 // Returns a DeviceNetworkInfo object populated with data from a
 // given DBus object path.
 //
 // returns true on success.
 bool ParseDeviceNetworkInfo(dbus::BusConnection bus,
                             const char* path,
                             DeviceNetworkInfo* info) {
   dbus::Proxy network_proxy(bus,
-                            kConnmanServiceName,
+                            kFlimflamServiceName,
                             path,
-                            kConnmanNetworkInterface);
+                            kFlimflamNetworkInterface);
   glib::ScopedHashTable properties;
   if (!GetProperties(network_proxy, &properties))
     return false;
   info->network_path = NewStringCopy(path);
 
   // Address (mandatory)
   const char* default_string = kUnknownString;
   if (!properties.Retrieve(kAddressProperty, &default_string))
     return false;
   info->address = NewStringCopy(default_string);
@@ skipping 24 matching lines @@
   return true;
 }
 }  // namespace
 
 extern "C"
 DeviceNetworkList* ChromeOSGetDeviceNetworkList() {
   glib::Value devices_val;
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   {
     dbus::Proxy manager_proxy(bus,
-                              kConnmanServiceName,
+                              kFlimflamServiceName,
                               "/",
-                              kConnmanManagerInterface);
+                              kFlimflamManagerInterface);
 
     glib::ScopedHashTable properties;
     if (!GetProperties(manager_proxy, &properties)) {
       LOG(WARNING) << "Couldn't read managers's properties";
       return NULL;
     }
 
     // Get the Devices property from the manager
     if (!properties.Retrieve(kDevicesProperty, &devices_val)) {
       LOG(WARNING) << kDevicesProperty << " property not found";
       return NULL;
     }
   }
   GPtrArray* devices = static_cast<GPtrArray*>(g_value_get_boxed(&devices_val));
   std::vector<DeviceNetworkInfo> buffer;
   bool found_at_least_one_device = false;
   for (size_t i = 0; i < devices->len; i++) {
     const char* device_path =
         static_cast<const char*>(g_ptr_array_index(devices, i));
     dbus::Proxy device_proxy(bus,
-                             kConnmanServiceName,
+                             kFlimflamServiceName,
                              device_path,
-                             kConnmanDeviceInterface);
+                             kFlimflamDeviceInterface);
 
     glib::ScopedHashTable properties;
     if (!GetProperties(device_proxy, &properties)) {
       LOG(WARNING) << "Couldn't read device's properties";
       continue;
     }
 
     glib::Value networks_val;
     if (!properties.Retrieve(kNetworksProperty, &networks_val))
       continue;  // Some devices do not list networks, e.g. ethernet.
@@ skipping 39 matching lines @@
 void ChromeOSFreeDeviceNetworkList(DeviceNetworkList* list) {
   delete [] list->networks;
   delete list;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Flimflam asynchronous interface code
 
 namespace {
 
-struct GetPropertiesCallbackData {
+struct FlimflamCallbackData {
+  FlimflamCallbackData(const char* interface,
+                       const char* service_path) {
+    DCHECK(interface);
+    interface_name = std::string(interface);
+    proxy = new dbus::Proxy(dbus::GetSystemBusConnection(),
+                            kFlimflamServiceName,
+                            service_path,
+                            interface);
+  }
+  virtual ~FlimflamCallbackData() {
+    delete proxy;
+  }
+  // Owned by the callback, deleteted in the destructor:
+  dbus::Proxy* proxy;
+  std::string interface_name;  // Store for error reporting.
+};
+
+// DBus will always call the Delete function passed to it by
+// dbus_g_proxy_begin_call, whether DBus calls the callback or not.
+void DeleteFlimflamCallbackData(void* user_data) {
+  FlimflamCallbackData* cb_data = static_cast<FlimflamCallbackData*>(user_data);
+  delete cb_data;  // virtual destructor.
+}
+
+// Generic hander for logging errors from messages with no return value.
+void FlimflamNotifyHandleError(DBusGProxy* gproxy,
+                               DBusGProxyCall* call_id,
+                               void* user_data) {
+  glib::ScopedError error;
+  if (!::dbus_g_proxy_end_call(gproxy,
+                               call_id,
+                               &Resetter(&error).lvalue(),
+                               G_TYPE_INVALID)) {
+    FlimflamCallbackData* cb_data =
+        static_cast<FlimflamCallbackData*>(user_data);
+    LOG(WARNING) << "DBus Error: " << cb_data->interface_name << ": "
+                 << (error->message ? error->message : "Unknown Error.");
+  }
+}
+
+struct GetPropertiesCallbackData : public FlimflamCallbackData {
   GetPropertiesCallbackData(const char* interface,
                             const char* service_path,
                             const char* cb_path,
                             NetworkPropertiesCallback cb,
                             void* obj) :
+      FlimflamCallbackData(interface, service_path),
       callback(cb),
       object(obj) {
     callback_path = NewStringCopy(cb_path);
-    proxy = new dbus::Proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
-                            service_path,
-                            interface);
   }
-  ~GetPropertiesCallbackData() {
+  virtual ~GetPropertiesCallbackData() {
     delete callback_path;
-    delete proxy;
   }
 
   // Owned by the caller (i.e. Chrome), do not destroy them:
   NetworkPropertiesCallback callback;
   void* object;
   // Owned by the callback, deleteted in the destructor:
   const char* callback_path;
-  dbus::Proxy* proxy;
 };
 
-// DBus will always call the Delete function passed to it in
-// dbus_g_proxy_begin_call, whether DBus calls the callback or not.
-void DeleteGetPropertiesCallbackData(void* user_data) {
-  GetPropertiesCallbackData* cb_data =
-      static_cast<GetPropertiesCallbackData*>(user_data);
-  delete cb_data;
-}
-
 void GetPropertiesNotify(DBusGProxy* gproxy,
                          DBusGProxyCall* call_id,
                          void* user_data) {
   GetPropertiesCallbackData* cb_data =
       static_cast<GetPropertiesCallbackData*>(user_data);
   DCHECK(cb_data);
   glib::ScopedError error;
   glib::ScopedHashTable properties;
   if (!::dbus_g_proxy_end_call(
           gproxy,
@@ skipping 17 matching lines @@
                         NetworkPropertiesCallback callback,
                         void* object) {
   DCHECK(interface && service_path  && callback);
   GetPropertiesCallbackData* cb_data = new GetPropertiesCallbackData(
       interface, service_path, service_path, callback, object);
   DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
       cb_data->proxy->gproxy(),
       kGetPropertiesFunction,
       &GetPropertiesNotify,
       cb_data,
-      &DeleteGetPropertiesCallbackData,
+      &DeleteFlimflamCallbackData,
       G_TYPE_INVALID);
   if (!call_id) {
     LOG(ERROR) << "NULL call_id for: " << interface << " : " << service_path;
     callback(object, service_path, NULL);
     delete cb_data;
   }
 }
 
 void GetEntryAsync(const char* interface,
                    const char* profile_path,
                    const char* entry_path,
                    NetworkPropertiesCallback callback,
                    void* object) {
   DCHECK(interface && profile_path  && entry_path && callback);
   GetPropertiesCallbackData* cb_data = new GetPropertiesCallbackData(
       interface, profile_path, entry_path, callback, object);
   DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
       cb_data->proxy->gproxy(),
       kGetEntryFunction,
       &GetPropertiesNotify,
       cb_data,
-      &DeleteGetPropertiesCallbackData,
+      &DeleteFlimflamCallbackData,
       G_TYPE_STRING,
       entry_path,
       G_TYPE_INVALID);
   if (!call_id) {
     LOG(ERROR) << "NULL call_id for: "
                << interface << " : " << profile_path << " : " << entry_path;
     callback(object, entry_path, NULL);
     delete cb_data;
   }
 }
@@ skipping 12 matching lines @@
           &Resetter(&error).lvalue(),
           DBUS_TYPE_G_OBJECT_PATH,
           &service_path,
           G_TYPE_INVALID)) {
     LOG(WARNING) << "GetWifiNotify for path: '"
                  << cb_data->callback_path << "' error: "
                  << (error->message ? error->message : "Unknown Error.");
     cb_data->callback(cb_data->object, cb_data->callback_path, NULL);
   } else {
     // Now request the properties for the service.
-    GetPropertiesAsync(kConnmanServiceInterface,
+    GetPropertiesAsync(kFlimflamServiceInterface,
                        service_path,
                        cb_data->callback,
                        cb_data->object);
   }
 }
 
-struct NetworkActionCallbackData {
+struct NetworkActionCallbackData : public FlimflamCallbackData {
   NetworkActionCallbackData(const char* interface,
                             const char* service_path,
                             const char* cb_path,
                             NetworkActionCallback cb,
                             void* obj) :
+      FlimflamCallbackData(interface, service_path),
       callback(cb),
       object(obj) {
     callback_path = NewStringCopy(cb_path);
-    proxy = new dbus::Proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
-                            service_path,
-                            interface);
   }
-  ~NetworkActionCallbackData() {
+  virtual ~NetworkActionCallbackData() {
     delete callback_path;
-    delete proxy;
   }
 
   // Owned by the caller (i.e. Chrome), do not destroy them:
   NetworkActionCallback callback;
   void* object;
   // Owned by the callback, deleteted in the destructor:
   const char* callback_path;
-  dbus::Proxy* proxy;
 };
 
-// DBus will always call the Delete function passed to it in
-// dbus_g_proxy_begin_call, whether DBus calls the callback or not.
-void DeleteNetworkActionCallbackData(void* user_data) {
-  NetworkActionCallbackData* cb_data =
-      static_cast<NetworkActionCallbackData*>(user_data);
-  delete cb_data;
-}
-
 void NetworkServiceConnectNotify(DBusGProxy* gproxy,
                                  DBusGProxyCall* call_id,
                                  void* user_data) {
   NetworkActionCallbackData* cb_data =
       static_cast<NetworkActionCallbackData*>(user_data);
   DCHECK(cb_data);
   glib::ScopedError error;
   if (!::dbus_g_proxy_end_call(
           gproxy,
           call_id,
@@ skipping 16 matching lines @@
                       NETWORK_METHOD_ERROR_NONE, NULL);
   }
 }
 
 void NetworkServiceConnectAsync(
     const char* service_path,
     NetworkActionCallback callback,
     void* object) {
   DCHECK(service_path && callback);
   NetworkActionCallbackData* cb_data = new NetworkActionCallbackData(
-      kConnmanServiceInterface, service_path, service_path, callback, object);
+      kFlimflamServiceInterface, service_path, service_path, callback, object);
 
   DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
       cb_data->proxy->gproxy(),
       kConnectFunction,
       &NetworkServiceConnectNotify,
       cb_data,
-      &DeleteNetworkActionCallbackData,
+      &DeleteFlimflamCallbackData,
       DBUS_TYPE_G_OBJECT_PATH,
       &service_path,
       G_TYPE_INVALID);
   if (!call_id) {
-    LOG(ERROR) << "NULL call_id for: " << kConnmanServiceInterface
+    LOG(ERROR) << "NULL call_id for: " << kFlimflamServiceInterface
                << " : " << service_path;
     callback(object, service_path, NETWORK_METHOD_ERROR_LOCAL,
              "dbus: NULL call_id");
     delete cb_data;
   }
 }
 
 
 }  // namespace
 
 extern "C"
 void ChromeOSRequestNetworkServiceConnect(
     const char* service_path,
     NetworkActionCallback callback,
     void* object) {
   NetworkServiceConnectAsync(service_path, callback, object);
 }
 
 
 extern "C"
 void ChromeOSRequestNetworkManagerInfo(
     NetworkPropertiesCallback callback,
     void* object) {
-  GetPropertiesAsync(kConnmanManagerInterface, "/", callback, object);
+  GetPropertiesAsync(kFlimflamManagerInterface, "/", callback, object);
 }
 
 extern "C"
 void ChromeOSRequestNetworkServiceInfo(
     const char* service_path,
     NetworkPropertiesCallback callback,
     void* object) {
-  GetPropertiesAsync(kConnmanServiceInterface, service_path, callback, object);
+  GetPropertiesAsync(kFlimflamServiceInterface, service_path, callback, object);
 }
 
 extern "C"
 void ChromeOSRequestNetworkDeviceInfo(
     const char* device_path,
     NetworkPropertiesCallback callback,
     void* object) {
-  GetPropertiesAsync(kConnmanDeviceInterface, device_path, callback, object);
+  GetPropertiesAsync(kFlimflamDeviceInterface, device_path, callback, object);
 }
 
 extern "C"
 void ChromeOSRequestNetworkProfile(
     const char* profile_path,
     NetworkPropertiesCallback callback,
     void* object) {
-  GetPropertiesAsync(kConnmanProfileInterface, profile_path, callback, object);
+  GetPropertiesAsync(kFlimflamProfileInterface, profile_path, callback, object);
 }
 
 extern "C"
 void ChromeOSRequestNetworkProfileEntry(
     const char* profile_path,
     const char* entry_service_path,
     NetworkPropertiesCallback callback,
     void* object) {
-  GetEntryAsync(kConnmanProfileInterface, profile_path, entry_service_path,
+  GetEntryAsync(kFlimflamProfileInterface, profile_path, entry_service_path,
                 callback, object);
 }
 
 extern "C"
-void ChromeOSRequestWifiServicePath(
+void ChromeOSRequestHiddenWifiNetwork(
     const char* ssid,
-    ConnectionSecurity security,
+    const char* security,
     NetworkPropertiesCallback callback,
     void* object) {
   DCHECK(ssid && callback);
   GetPropertiesCallbackData* cb_data = new GetPropertiesCallbackData(
-      kConnmanManagerInterface, "/", ssid, callback, object);
+      kFlimflamManagerInterface, "/", ssid, callback, object);
 
   glib::ScopedHashTable scoped_properties =
       glib::ScopedHashTable(::g_hash_table_new_full(
           ::g_str_hash, ::g_str_equal, ::g_free, NULL));
 
   glib::Value value_mode(kModeManaged);
   glib::Value value_type(kTypeWifi);
   glib::Value value_ssid(ssid);
-  if (security == SECURITY_UNKNOWN)
-    security = SECURITY_RSN;
-  glib::Value value_security(SecurityToString(security));
+  glib::Value value_security(security);
   ::GHashTable* properties = scoped_properties.get();
   ::g_hash_table_insert(properties, ::g_strdup(kModeProperty), &value_mode);
   ::g_hash_table_insert(properties, ::g_strdup(kTypeProperty), &value_type);
   ::g_hash_table_insert(properties, ::g_strdup(kSSIDProperty), &value_ssid);
   ::g_hash_table_insert(properties, ::g_strdup(kSecurityProperty),
                         &value_security);
 
   // flimflam.Manger.GetWifiService() will apply the property changes in
   // |properties| and return a new or existing service to GetWifiNotify.
   // GetWifiNotify will then call GetPropertiesAsync, triggering a second
   // asynchronous call to GetPropertiesNotify which will then call |callback|.
   DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
       cb_data->proxy->gproxy(),
       kGetWifiServiceFunction,
       &GetWifiNotify,
       cb_data,
-      &DeleteGetPropertiesCallbackData,
+      &DeleteFlimflamCallbackData,
       ::dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
       properties,
       G_TYPE_INVALID);
   if (!call_id) {
     LOG(ERROR) << "NULL call_id for: " << kGetWifiServiceFunction;
     delete cb_data;
     callback(object, ssid, NULL);
   }
 }
 
+extern "C"
+void ChromeOSRequestNetworkScan(const char* network_type) {
+  FlimflamCallbackData* cb_data =
+      new FlimflamCallbackData(kFlimflamManagerInterface, "/");
+  DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
+      cb_data->proxy->gproxy(),
+      kRequestScanFunction,
+      &FlimflamNotifyHandleError,
+      cb_data,
+      &DeleteFlimflamCallbackData,
+      G_TYPE_STRING,
+      network_type,
+      G_TYPE_INVALID);
+  if (!call_id) {
+    LOG(ERROR) << "NULL call_id for: " << kRequestScanFunction;
+    delete cb_data;
+  }
+}
+
+extern "C"
+void ChromeOSRequestNetworkDeviceEnable(const char* network_type, bool enable) {
+  FlimflamCallbackData* cb_data =
+      new FlimflamCallbackData(kFlimflamManagerInterface, "/");
+  DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
+      cb_data->proxy->gproxy(),
+      enable ? kEnableTechnologyFunction : kDisableTechnologyFunction,
+      &FlimflamNotifyHandleError,
+      cb_data,
+      &DeleteFlimflamCallbackData,
+      G_TYPE_STRING,
+      network_type,
+      G_TYPE_INVALID);
+  if (!call_id) {
+    LOG(ERROR) << "NULL call_id for: " << kRequestScanFunction;
+    delete cb_data;
+  }
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 static glib::Value *ConvertToGlibValue(const ::Value* value) {
   switch (value->GetType()) {
     case ::Value::TYPE_BOOLEAN: {
       bool out;
       if (value->GetAsBoolean(&out))
         return new glib::Value(out);
       break;
     }
@@ skipping 22 matching lines @@
   }
   LOG(ERROR) << "Value conversion failed, type: " << value->GetType();
   return NULL;
 }
 
 
 extern "C"
 void ChromeOSSetNetworkServiceProperty(const char* service_path,
                                        const char* property,
                                        const ::Value* setting) {
-  dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
-                            kConnmanServiceName,
-                            service_path,
-                            kConnmanServiceInterface);
+  FlimflamCallbackData* cb_data =
+      new FlimflamCallbackData(kFlimflamServiceInterface, service_path);
 
   // DEPRECATED
   // Backwards-compatibility for "CertPath=SETTINGS:key_id=1,cert_id=2,..."
   if (strcmp(property, "CertPath") == 0) {
-    std::string str;
-    const char* certpath;
-    setting->GetAsString(&str);
-    certpath = str.c_str();
-    // Synchronous call for backwards compatibility.
-    // TODO(njw): remove once CertPath is deprecated in favor of
-    // explicit EAP.* properties.
-    set_certpath_properties(certpath, &service_proxy);
+    std::string certpath;
+    if (setting->GetAsString(&certpath)) {
+      // Synchronous call for backwards compatibility.
+      // TODO(njw): remove once CertPath is deprecated in favor of
+      // explicit EAP.* properties.
+      set_certpath_properties(certpath.c_str(), cb_data->proxy);
+    }
+    delete cb_data;
     return;
   }
 
+  // Start the DBus call. FlimflamNotifyHandleError will get called when
+  // it completes and log any errors.
   scoped_ptr<glib::Value> gsetting(ConvertToGlibValue(setting));
-  ::dbus_g_proxy_call_no_reply(service_proxy.gproxy(),
-                               kSetPropertyFunction,
-                               G_TYPE_STRING,
-                               property,
-                               G_VALUE_TYPE(gsetting.get()),
-                               gsetting.get(),
-                               G_TYPE_INVALID);
+  DBusGProxyCall* call_id = ::dbus_g_proxy_begin_call(
+      cb_data->proxy->gproxy(),
+      kSetPropertyFunction,
+      &FlimflamNotifyHandleError,
+      cb_data,
+      &DeleteFlimflamCallbackData,
+      G_TYPE_STRING,
+      property,
+      G_VALUE_TYPE(gsetting.get()),
+      gsetting.get(),
+      G_TYPE_INVALID);
+  if (!call_id) {
+    LOG(ERROR) << "NULL call_id for: " << kRequestScanFunction;
+    delete cb_data;
+  }
 }
 
 // Cashew services
 
 extern "C"
 void ChromeOSFreeCellularDataPlanList(CellularDataPlanList* data_plan_list) {
   if (data_plan_list == NULL)
     return;
   if (data_plan_list->plans_size > 0) {
     std::for_each(data_plan_list->plans,
@@ skipping 147 matching lines @@
   }
   DCHECK(properties_array);
 
   CellularDataPlanList *data_plan_list =
       ParseCellularDataPlanList(properties_array);
   g_ptr_array_unref(properties_array);
   return data_plan_list;
 }
 
 }  // namespace chromeos