Provide IPConfigs in networkingPrivate.GetProperties

chromeos/dbus/fake_shill_manager_client.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 "chromeos/dbus/fake_shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
+#include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
@@ skipping 513 matching lines @@
 
 
 int FakeShillManagerClient::GetInteractiveDelay() const {
   return interactive_delay_;
 }
 
 void FakeShillManagerClient::SetupDefaultEnvironment() {
   DBusThreadManager* dbus_manager = DBusThreadManager::Get();
   ShillServiceClient::TestInterface* services =
       dbus_manager->GetShillServiceClient()->GetTestInterface();
+  DCHECK(services);
   ShillProfileClient::TestInterface* profiles =
       dbus_manager->GetShillProfileClient()->GetTestInterface();
+  DCHECK(profiles);
   ShillDeviceClient::TestInterface* devices =
       dbus_manager->GetShillDeviceClient()->GetTestInterface();
-  if (!services || !profiles || !devices)
-    return;
+  DCHECK(devices);
+  ShillIPConfigClient::TestInterface* ip_configs =
+      dbus_manager->GetShillIPConfigClient()->GetTestInterface();
+  DCHECK(ip_configs);
 
   const std::string shared_profile = ShillProfileClient::GetSharedProfilePath();
   profiles->AddProfile(shared_profile, std::string());
 
   const bool add_to_visible = true;
   const bool add_to_watchlist = true;
 
   bool enabled;
   std::string state;
 
+  // IPConfigs
+  base::DictionaryValue ipconfig_v4_dictionary;
+  ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
+      shill::kAddressProperty, "0.0.0.0");
+  ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
+      shill::kGatewayProperty, "0.0.0.1");
+  ipconfig_v4_dictionary.SetIntegerWithoutPathExpansion(
+      shill::kPrefixlenProperty, 0);
+  ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
+      shill::kMethodProperty, shill::kTypeIPv4);
+  ip_configs->AddIPConfig("ipconfig_v4_path", ipconfig_v4_dictionary);
+  base::DictionaryValue ipconfig_v6_dictionary;
+  ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
+      shill::kAddressProperty, "0:0:0:0:0:0:0:0");
+  ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
+      shill::kMethodProperty, shill::kTypeIPv6);
+  ip_configs->AddIPConfig("ipconfig_v6_path", ipconfig_v6_dictionary);
+
   // Ethernet
   state = GetInitialStateForType(shill::kTypeEthernet, &enabled);
   if (state == shill::kStateOnline) {
     AddTechnology(shill::kTypeEthernet, enabled);
     devices->AddDevice(
         "/device/eth1", shill::kTypeEthernet, "stub_eth_device1");
+    base::ListValue eth_ip_configs;
+    eth_ip_configs.AppendString("ipconfig_v4_path");
+    eth_ip_configs.AppendString("ipconfig_v6_path");
+    devices->SetDeviceProperty("/device/eth1",
+                               shill::kIPConfigsProperty,
+                               eth_ip_configs);
     services->AddService("eth1", "eth1",
                          shill::kTypeEthernet,
                          state,
                          add_to_visible, add_to_watchlist);
     profiles->AddService(shared_profile, "eth1");
   }
 
   // Wifi
   state = GetInitialStateForType(shill::kTypeWifi, &enabled);
   if (state != kTechnologyUnavailable) {
@@ skipping 411 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos