Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/wifi/wifi_service.cc

Index: chrome/utility/wifi/wifi_service.cc
diff --git a/chrome/utility/wifi/wifi_service.cc b/chrome/utility/wifi/wifi_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..68cce0263c13c02ffadecb205dd54e9ada9166d1
--- /dev/null
+++ b/chrome/utility/wifi/wifi_service.cc
@@ -0,0 +1,173 @@
+// Copyright 2013 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 "chrome/utility/wifi/wifi_service.h"
+
+#include "base/json/json_reader.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/stringprintf.h"
+
+namespace network_type {
+const char kAllTypes[] = "All";
+const char kCellular[] = "Cellular";
+const char kEthernet[] = "Ethernet";
+const char kVPN[] = "VPN";
+const char kWiFi[] = "WiFi";
+}  // namespace network_type
+
+namespace {
+const char kConnectionState[] = "ConnectionState";
+const char kNotConnected[] = "NotConnected";
+const char kConnected[] = "Connected";
+const char kGUID[] = "GUID";
+const char kName[] = "Name";
+const char kType[] = "Type";
+
+const char kNone[] = "None";
+const char kUnknown[] = "Unknown";
+const char kWiFi[] = "WiFi";
+const char kWiFiAutoConnect[] = "WiFi.AutoConnect";
+const char kWiFiFrequency[] = "WiFi.Frequency";
+const char kWiFiFrequencyList[] = "WiFi.FrequencyList";
+const char kWiFiSSID[] = "WiFi.SSID";
+const char kWiFiBSSID[] = "WiFi.BSSID";
+const char kWiFiSecurity[] = "WiFi.Security";
+const char kWEP_PSK[] = "WEP-PSK";
+const char kWPA[] = "WPA";
+const char kWPA_PSK[] = "WPA-PSK";
+const char kWiFiSignalStrength[] = "WiFi.SignalStrength";
+
+const char* NetworkTypeToString(WiFiService::NetworkType type) {
+  switch (type) {
+    case WiFiService::kNetworkTypeWiFi:
+      return network_type::kWiFi;
+    case WiFiService::kNetworkTypeEthernet:
+      return network_type::kEthernet;
+    case WiFiService::kNetworkTypeVPN:
+      return network_type::kVPN;
+    case WiFiService::kNetworkTypeCellular:
+      return network_type::kCellular;
+    case WiFiService::kNetworkTypeAll:
+      return network_type::kAllTypes;
+    case WiFiService::kNetworkTypeNone:
+      return kNone;
+  }
+  return kNone;
+}
+
+const char* ConnectionStateToString(WiFiService::ConnectionState state) {
+  switch (state) {
+    case WiFiService::kConnectionStateNotConnected:
+      return kNotConnected;
+    case WiFiService::kConnectionStateConnected:
+      return kConnected;
+  }
+  return kNotConnected;
+}
+
+const char* WiFiSecurityToString(WiFiService::Security security) {
+  switch (security) {
+    case WiFiService::kSecurityNone:
+      return kNone;
+    case WiFiService::kSecurityWEP_PSK:
+      return kWEP_PSK;
+    case WiFiService::kSecurityWPA:
+      return kWPA;
+    case WiFiService::kSecurityWPA_PSK:
+      return kWPA_PSK;
+    default:
+      return kUnknown;
+  }
+  return kUnknown;
+}
+
+}  // namespace
+
+WiFiService::NetworkProperties::NetworkProperties()
+    : connection_state(kConnectionStateNotConnected),
+      frequency(0),
+      security(kSecurityNone),
+      signal_strength(0),
+      auto_connect(false) {}
+
+WiFiService::NetworkProperties::~NetworkProperties() {}
+
+scoped_ptr<base::DictionaryValue> WiFiService::NetworkProperties::ToValue(
+    bool network_list) const {
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+
+  value->SetString(kGUID, guid);
+  value->SetString(kName, name);
+  value->SetString(kConnectionState, ConnectionStateToString(connection_state));
+  value->SetString(kType, NetworkTypeToString(type));
+
+  if (type == WiFiService::kNetworkTypeWiFi) {
+    value->SetString(kWiFiSecurity, WiFiSecurityToString(security));
+    value->SetInteger(kWiFiSignalStrength, signal_strength);
+
+    // Network list expects slightly different set of data.
+    if (network_list) {
+      value->SetBoolean(kWiFiAutoConnect, auto_connect);
+    } else {
+      if (frequency != WiFiService::kFrequencyUnknown)
+        value->SetInteger(kWiFiFrequency, frequency);
+      scoped_ptr<base::ListValue> frequency_list(new base::ListValue());
+      for (FrequencyList::const_iterator it = this->frequency_list.begin();
+           it != this->frequency_list.end();
+           ++it) {
+        frequency_list->AppendInteger(*it);
+      }
+      if (!frequency_list->empty())
+        value->Set(kWiFiFrequencyList, frequency_list.release());
+      if (!bssid.empty())
+        value->SetString(kWiFiBSSID, bssid);
+      value->SetString(kWiFiSSID, ssid);
+    }
+  } else {
+    // Add properites from json extra if present.
+    if (!json_extra.empty()) {
+      Value* value_extra = base::JSONReader::Read(json_extra);
+      value->Set(NetworkTypeToString(type), value_extra);
+    }
+  }
+
+  return value.Pass();
+}
+
+bool WiFiService::NetworkProperties::UpdateFromValue(
+    const base::DictionaryValue& value) {
+  std::string wifi_security;
+  if (value.GetString(kWiFiSecurity, &wifi_security)) {
+    if (!wifi_security.compare(kWEP_PSK)) {
+      security = WiFiService::kSecurityWEP_PSK;
+    } else if (!wifi_security.compare(kWPA_PSK)) {
+      security = WiFiService::kSecurityWPA_PSK;
+    } else {
+      security = WiFiService::kSecurityNone;
+    }
+    return true;
+  }
+  return false;
+}
+
+std::string WiFiService::NetworkProperties::MacAddressAsString(
+    const uint8 mac_as_int[6]) {
+  // mac_as_int is big-endian. Write in byte chunks.
+  // Format is XX:XX:XX:XX:XX:XX.
+  static const char* const kMacFormatString = "%02x:%02x:%02x:%02x:%02x:%02x";
+  return base::StringPrintf(kMacFormatString,
+                            mac_as_int[0],
+                            mac_as_int[1],
+                            mac_as_int[2],
+                            mac_as_int[3],
+                            mac_as_int[4],
+                            mac_as_int[5]);
+}
+
+bool WiFiService::NetworkProperties::OrderByType(const NetworkProperties& l,
+                                                 const NetworkProperties& r) {
+  if (l.connection_state != r.connection_state)
+    return l.connection_state < r.connection_state;
+  return l.type < r.type;
+}