Base infrastructure for Networking Private API on Windows and Mac.

components/wifi/wifi_service_mock.cc

Index: components/wifi/wifi_service_mock.cc
diff --git a/components/wifi/wifi_service_mock.cc b/components/wifi/wifi_service_mock.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5239c12aaeb6c62682c5dcdfb9a11ab6e6095c79
--- /dev/null
+++ b/components/wifi/wifi_service_mock.cc
@@ -0,0 +1,206 @@
+// 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 "components/wifi/wifi_service.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "components/onc/onc_constants.h"
+
+namespace wifi {
+
+class WiFiServiceMock : public WiFiService {

[tbarzic, 2013/11/15 22:56:30]

This isn't actually a mock.. I think TestWifiService/FakeWifiService would be
more suitable names (it shouldn't be too much of a hustle).

[mef, 2013/11/17 20:05:18]

Done.

+ public:
+  WiFiServiceMock() {
+    // Populate mock data expected by unit test.
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state = onc::connection_state::kConnected;
+      network_properties.guid = "stub_ethernet";
+      network_properties.name = "eth0";
+      network_properties.type = onc::network_type::kEthernet;
+      network_properties.json_extra =
+          "    {"
+          "      \"Authentication\": \"None\""
+          "    }";
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state = onc::connection_state::kConnected;
+      network_properties.guid = "stub_wifi1";
+      network_properties.name = "wifi1";
+      network_properties.type = onc::network_type::kWiFi;
+      network_properties.frequency = 0;
+      network_properties.ssid = "stub_wifi1";
+      network_properties.security = onc::wifi::kWEP_PSK;
+      network_properties.signal_strength = 0;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state = onc::connection_state::kConnected;
+      network_properties.guid = "stub_vpn1";
+      network_properties.name = "vpn1";
+      network_properties.type = onc::network_type::kVPN;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          onc::connection_state::kNotConnected;
+      network_properties.guid = "stub_wifi2";
+      network_properties.name = "wifi2_PSK";
+      network_properties.type = onc::network_type::kWiFi;
+      network_properties.frequency = 5000;
+      network_properties.frequency_list.push_back(2400);
+      network_properties.frequency_list.push_back(5000);
+      network_properties.ssid = "wifi2_PSK";
+      network_properties.security = onc::wifi::kWPA_PSK;
+      network_properties.signal_strength = 80;
+      networks_.push_back(network_properties);
+    }
+    {
+      WiFiService::NetworkProperties network_properties;
+      network_properties.connection_state =
+          onc::connection_state::kNotConnected;
+      network_properties.guid = "stub_cellular1";
+      network_properties.name = "cellular1";
+      network_properties.type = onc::network_type::kCellular;
+      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,
+                              DictionaryValue* properties,
+                              std::string* error) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      properties->Swap(network_properties->ToValue(false).get());
+    } else {
+      *error = "Error.DBusFailed";
+    }
+  }
+
+  virtual void SetProperties(const std::string& network_guid,
+                             scoped_ptr<base::DictionaryValue> properties,
+                             std::string* error) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties == networks_.end() ||
+        !network_properties->UpdateFromValue(*properties)) {
+      *error = "Error.DBusFailed";
+    }
+  }
+
+  virtual void GetVisibleNetworks(ListValue* network_list) OVERRIDE {
+    for (WiFiService::NetworkList::const_iterator it = networks_.begin();
+         it != networks_.end();
+         ++it) {
+      scoped_ptr<DictionaryValue> network(it->ToValue(true));
+      network_list->Append(network.release());
+    }
+  }
+
+  virtual void RequestNetworkScan() OVERRIDE {
+    NotifyNetworkListChanged(networks_);
+  }
+
+  virtual void StartConnect(const std::string& network_guid,
+                            std::string* error) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      DisconnectAllNetworksOfType(network_properties->type);
+      network_properties->connection_state = onc::connection_state::kConnected;
+      SortNetworks();
+      NotifyNetworkListChanged(networks_);
+      NotifyNetworkChanged(network_guid);
+    } else {
+      *error = "configure-failed";
+    }
+  }
+
+  virtual void StartDisconnect(const std::string& network_guid,
+                               std::string* error) OVERRIDE {
+    NetworkList::iterator network_properties = FindNetwork(network_guid);
+    if (network_properties != networks_.end()) {
+      network_properties->connection_state =
+          onc::connection_state::kNotConnected;
+      SortNetworks();
+      NotifyNetworkListChanged(networks_);
+      NotifyNetworkChanged(network_guid);
+    } else {
+      *error = "not-found";
+    }
+  }
+
+  virtual void SetEventObservers(
+      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+      const NetworkGuidListCallback& networks_changed_observer,
+      const NetworkGuidListCallback& network_list_changed_observer) OVERRIDE {
+    message_loop_proxy_.swap(message_loop_proxy);
+    networks_changed_observer_ = networks_changed_observer;
+    network_list_changed_observer_ = network_list_changed_observer;
+  }
+
+ 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(const std::string& type) {
+    for (NetworkList::iterator it = networks_.begin(); it != networks_.end();
+         ++it) {
+      if (it->type == type)
+        it->connection_state = onc::connection_state::kNotConnected;
+    }
+  }
+
+  void SortNetworks() {
+    // Sort networks, so connected/connecting is up front, then by type:
+    // Ethernet, WiFi, Cellular, VPN
+    networks_.sort(WiFiService::NetworkProperties::OrderByType);
+  }
+
+  void NotifyNetworkListChanged(const NetworkList& networks) {
+    WiFiService::NetworkGuidList current_networks;
+    for (WiFiService::NetworkList::const_iterator it = networks.begin();
+         it != networks.end();
+         ++it) {
+      current_networks.push_back(it->guid);
+    }
+
+    message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(network_list_changed_observer_, current_networks));
+  }
+
+  void NotifyNetworkChanged(const std::string& network_guid) {
+    WiFiService::NetworkGuidList changed_networks(1, network_guid);
+    message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(networks_changed_observer_, changed_networks));
+  }
+
+  NetworkList networks_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  NetworkGuidListCallback networks_changed_observer_;
+  NetworkGuidListCallback network_list_changed_observer_;
+};
+
+WiFiService* WiFiService::CreateServiceMock() { return new WiFiServiceMock(); }
+WiFiService* WiFiService::CreateService() { return new WiFiServiceMock(); }
+
+}  // namespace wifi