src/components/wifi/fake_wifi_service.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/wifi/fake_wifi_service.h"
   6
   7 #include "base/bind.h"
   8 #include "base/json/json_reader.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "components/onc/onc_constants.h"
  11
  12 namespace wifi {
  13
  14 FakeWiFiService::FakeWiFiService() {
  15   // Populate data expected by unit test.
  16   {
  17     WiFiService::NetworkProperties network_properties;
  18     network_properties.connection_state = onc::connection_state::kConnected;
  19     network_properties.guid = "stub_wifi1";
  20     network_properties.name = "wifi1";
  21     network_properties.type = onc::network_type::kWiFi;
  22     network_properties.frequency = 0;
  23     network_properties.ssid = "wifi1";
  24     network_properties.security = onc::wifi::kWEP_PSK;
  25     network_properties.signal_strength = 40;
  26     network_properties.json_extra =
  27       "{"
  28       "  \"IPConfigs\": [{"
  29       "     \"Gateway\": \"0.0.0.1\","
  30       "     \"IPAddress\": \"0.0.0.0\","
  31       "     \"RoutingPrefix\": 0,"
  32       "     \"Type\": \"IPv4\""
  33       "  }],"
  34       "  \"WiFi\": {"
  35       "    \"Frequency\": 2400,"
  36       "    \"FrequencyList\": [2400]"
  37       "  }"
  38       "}";
  39     networks_.push_back(network_properties);
  40   }
  41   {
  42     WiFiService::NetworkProperties network_properties;
  43     network_properties.connection_state = onc::connection_state::kNotConnected;
  44     network_properties.guid = "stub_wifi2";
  45     network_properties.name = "wifi2_PSK";
  46     network_properties.type = onc::network_type::kWiFi;
  47     network_properties.frequency = 5000;
  48     network_properties.frequency_set.insert(2400);
  49     network_properties.frequency_set.insert(5000);
  50     network_properties.ssid = "wifi2_PSK";
  51     network_properties.security = onc::wifi::kWPA_PSK;
  52     network_properties.signal_strength = 80;
  53     networks_.push_back(network_properties);
  54   }
  55 }
  56
  57 FakeWiFiService::~FakeWiFiService() {
  58 }
  59
  60 void FakeWiFiService::Initialize(
  61     scoped_refptr<base::SequencedTaskRunner> task_runner) {
  62 }
  63
  64 void FakeWiFiService::UnInitialize() {
  65 }
  66
  67 void FakeWiFiService::GetProperties(const std::string& network_guid,
  68                                     base::DictionaryValue* properties,
  69                                     std::string* error) {
  70   WiFiService::NetworkList::iterator network_properties =
  71       FindNetwork(network_guid);
  72   if (network_properties != networks_.end()) {
  73     properties->Swap(network_properties->ToValue(false).get());
  74   } else {
  75     *error = "Error.DBusFailed";
  76   }
  77 }
  78
  79 void FakeWiFiService::GetManagedProperties(
  80     const std::string& network_guid,
  81     base::DictionaryValue* managed_properties,
  82     std::string* error) {
  83   // Not implemented
  84   *error = kErrorWiFiService;
  85 }
  86
  87 void FakeWiFiService::GetState(const std::string& network_guid,
  88                                base::DictionaryValue* properties,
  89                                std::string* error) {
  90   WiFiService::NetworkList::iterator network_properties =
  91       FindNetwork(network_guid);
  92   if (network_properties == networks_.end()) {
  93     *error = "Error.InvalidParameter";
  94     return;
  95   }
  96   properties->Swap(network_properties->ToValue(true).get());
  97 }
  98
  99 void FakeWiFiService::SetProperties(
 100     const std::string& network_guid,
 101     scoped_ptr<base::DictionaryValue> properties,
 102     std::string* error) {
 103   WiFiService::NetworkList::iterator network_properties =
 104       FindNetwork(network_guid);
 105   if (network_properties == networks_.end() ||
 106       !network_properties->UpdateFromValue(*properties)) {
 107     *error = "Error.DBusFailed";
 108   }
 109 }
 110
 111 void FakeWiFiService::CreateNetwork(
 112     bool shared,
 113     scoped_ptr<base::DictionaryValue> properties,
 114     std::string* network_guid,
 115     std::string* error) {
 116   WiFiService::NetworkProperties network_properties;
 117   if (network_properties.UpdateFromValue(*properties)) {
 118     network_properties.guid = network_properties.ssid;
 119     networks_.push_back(network_properties);
 120     *network_guid = network_properties.guid;
 121   } else {
 122     *error = "Error.DBusFailed";
 123   }
 124 }
 125
 126 void FakeWiFiService::GetVisibleNetworks(const std::string& network_type,
 127                                          base::ListValue* network_list) {
 128   for (WiFiService::NetworkList::const_iterator it = networks_.begin();
 129        it != networks_.end();
 130        ++it) {
 131     if (network_type.empty() || network_type == onc::network_type::kAllTypes ||
 132         it->type == network_type) {
 133       scoped_ptr<base::DictionaryValue> network(it->ToValue(true));
 134       network_list->Append(network.release());
 135     }
 136   }
 137 }
 138
 139 void FakeWiFiService::RequestNetworkScan() {
 140   NotifyNetworkListChanged(networks_);
 141 }
 142
 143 void FakeWiFiService::StartConnect(const std::string& network_guid,
 144                                    std::string* error) {
 145   NetworkList::iterator network_properties = FindNetwork(network_guid);
 146   if (network_properties != networks_.end()) {
 147     DisconnectAllNetworksOfType(network_properties->type);
 148     network_properties->connection_state = onc::connection_state::kConnected;
 149     SortNetworks();
 150     NotifyNetworkListChanged(networks_);
 151     NotifyNetworkChanged(network_guid);
 152   } else {
 153     *error = "configure-failed";
 154   }
 155 }
 156
 157 void FakeWiFiService::StartDisconnect(const std::string& network_guid,
 158                                       std::string* error) {
 159   WiFiService::NetworkList::iterator network_properties =
 160       FindNetwork(network_guid);
 161   if (network_properties != networks_.end()) {
 162     network_properties->connection_state = onc::connection_state::kNotConnected;
 163     SortNetworks();
 164     NotifyNetworkListChanged(networks_);
 165     NotifyNetworkChanged(network_guid);
 166   } else {
 167     *error = "not-found";
 168   }
 169 }
 170
 171 void FakeWiFiService::GetKeyFromSystem(const std::string& network_guid,
 172                                        std::string* key_data,
 173                                        std::string* error) {
 174   *error = "not-found";
 175 }
 176
 177 void FakeWiFiService::SetEventObservers(
 178     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
 179     const NetworkGuidListCallback& networks_changed_observer,
 180     const NetworkGuidListCallback& network_list_changed_observer) {
 181   message_loop_proxy_.swap(message_loop_proxy);
 182   networks_changed_observer_ = networks_changed_observer;
 183   network_list_changed_observer_ = network_list_changed_observer;
 184 }
 185
 186 void FakeWiFiService::RequestConnectedNetworkUpdate() {
 187 }
 188
 189 WiFiService::NetworkList::iterator FakeWiFiService::FindNetwork(
 190     const std::string& network_guid) {
 191   for (WiFiService::NetworkList::iterator it = networks_.begin();
 192        it != networks_.end();
 193        ++it) {
 194     if (it->guid == network_guid)
 195       return it;
 196   }
 197   return networks_.end();
 198 }
 199
 200 void FakeWiFiService::DisconnectAllNetworksOfType(const std::string& type) {
 201   for (WiFiService::NetworkList::iterator it = networks_.begin();
 202        it != networks_.end();
 203        ++it) {
 204     if (it->type == type)
 205       it->connection_state = onc::connection_state::kNotConnected;
 206   }
 207 }
 208
 209 void FakeWiFiService::SortNetworks() {
 210   // Sort networks, so connected/connecting is up front, then by type:
 211   // Ethernet, WiFi, Cellular, VPN
 212   networks_.sort(WiFiService::NetworkProperties::OrderByType);
 213 }
 214
 215 void FakeWiFiService::NotifyNetworkListChanged(
 216     const WiFiService::NetworkList& networks) {
 217   WiFiService::NetworkGuidList current_networks;
 218   for (WiFiService::NetworkList::const_iterator it = networks.begin();
 219        it != networks.end();
 220        ++it) {
 221     current_networks.push_back(it->guid);
 222   }
 223
 224   message_loop_proxy_->PostTask(
 225       FROM_HERE, base::Bind(network_list_changed_observer_, current_networks));
 226 }
 227
 228 void FakeWiFiService::NotifyNetworkChanged(const std::string& network_guid) {
 229   WiFiService::NetworkGuidList changed_networks(1, network_guid);
 230   message_loop_proxy_->PostTask(
 231       FROM_HERE, base::Bind(networks_changed_observer_, changed_networks));
 232 }
 233
 234 }  // namespace wifi