This source file includes following definitions.
- Initialize
- UnInitialize
- GetProperties
- GetManagedProperties
- GetState
- SetProperties
- CreateNetwork
- GetVisibleNetworks
- RequestNetworkScan
- StartConnect
- StartDisconnect
- GetKeyFromSystem
- SetEventObservers
- RequestConnectedNetworkUpdate
- FindNetwork
- DisconnectAllNetworksOfType
- SortNetworks
- NotifyNetworkListChanged
- NotifyNetworkChanged
- CreateForTest
#include "components/wifi/wifi_service.h"
#include "base/bind.h"
#include "base/json/json_reader.h"
#include "base/message_loop/message_loop.h"
#include "components/onc/onc_constants.h"
namespace wifi {
class FakeWiFiService : public WiFiService {
public:
FakeWiFiService() {
{
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_set.insert(2400);
network_properties.frequency_set.insert(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 Initialize(
scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE {}
virtual void UnInitialize() OVERRIDE {}
virtual void GetProperties(const std::string& network_guid,
base::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 GetManagedProperties(const std::string& network_guid,
base::DictionaryValue* managed_properties,
std::string* error) OVERRIDE {
const std::string network_properties =
"{"
" \"ConnectionState\": {"
" \"Active\": \"NotConnected\","
" \"Effective\": \"Unmanaged\""
" },"
" \"GUID\": \"stub_wifi2\","
" \"Name\": {"
" \"Active\": \"wifi2_PSK\","
" \"Effective\": \"UserPolicy\","
" \"UserPolicy\": \"My WiFi Network\""
" },"
" \"Type\": {"
" \"Active\": \"WiFi\","
" \"Effective\": \"UserPolicy\","
" \"UserPolicy\": \"WiFi\""
" },"
" \"WiFi\": {"
" \"AutoConnect\": {"
" \"Active\": false,"
" \"UserEditable\": true"
" },"
" \"Frequency\" : {"
" \"Active\": 5000,"
" \"Effective\": \"Unmanaged\""
" },"
" \"FrequencyList\" : {"
" \"Active\": [2400, 5000],"
" \"Effective\": \"Unmanaged\""
" },"
" \"Passphrase\": {"
" \"Effective\": \"UserSetting\","
" \"UserEditable\": true,"
" \"UserSetting\": \"FAKE_CREDENTIAL_VPaJDV9x\""
" },"
" \"SSID\": {"
" \"Active\": \"wifi2_PSK\","
" \"Effective\": \"UserPolicy\","
" \"UserPolicy\": \"wifi2_PSK\""
" },"
" \"Security\": {"
" \"Active\": \"WPA-PSK\","
" \"Effective\": \"UserPolicy\","
" \"UserPolicy\": \"WPA-PSK\""
" },"
" \"SignalStrength\": {"
" \"Active\": 80,"
" \"Effective\": \"Unmanaged\""
" }"
" }"
"}";
scoped_ptr<base::DictionaryValue> properties_value(
reinterpret_cast<base::DictionaryValue*>(
base::JSONReader::Read(network_properties)));
managed_properties->MergeDictionary(properties_value.get());
}
virtual void GetState(const std::string& network_guid,
base::DictionaryValue* properties,
std::string* error) OVERRIDE {
NetworkList::iterator network_properties = FindNetwork(network_guid);
if (network_properties == networks_.end()) {
*error = "Error.InvalidParameter";
return;
}
const std::string network_state =
"{"
" \"ConnectionState\": \"NotConnected\","
" \"GUID\": \"stub_wifi2\","
" \"Name\": \"wifi2_PSK\","
" \"Type\": \"WiFi\","
" \"WiFi\": {"
" \"Security\": \"WPA-PSK\","
" \"SignalStrength\": 80"
" }"
"}";
scoped_ptr<base::DictionaryValue> properties_value(
reinterpret_cast<base::DictionaryValue*>(
base::JSONReader::Read(network_state)));
properties->MergeDictionary(properties_value.get());
}
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 CreateNetwork(bool shared,
scoped_ptr<base::DictionaryValue> properties,
std::string* network_guid,
std::string* error) OVERRIDE {
WiFiService::NetworkProperties network_properties;
if (network_properties.UpdateFromValue(*properties)) {
network_properties.guid = network_properties.ssid;
networks_.push_back(network_properties);
*network_guid = network_properties.guid;
} else {
*error = "Error.DBusFailed";
}
}
virtual void GetVisibleNetworks(const std::string& network_type,
base::ListValue* network_list) OVERRIDE {
for (WiFiService::NetworkList::const_iterator it = networks_.begin();
it != networks_.end();
++it) {
if (network_type.empty() ||
network_type == onc::network_type::kAllTypes ||
it->type == network_type) {
scoped_ptr<base::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 GetKeyFromSystem(const std::string& network_guid,
std::string* key_data,
std::string* error) OVERRIDE {
*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;
}
virtual void RequestConnectedNetworkUpdate() OVERRIDE { }
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() {
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::CreateForTest() { return new FakeWiFiService(); }
}