Eliminate ConenctionType, etc from chromeos_network.h

chromeos_network_deprecated.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 "chromeos_network_deprecated.h"  // NOLINT
 
 #include <algorithm>
 #include <cstring>
 #include <list>
@@ skipping 20 matching lines @@
 
 // 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* kConnmanDeviceInterface = "org.chromium.flimflam.Device";
 static const char* kConnmanProfileInterface = "org.chromium.flimflam.Profile";
 
 // Connman function names.
 static const char* kGetPropertiesFunction = "GetProperties";
+static const char* kRequestScanFunction = "RequestScan";
 static const char* kConfigureWifiServiceFunction = "ConfigureWifiService";
 static const char* kGetWifiServiceFunction = "GetWifiService";
+static const char* kEnableTechnologyFunction = "EnableTechnology";
+static const char* kDisableTechnologyFunction = "DisableTechnology";
 static const char* kGetEntryFunction = "GetEntry";
 
 // Connman property names.
 static const char* kSecurityProperty = "Security";
 static const char* kPassphraseProperty = "Passphrase";
 static const char* kPassphraseRequiredProperty = "PassphraseRequired";
 static const char* kServicesProperty = "Services";
 static const char* kAvailableTechnologiesProperty = "AvailableTechnologies";
 static const char* kEnabledTechnologiesProperty = "EnabledTechnologies";
 static const char* kConnectedTechnologiesProperty = "ConnectedTechnologies";
@@ skipping 141 matching lines @@
     return TYPE_WIFI;
   if (type == kTypeWimax)
     return TYPE_WIMAX;
   if (type == kTypeBluetooth)
     return TYPE_BLUETOOTH;
   if (type == kTypeCellular)
     return TYPE_CELLULAR;
   return TYPE_UNKNOWN;
 }
 
+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 ConnectionMode ParseMode(const std::string& mode) {
   if (mode == kModeManaged)
     return MODE_MANAGED;
   if (mode == kModeAdhoc)
     return MODE_ADHOC;
   return MODE_UNKNOWN;
 }
 
 static ConnectionSecurity ParseSecurity(const std::string& security) {
   if (security == kSecurity8021x)
@@ skipping 545 matching lines @@
     delete info.carrier_info;
     info.carrier_info = NULL;
   }
 
   // Note: DeviceInfo is owned by SystemInfo.
 }
 
 }
 
 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.");
+  }
+  ::g_free(device);
+}
+
+extern "C"
 ServiceInfo* ChromeOSGetWifiService(const char* ssid,
                                     ConnectionSecurity security) {
   dbus::Proxy manager_proxy(dbus::GetSystemBusConnection(),
                             kConnmanServiceName,
                             "/",
                             kConnmanManagerInterface);
 
   glib::ScopedHashTable scoped_properties =
       glib::ScopedHashTable(
           ::g_hash_table_new_full(::g_str_hash,
@@ skipping 348 matching lines @@
   system->service_info_size = sizeof(ServiceInfo);
   system->device_info_size = sizeof(DeviceInfo);
 
   base::TimeDelta dt = (base::Time::Now() - t0);
   LOG(INFO) << "SystemInfo: " << dt.InMilliseconds() << " ms.";
 
   return system;
 }
 
 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;
+}
+
+extern "C"
 void ChromeOSFreeSystemInfo(SystemInfo* system) {
   if (system == NULL)
     return;
   if (system->service_size > 0) {
     std::for_each(system->services,
                   system->services + system->service_size,
                   &DeleteServiceInfoProperties);
     delete [] system->services;
   }
   if (system->remembered_service_size > 0) {
@@ skipping 70 matching lines @@
       &ManagerPropertyChangedHandler::Run, result);
   return result;
 }
 
 extern "C"
 void ChromeOSDisconnectMonitorNetwork(MonitorNetworkConnection connection) {
   dbus::Disconnect(connection->connection());
   delete connection;
 }
 
+extern "C"
+void ChromeOSRequestHiddenWifiNetwork(const char* ssid,
+                                      const char* security,
+                                      NetworkPropertiesCallback callback,
+                                      void* object);
+
+extern "C"
+void ChromeOSRequestWifiServicePath(
+    const char* ssid,
+    ConnectionSecurity security,
+    NetworkPropertiesCallback callback,
+    void* object) {
+  ChromeOSRequestHiddenWifiNetwork(
+      ssid, SecurityToString(security), callback, object);
+}
+
 }  // namespace chromeos