Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/wifi/wifi_service_mock.cc

+// 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/message_loop/message_loop.h"
+
+class WiFiServiceMock : public WiFiService {
+ public:
+  WiFiServiceMock() {
+    // Populate mock data expected by unit test.
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          WiFiService::kConnectionStateConnected;
+      network_properties.guid = "stub_ethernet";
+      network_properties.name = "eth0";
+      network_properties.type = WiFiService::kNetworkTypeEthernet;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          WiFiService::kConnectionStateConnected;
+      network_properties.guid = "stub_wifi1";
+      network_properties.name = "wifi1";
+      network_properties.type = WiFiService::kNetworkTypeWiFi;
+      network_properties.frequency = 0;
+      network_properties.ssid = "stub_wifi1";
+      network_properties.security = WiFiService::kSecurityWEP_PSK;
+      network_properties.signal_strength = 0;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          WiFiService::kConnectionStateConnected;
+      network_properties.guid = "stub_vpn1";
+      network_properties.name = "vpn1";
+      network_properties.type = WiFiService::kNetworkTypeVPN;
+      network_properties.json_extra =
+          "    {"
+          "      \"AutoConnect\": false"
+          "    }";
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          WiFiService::kConnectionStateNotConnected;
+      network_properties.guid = "stub_wifi2";
+      network_properties.name = "wifi2_PSK";
+      network_properties.type = WiFiService::kNetworkTypeWiFi;
+      network_properties.frequency = 5000;
+      network_properties.frequency_list.push_back(2400);
+      network_properties.frequency_list.push_back(5000);
+      network_properties.ssid = "stub_wifi2";
+      network_properties.security = WiFiService::kSecurityWPA_PSK;
+      network_properties.signal_strength = 80;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          WiFiService::kConnectionStateNotConnected;
+      network_properties.guid = "stub_cellular1";
+      network_properties.name = "cellular1";
+      network_properties.type = WiFiService::kNetworkTypeCellular;
+      network_properties.json_extra =
+          "    {"
+          "      \"ActivateOverNonCellularNetwork\": false,"
+          "      \"ActivationState\": \"not-activated\","
+          "      \"NetworkTechnology\": \"GSM\","
+          "      \"RoamingState\": \"home\""
+          "    }";
+      networks_.push_back(network_properties);
+    }
+  }
+
+  virtual void GetProperties(const std::string& network_guid,
+                             const NetworkPropertiesCallback& callback,
+                             const ErrorCallback& error_callback) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      callback.Run(network_guid, *network_properties);
+    } else {
+      scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+      error_callback.Run("Error.DBusFailed", error_data.Pass());
+    }
+  }
+
+  virtual void GetState(const std::string& network_guid,
+                        const NetworkPropertiesCallback& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {}
+
+  virtual void GetManagedProperties(
+      const std::string& network_guid,
+      const DictionaryResultCallback& callback,
+      const ErrorCallback& error_callback) OVERRIDE {}
+
+  virtual void SetProperties(const std::string& network_guid,
+                             const base::DictionaryValue& properties,
+                             const StringResultCallback& callback,
+                             const ErrorCallback& error_callback) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end() &&
+        network_properties->UpdateFromValue(properties)) {
+      callback.Run(network_guid);
+    } else {
+      scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+      error_callback.Run("Error.DBusFailed", error_data.Pass());
+    }
+  }
+
+  virtual void GetVisibleNetworks(
+      const NetworkListCallback& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
+    callback.Run(networks_);
+  }
+
+  virtual void RequestNetworkScan() OVERRIDE {}
+
+  virtual void StartConnect(const std::string& network_guid,
+                            const StringResultCallback& callback,
+                            const ErrorCallback& error_callback) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      DisconnectAllNetworksOfType(network_properties->type);
+      network_properties->connection_state = kConnectionStateConnected;
+      SortNetworks();
+      callback.Run(network_guid);
+    } else {
+      scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+      error_callback.Run("not-found", error_data.Pass());
+    }
+  }
+
+  virtual void StartDisconnect(const std::string& network_guid,
+                               const StringResultCallback& callback,
+                               const ErrorCallback& error_callback) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      network_properties->connection_state = kConnectionStateNotConnected;
+      SortNetworks();
+      callback.Run(network_guid);
+    } else {
+      scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+      error_callback.Run("not-found", error_data.Pass());
+    }
+  }
+
+ private:
+  NetworkList::iterator FindNetwork(const std::string& network_guid) {
+    for (NetworkList::iterator it = networks_.begin(); it != networks_.end();
+         ++it) {
+      if (it->guid == network_guid)
+        return it;
+    }
+    return networks_.end();
+  }
+
+  void DisconnectAllNetworksOfType(WiFiService::NetworkType type) {
+    for (NetworkList::iterator it = networks_.begin(); it != networks_.end();
+         ++it) {
+      if (it->type == type)
+        it->connection_state = kConnectionStateNotConnected;
+    }
+  }
+
+  void SortNetworks() {
+    // Sort networks, so connected/connecting is up front, then by type:
+    // Ethernet, WiFi, Cellular, VPN
+    networks_.sort(WiFiService::NetworkProperties::OrderByType);
+  }
+
+  NetworkList networks_;
+};
+
+WiFiService* WiFiService::CreateServiceMock() { return new WiFiServiceMock(); }