Provide GUID in ONC for all networks in ManagedNetworkConfigurationHandler

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"
@@ skipping 574 matching lines @@
   DCHECK(ip_configs);
 
   const std::string shared_profile = ShillProfileClient::GetSharedProfilePath();
   profiles->AddProfile(shared_profile, std::string());
 
   const bool add_to_visible = true;
 
   // IPConfigs
   base::DictionaryValue ipconfig_v4_dictionary;
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
-      shill::kAddressProperty, "0.0.0.0");
+      shill::kAddressProperty, "100.0.0.1");
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
-      shill::kGatewayProperty, "0.0.0.1");
+      shill::kGatewayProperty, "100.0.0.2");
   ipconfig_v4_dictionary.SetIntegerWithoutPathExpansion(
       shill::kPrefixlenProperty, 1);
   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");
+      shill::kAddressProperty, "0:0:0:0:100:0:0:1");
   ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
       shill::kMethodProperty, shill::kTypeIPv6);
   ip_configs->AddIPConfig("ipconfig_v6_path", ipconfig_v6_dictionary);
 
   bool enabled;
   std::string state;
 
   // Ethernet
   state = GetInitialStateForType(shill::kTypeEthernet, &enabled);
   if (state == shill::kStateOnline) {
@@ skipping 24 matching lines @@
   if (state != kTechnologyUnavailable) {
     bool portaled = false;
     if (state == shill::kStatePortal) {
       portaled = true;
       state = shill::kStateIdle;
     }
     AddTechnology(shill::kTypeWifi, enabled);
     devices->AddDevice("/device/wifi1", shill::kTypeWifi, "stub_wifi_device1");
     devices->SetDeviceProperty("/device/wifi1",
                                shill::kAddressProperty,
-                               base::StringValue("23456789abc"));
+                               base::StringValue("23456789abcd"));
     base::ListValue wifi_ip_configs;
     wifi_ip_configs.AppendString("ipconfig_v4_path");
     wifi_ip_configs.AppendString("ipconfig_v6_path");
     devices->SetDeviceProperty("/device/wifi1",
                                shill::kIPConfigsProperty,
                                wifi_ip_configs);
 
     const std::string kWifi1Path = "/service/wifi1";
     services->AddService(kWifi1Path,
                          "wifi1_guid",
@@ skipping 12 matching lines @@
     const std::string kWifi2Path = "/service/wifi2";
     services->AddService(kWifi2Path,
                          "wifi2_PSK_guid",
                          "wifi2_PSK" /* name */,
                          shill::kTypeWifi,
                          shill::kStateIdle,
                          add_to_visible);
     services->SetServiceProperty(kWifi2Path,
                                  shill::kSecurityClassProperty,
                                  base::StringValue(shill::kSecurityPsk));
+    services->SetServiceProperty(
+        kWifi2Path, shill::kSignalStrengthProperty, base::FundamentalValue(80));
+    profiles->AddService(shared_profile, kWifi2Path);
 
-    base::FundamentalValue strength_value(80);
+    const std::string kWifi3Path = "/service/wifi3";
+    services->AddService(kWifi3Path,
+                         "",  /* empty GUID */
+                         "wifi3" /* name */,
+                         shill::kTypeWifi,
+                         shill::kStateIdle,
+                         add_to_visible);
     services->SetServiceProperty(
-        kWifi2Path, shill::kSignalStrengthProperty, strength_value);
-    profiles->AddService(shared_profile, kWifi2Path);
+        kWifi3Path, shill::kSignalStrengthProperty, base::FundamentalValue(40));
 
     if (portaled) {
       const std::string kPortaledWifiPath = "/service/portaled_wifi";
       services->AddService(kPortaledWifiPath,
                            "portaled_wifi_guid",
                            "Portaled Wifi" /* name */,
                            shill::kTypeWifi,
                            shill::kStatePortal,
                            add_to_visible);
       services->SetServiceProperty(kPortaledWifiPath,
@@ skipping 403 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