Implement md-settings network lists.

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/strings/stringprintf.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 {
 
 namespace {
 
 // Allow parsed command line option 'tdls_busy' to set the fake busy count.
 int s_tdls_busy_count = 0;
+int s_extra_wifi_networks = 0;
 
 // Used to compare values for finding entries to erase in a ListValue.
 // (ListValue only implements a const_iterator version of Find).
 struct ValueEquals {
   explicit ValueEquals(const base::Value* first) : first_(first) {}
   bool operator()(const base::Value* second) const {
     return first_->Equals(second);
   }
   const base::Value* first_;
 };
@@ skipping 685 matching lines @@
                                    shill::kSecurityClassProperty,
                                    base::StringValue(shill::kSecurityNone));
       services->SetConnectBehavior(
           kPortaledWifiPath,
           base::Bind(&UpdatePortaledWifiState, kPortaledWifiPath));
       services->SetServiceProperty(kPortaledWifiPath,
                                    shill::kConnectableProperty,
                                    base::FundamentalValue(true));
       profiles->AddService(shared_profile, kPortaledWifiPath);
     }
+
+    for (int i = 0; i < s_extra_wifi_networks; ++i) {
+      int id = 4 + i;
+      std::string path = base::StringPrintf("/service/wifi%d", id);
+      std::string guid = base::StringPrintf("wifi%d_guid", id);
+      std::string name = base::StringPrintf("wifi%d", id);
+      services->AddService(path, guid, name, shill::kTypeWifi,
+                           shill::kStateIdle, add_to_visible);
+    }
   }
 
   // Wimax
   const std::string kWimaxPath = "/service/wimax1";
   state = GetInitialStateForType(shill::kTypeWimax, &enabled);
   if (state != kTechnologyUnavailable) {
     AddTechnology(shill::kTypeWimax, enabled);
     devices->AddDevice(
         "/device/wimax1", shill::kTypeWimax, "stub_wimax_device1");
 
@@ skipping 323 matching lines @@
   } else if (arg0 == "roaming") {
     // "home", "roaming", or "required"
     roaming_state_ = arg1;
     return true;
   }
   return SetInitialNetworkState(arg0, arg1);
 }
 
 bool FakeShillManagerClient::SetInitialNetworkState(std::string type_arg,
                                                     std::string state_arg) {
+  int state_arg_as_int = -1;
+  base::StringToInt(state_arg, &state_arg_as_int);
+
   std::string state;
   if (state_arg.empty() || state_arg == "1" || state_arg == "on" ||
       state_arg == "enabled" || state_arg == "connected" ||
       state_arg == "online") {
     // Enabled and connected (default value)
     state = shill::kStateOnline;
   } else if (state_arg == "0" || state_arg == "off" ||
              state_arg == "inactive" || state_arg == shill::kStateIdle) {
     // Technology enabled, services are created but are not connected.
     state = shill::kStateIdle;
+  } else if (type_arg == shill::kTypeWifi && state_arg_as_int > 1) {
+    // Enabled and connected, add extra wifi networks.
+    state = shill::kStateOnline;
+    s_extra_wifi_networks = state_arg_as_int - 1;
   } else if (state_arg == "disabled" || state_arg == "disconnect") {
     // Technology disabled but available, services created but not connected.
     state = kNetworkDisabled;
   } else if (state_arg == "none" || state_arg == "offline") {
     // Technology not available, do not create services.
     state = kTechnologyUnavailable;
   } else if (state_arg == "portal") {
     // Technology is enabled, a service is connected and in Portal state.
     state = shill::kStatePortal;
   } else if (state_arg == "active" || state_arg == "activated") {
@@ skipping 59 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