Provide IPConfigs in networkingPrivate.GetProperties

components/wifi/fake_wifi_service.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 "components/wifi/fake_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 {
 
 FakeWiFiService::FakeWiFiService() {
   // Populate 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.ssid = "wifi1";
     network_properties.security = onc::wifi::kWEP_PSK;
-    network_properties.signal_strength = 0;
+    network_properties.signal_strength = 40;
+    network_properties.json_extra =
+      "{"
+      "  \"IPConfigs\": [{"
+      "     \"Gateway\": \"0.0.0.1\","
+      "     \"IPAddress\": \"0.0.0.0\","
+      "     \"RoutingPrefix\": 0,"
+      "     \"Type\": \"IPv4\""
+      "  }],"
+      "  \"WiFi\": {"
+      "    \"Frequency\": 2400,"
+      "    \"FrequencyList\": [2400]"
+      "  }"
+      "}";
     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 =
-        "    {"
-        "      \"ActivationState\": \"not-activated\","
-        "      \"NetworkTechnology\": \"GSM\","
-        "      \"RoamingState\": \"home\""
-        "    }";
-    networks_.push_back(network_properties);
-  }
 }
 
 FakeWiFiService::~FakeWiFiService() {
 }
 
 void FakeWiFiService::Initialize(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
 }
 
 void FakeWiFiService::UnInitialize() {
 }
 
 void FakeWiFiService::GetProperties(const std::string& network_guid,
                                     base::DictionaryValue* properties,
                                     std::string* error) {
   WiFiService::NetworkList::iterator network_properties =
       FindNetwork(network_guid);
   if (network_properties != networks_.end()) {
     properties->Swap(network_properties->ToValue(false).get());
   } else {
     *error = "Error.DBusFailed";
   }
 }
 
 void FakeWiFiService::GetManagedProperties(
     const std::string& network_guid,
     base::DictionaryValue* managed_properties,
     std::string* error) {
-  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());
+  // Not implemented
+  *error = kErrorWiFiService;
 }
 
 void FakeWiFiService::GetState(const std::string& network_guid,
                                base::DictionaryValue* properties,
                                std::string* error) {
   WiFiService::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());
+  properties->Swap(network_properties->ToValue(true).get());
 }
 
 void FakeWiFiService::SetProperties(
     const std::string& network_guid,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* error) {
   WiFiService::NetworkList::iterator network_properties =
       FindNetwork(network_guid);
   if (network_properties == networks_.end() ||
       !network_properties->UpdateFromValue(*properties)) {
@@ skipping 118 matching lines @@
       FROM_HERE, base::Bind(network_list_changed_observer_, current_networks));
 }
 
 void FakeWiFiService::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));
 }
 
 }  // namespace wifi