chromeos/dbus/fake_shill_manager_client.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 "chromeos/dbus/fake_shill_manager_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_split.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/values.h"
  14 #include "chromeos/chromeos_switches.h"
  15 #include "chromeos/dbus/dbus_thread_manager.h"
  16 #include "chromeos/dbus/shill_device_client.h"
  17 #include "chromeos/dbus/shill_ipconfig_client.h"
  18 #include "chromeos/dbus/shill_profile_client.h"
  19 #include "chromeos/dbus/shill_property_changed_observer.h"
  20 #include "chromeos/dbus/shill_service_client.h"
  21 #include "dbus/bus.h"
  22 #include "dbus/message.h"
  23 #include "dbus/object_path.h"
  24 #include "dbus/values_util.h"
  25 #include "third_party/cros_system_api/dbus/service_constants.h"
  26
  27 namespace chromeos {
  28
  29 namespace {
  30
  31 // Used to compare values for finding entries to erase in a ListValue.
  32 // (ListValue only implements a const_iterator version of Find).
  33 struct ValueEquals {
  34   explicit ValueEquals(const base::Value* first) : first_(first) {}
  35   bool operator()(const base::Value* second) const {
  36     return first_->Equals(second);
  37   }
  38   const base::Value* first_;
  39 };
  40
  41 // Appends string entries from |service_list_in| whose entries in ServiceClient
  42 // have Type |match_type| to one of the output lists based on the entry's State.
  43 void AppendServicesForType(
  44     const base::ListValue* service_list_in,
  45     const char* match_type,
  46     bool technology_enabled,
  47     std::vector<std::string>* active_service_list_out,
  48     std::vector<std::string>* inactive_service_list_out,
  49     std::vector<std::string>* disabled_service_list_out) {
  50   ShillServiceClient::TestInterface* service_client =
  51       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
  52   for (base::ListValue::const_iterator iter = service_list_in->begin();
  53        iter != service_list_in->end(); ++iter) {
  54     std::string service_path;
  55     if (!(*iter)->GetAsString(&service_path))
  56       continue;
  57     const base::DictionaryValue* properties =
  58         service_client->GetServiceProperties(service_path);
  59     if (!properties) {
  60       LOG(ERROR) << "Properties not found for service: " << service_path;
  61       continue;
  62     }
  63     std::string type;
  64     properties->GetString(shill::kTypeProperty, &type);
  65     if (type != match_type)
  66       continue;
  67     bool visible = false;
  68     if (technology_enabled)
  69       properties->GetBoolean(shill::kVisibleProperty, &visible);
  70     if (!visible) {
  71       disabled_service_list_out->push_back(service_path);
  72       continue;
  73     }
  74     std::string state;
  75     properties->GetString(shill::kStateProperty, &state);
  76     if (state == shill::kStateOnline ||
  77         state == shill::kStateAssociation ||
  78         state == shill::kStateConfiguration ||
  79         state == shill::kStatePortal ||
  80         state == shill::kStateReady) {
  81       active_service_list_out->push_back(service_path);
  82     } else {
  83       inactive_service_list_out->push_back(service_path);
  84     }
  85   }
  86 }
  87
  88 void LogErrorCallback(const std::string& error_name,
  89                       const std::string& error_message) {
  90   LOG(ERROR) << error_name << ": " << error_message;
  91 }
  92
  93 bool IsConnectedState(const std::string& state) {
  94   return state == shill::kStateOnline || state == shill::kStatePortal ||
  95          state == shill::kStateReady;
  96 }
  97
  98 void UpdatePortaledWifiState(const std::string& service_path) {
  99   DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
 100       ->SetServiceProperty(service_path,
 101                            shill::kStateProperty,
 102                            base::StringValue(shill::kStatePortal));
 103 }
 104
 105 const char* kTechnologyUnavailable = "unavailable";
 106 const char* kNetworkActivated = "activated";
 107 const char* kNetworkDisabled = "disabled";
 108 const char* kCellularServicePath = "/service/cellular1";
 109
 110 }  // namespace
 111
 112 // static
 113 const char FakeShillManagerClient::kFakeEthernetNetworkGuid[] = "eth1_guid";
 114
 115 FakeShillManagerClient::FakeShillManagerClient()
 116     : interactive_delay_(0),
 117       weak_ptr_factory_(this) {
 118   ParseCommandLineSwitch();
 119 }
 120
 121 FakeShillManagerClient::~FakeShillManagerClient() {}
 122
 123 // ShillManagerClient overrides.
 124
 125 void FakeShillManagerClient::Init(dbus::Bus* bus) {}
 126
 127 void FakeShillManagerClient::AddPropertyChangedObserver(
 128     ShillPropertyChangedObserver* observer) {
 129   observer_list_.AddObserver(observer);
 130 }
 131
 132 void FakeShillManagerClient::RemovePropertyChangedObserver(
 133     ShillPropertyChangedObserver* observer) {
 134   observer_list_.RemoveObserver(observer);
 135 }
 136
 137 void FakeShillManagerClient::GetProperties(
 138     const DictionaryValueCallback& callback) {
 139   DVLOG(1) << "Manager.GetProperties";
 140   base::MessageLoop::current()->PostTask(
 141       FROM_HERE, base::Bind(
 142           &FakeShillManagerClient::PassStubProperties,
 143           weak_ptr_factory_.GetWeakPtr(),
 144           callback));
 145 }
 146
 147 void FakeShillManagerClient::GetNetworksForGeolocation(
 148     const DictionaryValueCallback& callback) {
 149   base::MessageLoop::current()->PostTask(
 150       FROM_HERE, base::Bind(
 151           &FakeShillManagerClient::PassStubGeoNetworks,
 152           weak_ptr_factory_.GetWeakPtr(),
 153           callback));
 154 }
 155
 156 void FakeShillManagerClient::SetProperty(const std::string& name,
 157                                          const base::Value& value,
 158                                          const base::Closure& callback,
 159                                          const ErrorCallback& error_callback) {
 160   DVLOG(2) << "SetProperty: " << name;
 161   stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
 162   CallNotifyObserversPropertyChanged(name);
 163   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 164 }
 165
 166 void FakeShillManagerClient::RequestScan(const std::string& type,
 167                                          const base::Closure& callback,
 168                                          const ErrorCallback& error_callback) {
 169   // For Stub purposes, default to a Wifi scan.
 170   std::string device_type = shill::kTypeWifi;
 171   if (!type.empty())
 172     device_type = type;
 173   ShillDeviceClient::TestInterface* device_client =
 174       DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
 175   std::string device_path = device_client->GetDevicePathForType(device_type);
 176   if (!device_path.empty()) {
 177     device_client->SetDeviceProperty(
 178         device_path, shill::kScanningProperty, base::FundamentalValue(true));
 179   }
 180   base::MessageLoop::current()->PostDelayedTask(
 181       FROM_HERE,
 182       base::Bind(&FakeShillManagerClient::ScanCompleted,
 183                  weak_ptr_factory_.GetWeakPtr(),
 184                  device_path,
 185                  callback),
 186       base::TimeDelta::FromSeconds(interactive_delay_));
 187 }
 188
 189 void FakeShillManagerClient::EnableTechnology(
 190     const std::string& type,
 191     const base::Closure& callback,
 192     const ErrorCallback& error_callback) {
 193   base::ListValue* enabled_list = NULL;
 194   if (!stub_properties_.GetListWithoutPathExpansion(
 195           shill::kAvailableTechnologiesProperty, &enabled_list)) {
 196     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 197     base::MessageLoop::current()->PostTask(
 198         FROM_HERE,
 199         base::Bind(error_callback, "StubError", "Property not found"));
 200     return;
 201   }
 202   base::MessageLoop::current()->PostDelayedTask(
 203       FROM_HERE,
 204       base::Bind(&FakeShillManagerClient::SetTechnologyEnabled,
 205                  weak_ptr_factory_.GetWeakPtr(),
 206                  type,
 207                  callback,
 208                  true),
 209       base::TimeDelta::FromSeconds(interactive_delay_));
 210 }
 211
 212 void FakeShillManagerClient::DisableTechnology(
 213     const std::string& type,
 214     const base::Closure& callback,
 215     const ErrorCallback& error_callback) {
 216   base::ListValue* enabled_list = NULL;
 217   if (!stub_properties_.GetListWithoutPathExpansion(
 218           shill::kAvailableTechnologiesProperty, &enabled_list)) {
 219     base::MessageLoop::current()->PostTask(
 220         FROM_HERE,
 221         base::Bind(error_callback, "StubError", "Property not found"));
 222     return;
 223   }
 224   base::MessageLoop::current()->PostDelayedTask(
 225       FROM_HERE,
 226       base::Bind(&FakeShillManagerClient::SetTechnologyEnabled,
 227                  weak_ptr_factory_.GetWeakPtr(),
 228                  type,
 229                  callback,
 230                  false),
 231       base::TimeDelta::FromSeconds(interactive_delay_));
 232 }
 233
 234 void FakeShillManagerClient::ConfigureService(
 235     const base::DictionaryValue& properties,
 236     const ObjectPathCallback& callback,
 237     const ErrorCallback& error_callback) {
 238   ShillServiceClient::TestInterface* service_client =
 239       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 240
 241   std::string guid;
 242   std::string type;
 243   if (!properties.GetString(shill::kGuidProperty, &guid) ||
 244       !properties.GetString(shill::kTypeProperty, &type)) {
 245     LOG(ERROR) << "ConfigureService requires GUID and Type to be defined";
 246     // If the properties aren't filled out completely, then just return an empty
 247     // object path.
 248     base::MessageLoop::current()->PostTask(
 249         FROM_HERE, base::Bind(callback, dbus::ObjectPath()));
 250     return;
 251   }
 252
 253   // For the purposes of this stub, we're going to assume that the GUID property
 254   // is set to the service path because we don't want to re-implement Shill's
 255   // property matching magic here.
 256   std::string service_path = guid;
 257
 258   std::string ipconfig_path;
 259   properties.GetString(shill::kIPConfigProperty, &ipconfig_path);
 260
 261   // Merge the new properties with existing properties, if any.
 262   const base::DictionaryValue* existing_properties =
 263       service_client->GetServiceProperties(service_path);
 264   if (!existing_properties) {
 265     // Add a new service to the service client stub because none exists, yet.
 266     // This calls AddManagerService.
 267     service_client->AddServiceWithIPConfig(service_path,
 268                                            guid /* guid */,
 269                                            guid /* name */,
 270                                            type,
 271                                            shill::kStateIdle,
 272                                            ipconfig_path,
 273                                            true /* visible */);
 274     existing_properties = service_client->GetServiceProperties(service_path);
 275   }
 276
 277   scoped_ptr<base::DictionaryValue> merged_properties(
 278       existing_properties->DeepCopy());
 279   merged_properties->MergeDictionary(&properties);
 280
 281   // Now set all the properties.
 282   for (base::DictionaryValue::Iterator iter(*merged_properties);
 283        !iter.IsAtEnd(); iter.Advance()) {
 284     service_client->SetServiceProperty(service_path, iter.key(), iter.value());
 285   }
 286
 287   // If the Profile property is set, add it to ProfileClient.
 288   std::string profile_path;
 289   merged_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
 290                                                    &profile_path);
 291   if (!profile_path.empty()) {
 292     DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
 293         AddService(profile_path, service_path);
 294   }
 295
 296   base::MessageLoop::current()->PostTask(
 297       FROM_HERE, base::Bind(callback, dbus::ObjectPath(service_path)));
 298 }
 299
 300 void FakeShillManagerClient::ConfigureServiceForProfile(
 301     const dbus::ObjectPath& profile_path,
 302     const base::DictionaryValue& properties,
 303     const ObjectPathCallback& callback,
 304     const ErrorCallback& error_callback) {
 305   std::string profile_property;
 306   properties.GetStringWithoutPathExpansion(shill::kProfileProperty,
 307                                            &profile_property);
 308   CHECK(profile_property == profile_path.value());
 309   ConfigureService(properties, callback, error_callback);
 310 }
 311
 312
 313 void FakeShillManagerClient::GetService(
 314     const base::DictionaryValue& properties,
 315     const ObjectPathCallback& callback,
 316     const ErrorCallback& error_callback) {
 317   base::MessageLoop::current()->PostTask(
 318       FROM_HERE, base::Bind(callback, dbus::ObjectPath()));
 319 }
 320
 321 void FakeShillManagerClient::VerifyDestination(
 322     const VerificationProperties& properties,
 323     const BooleanCallback& callback,
 324     const ErrorCallback& error_callback) {
 325   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
 326 }
 327
 328 void FakeShillManagerClient::VerifyAndEncryptCredentials(
 329     const VerificationProperties& properties,
 330     const std::string& service_path,
 331     const StringCallback& callback,
 332     const ErrorCallback& error_callback) {
 333   base::MessageLoop::current()->PostTask(
 334       FROM_HERE, base::Bind(callback, "encrypted_credentials"));
 335 }
 336
 337 void FakeShillManagerClient::VerifyAndEncryptData(
 338     const VerificationProperties& properties,
 339     const std::string& data,
 340     const StringCallback& callback,
 341     const ErrorCallback& error_callback) {
 342   base::MessageLoop::current()->PostTask(
 343       FROM_HERE, base::Bind(callback, "encrypted_data"));
 344 }
 345
 346 void FakeShillManagerClient::ConnectToBestServices(
 347     const base::Closure& callback,
 348     const ErrorCallback& error_callback) {
 349   if (best_service_.empty()) {
 350     VLOG(1) << "No 'best' service set.";
 351     return;
 352   }
 353
 354   DBusThreadManager::Get()->GetShillServiceClient()->Connect(
 355       dbus::ObjectPath(best_service_), callback, error_callback);
 356 }
 357
 358 void FakeShillManagerClient::AddWakeOnPacketConnection(
 359     const net::IPEndPoint& ip_endpoint,
 360     const base::Closure& callback,
 361     const ErrorCallback& error_callback) {
 362 }
 363
 364 void FakeShillManagerClient::RemoveWakeOnPacketConnection(
 365     const net::IPEndPoint& ip_endpoint,
 366     const base::Closure& callback,
 367     const ErrorCallback& error_callback) {
 368 }
 369
 370 void FakeShillManagerClient::RemoveAllWakeOnPacketConnections(
 371     const base::Closure& callback,
 372     const ErrorCallback& error_callback) {
 373 }
 374
 375 ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() {
 376   return this;
 377 }
 378
 379 // ShillManagerClient::TestInterface overrides.
 380
 381 void FakeShillManagerClient::AddDevice(const std::string& device_path) {
 382   if (GetListProperty(shill::kDevicesProperty)
 383           ->AppendIfNotPresent(new base::StringValue(device_path))) {
 384     CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 385   }
 386 }
 387
 388 void FakeShillManagerClient::RemoveDevice(const std::string& device_path) {
 389   base::StringValue device_path_value(device_path);
 390   if (GetListProperty(shill::kDevicesProperty)->Remove(
 391       device_path_value, NULL)) {
 392     CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 393   }
 394 }
 395
 396 void FakeShillManagerClient::ClearDevices() {
 397   GetListProperty(shill::kDevicesProperty)->Clear();
 398   CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 399 }
 400
 401 void FakeShillManagerClient::AddTechnology(const std::string& type,
 402                                            bool enabled) {
 403   if (GetListProperty(shill::kAvailableTechnologiesProperty)
 404           ->AppendIfNotPresent(new base::StringValue(type))) {
 405     CallNotifyObserversPropertyChanged(
 406         shill::kAvailableTechnologiesProperty);
 407   }
 408   if (enabled &&
 409       GetListProperty(shill::kEnabledTechnologiesProperty)
 410           ->AppendIfNotPresent(new base::StringValue(type))) {
 411     CallNotifyObserversPropertyChanged(
 412         shill::kEnabledTechnologiesProperty);
 413   }
 414 }
 415
 416 void FakeShillManagerClient::RemoveTechnology(const std::string& type) {
 417   base::StringValue type_value(type);
 418   if (GetListProperty(shill::kAvailableTechnologiesProperty)->Remove(
 419       type_value, NULL)) {
 420     CallNotifyObserversPropertyChanged(
 421         shill::kAvailableTechnologiesProperty);
 422   }
 423   if (GetListProperty(shill::kEnabledTechnologiesProperty)->Remove(
 424       type_value, NULL)) {
 425     CallNotifyObserversPropertyChanged(
 426         shill::kEnabledTechnologiesProperty);
 427   }
 428 }
 429
 430 void FakeShillManagerClient::SetTechnologyInitializing(const std::string& type,
 431                                                        bool initializing) {
 432   if (initializing) {
 433     if (GetListProperty(shill::kUninitializedTechnologiesProperty)
 434             ->AppendIfNotPresent(new base::StringValue(type))) {
 435       CallNotifyObserversPropertyChanged(
 436           shill::kUninitializedTechnologiesProperty);
 437     }
 438   } else {
 439     if (GetListProperty(shill::kUninitializedTechnologiesProperty)->Remove(
 440             base::StringValue(type), NULL)) {
 441       CallNotifyObserversPropertyChanged(
 442           shill::kUninitializedTechnologiesProperty);
 443     }
 444   }
 445 }
 446
 447 void FakeShillManagerClient::AddGeoNetwork(
 448     const std::string& technology,
 449     const base::DictionaryValue& network) {
 450   base::ListValue* list_value = NULL;
 451   if (!stub_geo_networks_.GetListWithoutPathExpansion(technology,
 452                                                       &list_value)) {
 453     list_value = new base::ListValue;
 454     stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
 455   }
 456   list_value->Append(network.DeepCopy());
 457 }
 458
 459 void FakeShillManagerClient::AddProfile(const std::string& profile_path) {
 460   const char* key = shill::kProfilesProperty;
 461   if (GetListProperty(key)
 462           ->AppendIfNotPresent(new base::StringValue(profile_path))) {
 463     CallNotifyObserversPropertyChanged(key);
 464   }
 465 }
 466
 467 void FakeShillManagerClient::ClearProperties() {
 468   stub_properties_.Clear();
 469 }
 470
 471 void FakeShillManagerClient::SetManagerProperty(const std::string& key,
 472                                                 const base::Value& value) {
 473   SetProperty(key, value,
 474               base::Bind(&base::DoNothing), base::Bind(&LogErrorCallback));
 475 }
 476
 477 void FakeShillManagerClient::AddManagerService(
 478     const std::string& service_path,
 479     bool notify_observers) {
 480   DVLOG(2) << "AddManagerService: " << service_path;
 481   GetListProperty(shill::kServiceCompleteListProperty)
 482       ->AppendIfNotPresent(new base::StringValue(service_path));
 483   SortManagerServices(false);
 484   if (notify_observers)
 485     CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 486 }
 487
 488 void FakeShillManagerClient::RemoveManagerService(
 489     const std::string& service_path) {
 490   DVLOG(2) << "RemoveManagerService: " << service_path;
 491   base::StringValue service_path_value(service_path);
 492   GetListProperty(shill::kServiceCompleteListProperty)->Remove(
 493       service_path_value, NULL);
 494   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 495 }
 496
 497 void FakeShillManagerClient::ClearManagerServices() {
 498   DVLOG(1) << "ClearManagerServices";
 499   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
 500   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 501 }
 502
 503 void FakeShillManagerClient::ServiceStateChanged(
 504     const std::string& service_path,
 505     const std::string& state) {
 506   if (service_path == default_service_ && !IsConnectedState(state)) {
 507     // Default service is no longer connected; clear.
 508     default_service_.clear();
 509     base::StringValue default_service_value(default_service_);
 510     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
 511   }
 512 }
 513
 514 void FakeShillManagerClient::SortManagerServices(bool notify) {
 515   DVLOG(1) << "SortManagerServices";
 516   static const char* ordered_types[] = {shill::kTypeEthernet,
 517                                         shill::kTypeEthernetEap,
 518                                         shill::kTypeWifi,
 519                                         shill::kTypeCellular,
 520                                         shill::kTypeWimax,
 521                                         shill::kTypeVPN};
 522
 523   base::ListValue* complete_list =
 524       GetListProperty(shill::kServiceCompleteListProperty);
 525   if (complete_list->empty())
 526     return;
 527   scoped_ptr<base::ListValue> prev_complete_list(complete_list->DeepCopy());
 528
 529   std::vector<std::string> active_services;
 530   std::vector<std::string> inactive_services;
 531   std::vector<std::string> disabled_services;
 532   for (size_t i = 0; i < arraysize(ordered_types); ++i) {
 533     AppendServicesForType(complete_list,
 534                           ordered_types[i],
 535                           TechnologyEnabled(ordered_types[i]),
 536                           &active_services,
 537                           &inactive_services,
 538                           &disabled_services);
 539   }
 540   complete_list->Clear();
 541   for (size_t i = 0; i < active_services.size(); ++i)
 542     complete_list->AppendString(active_services[i]);
 543   for (size_t i = 0; i < inactive_services.size(); ++i)
 544     complete_list->AppendString(inactive_services[i]);
 545   for (size_t i = 0; i < disabled_services.size(); ++i)
 546     complete_list->AppendString(disabled_services[i]);
 547
 548   if (notify && !complete_list->Equals(prev_complete_list.get()))
 549     CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 550
 551   // Set the first active service as the Default service.
 552   std::string new_default_service;
 553   if (!active_services.empty()) {
 554     ShillServiceClient::TestInterface* service_client =
 555         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 556     std::string service_path = active_services[0];
 557     const base::DictionaryValue* properties =
 558         service_client->GetServiceProperties(service_path);
 559     if (!properties) {
 560       LOG(ERROR) << "Properties not found for service: " << service_path;
 561     } else {
 562       std::string state;
 563       properties->GetString(shill::kStateProperty, &state);
 564       if (IsConnectedState(state))
 565         new_default_service = service_path;
 566     }
 567   }
 568   if (default_service_ != new_default_service) {
 569     default_service_ = new_default_service;
 570     base::StringValue default_service_value(default_service_);
 571     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
 572   }
 573 }
 574
 575 int FakeShillManagerClient::GetInteractiveDelay() const {
 576   return interactive_delay_;
 577 }
 578
 579 void FakeShillManagerClient::SetBestServiceToConnect(
 580     const std::string& service_path) {
 581   best_service_ = service_path;
 582 }
 583
 584 void FakeShillManagerClient::SetupDefaultEnvironment() {
 585   // Bail out from setup if there is no message loop. This will be the common
 586   // case for tests that are not testing Shill.
 587   if (!base::MessageLoop::current())
 588     return;
 589
 590   DBusThreadManager* dbus_manager = DBusThreadManager::Get();
 591   ShillServiceClient::TestInterface* services =
 592       dbus_manager->GetShillServiceClient()->GetTestInterface();
 593   DCHECK(services);
 594   ShillProfileClient::TestInterface* profiles =
 595       dbus_manager->GetShillProfileClient()->GetTestInterface();
 596   DCHECK(profiles);
 597   ShillDeviceClient::TestInterface* devices =
 598       dbus_manager->GetShillDeviceClient()->GetTestInterface();
 599   DCHECK(devices);
 600   ShillIPConfigClient::TestInterface* ip_configs =
 601       dbus_manager->GetShillIPConfigClient()->GetTestInterface();
 602   DCHECK(ip_configs);
 603
 604   const std::string shared_profile = ShillProfileClient::GetSharedProfilePath();
 605   profiles->AddProfile(shared_profile, std::string());
 606
 607   const bool add_to_visible = true;
 608
 609   // IPConfigs
 610   base::DictionaryValue ipconfig_v4_dictionary;
 611   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
 612       shill::kAddressProperty, "0.0.0.0");
 613   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
 614       shill::kGatewayProperty, "0.0.0.1");
 615   ipconfig_v4_dictionary.SetIntegerWithoutPathExpansion(
 616       shill::kPrefixlenProperty, 0);
 617   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
 618       shill::kMethodProperty, shill::kTypeIPv4);
 619   ip_configs->AddIPConfig("ipconfig_v4_path", ipconfig_v4_dictionary);
 620   base::DictionaryValue ipconfig_v6_dictionary;
 621   ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
 622       shill::kAddressProperty, "0:0:0:0:0:0:0:0");
 623   ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
 624       shill::kMethodProperty, shill::kTypeIPv6);
 625   ip_configs->AddIPConfig("ipconfig_v6_path", ipconfig_v6_dictionary);
 626
 627   bool enabled;
 628   std::string state;
 629
 630   // Ethernet
 631   state = GetInitialStateForType(shill::kTypeEthernet, &enabled);
 632   if (state == shill::kStateOnline) {
 633     AddTechnology(shill::kTypeEthernet, enabled);
 634     devices->AddDevice(
 635         "/device/eth1", shill::kTypeEthernet, "stub_eth_device1");
 636     devices->SetDeviceProperty("/device/eth1",
 637                                shill::kAddressProperty,
 638                                base::StringValue("0123456789ab"));
 639     base::ListValue eth_ip_configs;
 640     eth_ip_configs.AppendString("ipconfig_v4_path");
 641     eth_ip_configs.AppendString("ipconfig_v6_path");
 642     devices->SetDeviceProperty("/device/eth1",
 643                                shill::kIPConfigsProperty,
 644                                eth_ip_configs);
 645     const std::string kFakeEthernetNetworkPath = "/service/eth1";
 646     services->AddService(kFakeEthernetNetworkPath,
 647                          kFakeEthernetNetworkGuid,
 648                          "eth1" /* name */,
 649                          shill::kTypeEthernet,
 650                          state,
 651                          add_to_visible);
 652     profiles->AddService(shared_profile, kFakeEthernetNetworkPath);
 653   }
 654
 655   // Wifi
 656   state = GetInitialStateForType(shill::kTypeWifi, &enabled);
 657   if (state != kTechnologyUnavailable) {
 658     bool portaled = false;
 659     if (state == shill::kStatePortal) {
 660       portaled = true;
 661       state = shill::kStateIdle;
 662     }
 663     AddTechnology(shill::kTypeWifi, enabled);
 664     devices->AddDevice("/device/wifi1", shill::kTypeWifi, "stub_wifi_device1");
 665     devices->SetDeviceProperty("/device/wifi1",
 666                                shill::kAddressProperty,
 667                                base::StringValue("23456789abc"));
 668     base::ListValue wifi_ip_configs;
 669     wifi_ip_configs.AppendString("ipconfig_v4_path");
 670     wifi_ip_configs.AppendString("ipconfig_v6_path");
 671     devices->SetDeviceProperty("/device/wifi1",
 672                                shill::kIPConfigsProperty,
 673                                wifi_ip_configs);
 674
 675     const std::string kWifi1Path = "/service/wifi1";
 676     services->AddService(kWifi1Path,
 677                          "wifi1_guid",
 678                          "wifi1" /* name */,
 679                          shill::kTypeWifi,
 680                          state,
 681                          add_to_visible);
 682     services->SetServiceProperty(kWifi1Path,
 683                                  shill::kSecurityProperty,
 684                                  base::StringValue(shill::kSecurityWep));
 685     services->SetServiceProperty(kWifi1Path,
 686                                  shill::kConnectableProperty,
 687                                  base::FundamentalValue(true));
 688     profiles->AddService(shared_profile, kWifi1Path);
 689
 690     const std::string kWifi2Path = "/service/wifi2";
 691     services->AddService(kWifi2Path,
 692                          "wifi2_PSK_guid",
 693                          "wifi2_PSK" /* name */,
 694                          shill::kTypeWifi,
 695                          shill::kStateIdle,
 696                          add_to_visible);
 697     services->SetServiceProperty(kWifi2Path,
 698                                  shill::kSecurityProperty,
 699                                  base::StringValue(shill::kSecurityPsk));
 700
 701     base::FundamentalValue strength_value(80);
 702     services->SetServiceProperty(
 703         kWifi2Path, shill::kSignalStrengthProperty, strength_value);
 704     profiles->AddService(shared_profile, kWifi2Path);
 705
 706     if (portaled) {
 707       const std::string kPortaledWifiPath = "/service/portaled_wifi";
 708       services->AddService(kPortaledWifiPath,
 709                            "portaled_wifi_guid",
 710                            "Portaled Wifi" /* name */,
 711                            shill::kTypeWifi,
 712                            shill::kStatePortal,
 713                            add_to_visible);
 714       services->SetServiceProperty(kPortaledWifiPath,
 715                                    shill::kSecurityProperty,
 716                                    base::StringValue(shill::kSecurityNone));
 717       services->SetConnectBehavior(kPortaledWifiPath,
 718                                    base::Bind(&UpdatePortaledWifiState,
 719                                               "portaled_wifi"));
 720       services->SetServiceProperty(kPortaledWifiPath,
 721                                    shill::kConnectableProperty,
 722                                    base::FundamentalValue(true));
 723       profiles->AddService(shared_profile, kPortaledWifiPath);
 724     }
 725   }
 726
 727   // Wimax
 728   state = GetInitialStateForType(shill::kTypeWimax, &enabled);
 729   if (state != kTechnologyUnavailable) {
 730     AddTechnology(shill::kTypeWimax, enabled);
 731     devices->AddDevice(
 732         "/device/wimax1", shill::kTypeWimax, "stub_wimax_device1");
 733
 734     services->AddService("/service/wimax1",
 735                          "wimax1_guid",
 736                          "wimax1" /* name */,
 737                          shill::kTypeWimax,
 738                          state,
 739                          add_to_visible);
 740     services->SetServiceProperty("/service/wimax1",
 741                                  shill::kConnectableProperty,
 742                                  base::FundamentalValue(true));
 743     base::FundamentalValue strength_value(80);
 744     services->SetServiceProperty(
 745         "/service/wimax1", shill::kSignalStrengthProperty, strength_value);
 746     base::StringValue identity_value("test.identity");
 747     services->SetServiceProperty(
 748         "/service/wimax1", shill::kEapIdentityProperty, identity_value);
 749   }
 750
 751   // Cellular
 752   state = GetInitialStateForType(shill::kTypeCellular, &enabled);
 753   if (state != kTechnologyUnavailable) {
 754     bool activated = false;
 755     if (state == kNetworkActivated) {
 756       activated = true;
 757       state = shill::kStateIdle;
 758     }
 759     AddTechnology(shill::kTypeCellular, enabled);
 760     devices->AddDevice(
 761         "/device/cellular1", shill::kTypeCellular, "stub_cellular_device1");
 762     devices->SetDeviceProperty("/device/cellular1",
 763                                shill::kCarrierProperty,
 764                                base::StringValue(shill::kCarrierSprint));
 765     base::ListValue carrier_list;
 766     carrier_list.AppendString(shill::kCarrierSprint);
 767     carrier_list.AppendString(shill::kCarrierGenericUMTS);
 768     devices->SetDeviceProperty("/device/cellular1",
 769                                shill::kSupportedCarriersProperty,
 770                                carrier_list);
 771
 772     services->AddService(kCellularServicePath,
 773                          "cellular1_guid",
 774                          "cellular1" /* name */,
 775                          shill::kTypeCellular,
 776                          state,
 777                          add_to_visible);
 778     base::StringValue technology_value(shill::kNetworkTechnologyGsm);
 779     services->SetServiceProperty(kCellularServicePath,
 780                                  shill::kNetworkTechnologyProperty,
 781                                  technology_value);
 782
 783     if (activated) {
 784       services->SetServiceProperty(
 785           kCellularServicePath,
 786           shill::kActivationStateProperty,
 787           base::StringValue(shill::kActivationStateActivated));
 788       services->SetServiceProperty(kCellularServicePath,
 789                                    shill::kConnectableProperty,
 790                                    base::FundamentalValue(true));
 791     } else {
 792       services->SetServiceProperty(
 793           kCellularServicePath,
 794           shill::kActivationStateProperty,
 795           base::StringValue(shill::kActivationStateNotActivated));
 796     }
 797
 798     services->SetServiceProperty(kCellularServicePath,
 799                                  shill::kRoamingStateProperty,
 800                                  base::StringValue(shill::kRoamingStateHome));
 801   }
 802
 803   // VPN
 804   state = GetInitialStateForType(shill::kTypeVPN, &enabled);
 805   if (state != kTechnologyUnavailable) {
 806     // Set the "Provider" dictionary properties. Note: when setting these in
 807     // Shill, "Provider.Type", etc keys are used, but when reading the values
 808     // "Provider" . "Type", etc keys are used. Here we are setting the values
 809     // that will be read (by the UI, tests, etc).
 810     base::DictionaryValue provider_properties_openvpn;
 811     provider_properties_openvpn.SetString(shill::kTypeProperty,
 812                                           shill::kProviderOpenVpn);
 813     provider_properties_openvpn.SetString(shill::kHostProperty, "vpn_host");
 814
 815     services->AddService("/service/vpn1",
 816                          "vpn1_guid",
 817                          "vpn1" /* name */,
 818                          shill::kTypeVPN,
 819                          state,
 820                          add_to_visible);
 821     services->SetServiceProperty(
 822         "/service/vpn1", shill::kProviderProperty, provider_properties_openvpn);
 823     profiles->AddService(shared_profile, "/service/vpn1");
 824
 825     base::DictionaryValue provider_properties_l2tp;
 826     provider_properties_l2tp.SetString(shill::kTypeProperty,
 827                                        shill::kProviderL2tpIpsec);
 828     provider_properties_l2tp.SetString(shill::kHostProperty, "vpn_host2");
 829
 830     services->AddService("/service/vpn2",
 831                          "vpn2_guid",
 832                          "vpn2" /* name */,
 833                          shill::kTypeVPN,
 834                          shill::kStateIdle,
 835                          add_to_visible);
 836     services->SetServiceProperty(
 837         "/service/vpn2", shill::kProviderProperty, provider_properties_l2tp);
 838   }
 839
 840   // Additional device states
 841   for (DevicePropertyMap::iterator iter1 = shill_device_property_map_.begin();
 842        iter1 != shill_device_property_map_.end(); ++iter1) {
 843     std::string device_type = iter1->first;
 844     std::string device_path = devices->GetDevicePathForType(device_type);
 845     for (ShillPropertyMap::iterator iter2 = iter1->second.begin();
 846          iter2 != iter1->second.end(); ++iter2) {
 847       devices->SetDeviceProperty(device_path, iter2->first, *(iter2->second));
 848       delete iter2->second;
 849     }
 850   }
 851
 852   SortManagerServices(true);
 853 }
 854
 855 // Private methods
 856
 857 void FakeShillManagerClient::PassStubProperties(
 858     const DictionaryValueCallback& callback) const {
 859   scoped_ptr<base::DictionaryValue> stub_properties(
 860       stub_properties_.DeepCopy());
 861   stub_properties->SetWithoutPathExpansion(
 862       shill::kServiceCompleteListProperty,
 863       GetEnabledServiceList(shill::kServiceCompleteListProperty));
 864   callback.Run(DBUS_METHOD_CALL_SUCCESS, *stub_properties);
 865 }
 866
 867 void FakeShillManagerClient::PassStubGeoNetworks(
 868     const DictionaryValueCallback& callback) const {
 869   callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_);
 870 }
 871
 872 void FakeShillManagerClient::CallNotifyObserversPropertyChanged(
 873     const std::string& property) {
 874   // Avoid unnecessary delayed task if we have no observers (e.g. during
 875   // initial setup).
 876   if (!observer_list_.might_have_observers())
 877     return;
 878   base::MessageLoop::current()->PostTask(
 879       FROM_HERE,
 880       base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged,
 881                  weak_ptr_factory_.GetWeakPtr(),
 882                  property));
 883 }
 884
 885 void FakeShillManagerClient::NotifyObserversPropertyChanged(
 886     const std::string& property) {
 887   DVLOG(1) << "NotifyObserversPropertyChanged: " << property;
 888   base::Value* value = NULL;
 889   if (!stub_properties_.GetWithoutPathExpansion(property, &value)) {
 890     LOG(ERROR) << "Notify for unknown property: " << property;
 891     return;
 892   }
 893   if (property == shill::kServiceCompleteListProperty) {
 894     scoped_ptr<base::ListValue> services(GetEnabledServiceList(property));
 895     FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
 896                       observer_list_,
 897                       OnPropertyChanged(property, *(services.get())));
 898     return;
 899   }
 900   FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
 901                     observer_list_,
 902                     OnPropertyChanged(property, *value));
 903 }
 904
 905 base::ListValue* FakeShillManagerClient::GetListProperty(
 906     const std::string& property) {
 907   base::ListValue* list_property = NULL;
 908   if (!stub_properties_.GetListWithoutPathExpansion(
 909       property, &list_property)) {
 910     list_property = new base::ListValue;
 911     stub_properties_.SetWithoutPathExpansion(property, list_property);
 912   }
 913   return list_property;
 914 }
 915
 916 bool FakeShillManagerClient::TechnologyEnabled(const std::string& type) const {
 917   if (type == shill::kTypeVPN)
 918     return true;  // VPN is always "enabled" since there is no associated device
 919   if (type == shill::kTypeEthernetEap)
 920     return true;
 921   bool enabled = false;
 922   const base::ListValue* technologies;
 923   if (stub_properties_.GetListWithoutPathExpansion(
 924           shill::kEnabledTechnologiesProperty, &technologies)) {
 925     base::StringValue type_value(type);
 926     if (technologies->Find(type_value) != technologies->end())
 927       enabled = true;
 928   }
 929   return enabled;
 930 }
 931
 932 void FakeShillManagerClient::SetTechnologyEnabled(
 933     const std::string& type,
 934     const base::Closure& callback,
 935     bool enabled) {
 936   base::ListValue* enabled_list =
 937       GetListProperty(shill::kEnabledTechnologiesProperty);
 938   if (enabled)
 939     enabled_list->AppendIfNotPresent(new base::StringValue(type));
 940   else
 941     enabled_list->Remove(base::StringValue(type), NULL);
 942   CallNotifyObserversPropertyChanged(
 943       shill::kEnabledTechnologiesProperty);
 944   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 945   // May affect available services.
 946   SortManagerServices(true);
 947 }
 948
 949 base::ListValue* FakeShillManagerClient::GetEnabledServiceList(
 950     const std::string& property) const {
 951   base::ListValue* new_service_list = new base::ListValue;
 952   const base::ListValue* service_list;
 953   if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) {
 954     ShillServiceClient::TestInterface* service_client =
 955         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 956     for (base::ListValue::const_iterator iter = service_list->begin();
 957          iter != service_list->end(); ++iter) {
 958       std::string service_path;
 959       if (!(*iter)->GetAsString(&service_path))
 960         continue;
 961       const base::DictionaryValue* properties =
 962           service_client->GetServiceProperties(service_path);
 963       if (!properties) {
 964         LOG(ERROR) << "Properties not found for service: " << service_path;
 965         continue;
 966       }
 967       std::string type;
 968       properties->GetString(shill::kTypeProperty, &type);
 969       if (TechnologyEnabled(type))
 970         new_service_list->Append((*iter)->DeepCopy());
 971     }
 972   }
 973   return new_service_list;
 974 }
 975
 976 void FakeShillManagerClient::ScanCompleted(const std::string& device_path,
 977                                            const base::Closure& callback) {
 978   if (!device_path.empty()) {
 979     DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
 980         SetDeviceProperty(device_path,
 981                           shill::kScanningProperty,
 982                           base::FundamentalValue(false));
 983   }
 984   DVLOG(2) << "ScanCompleted";
 985   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 986   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 987 }
 988
 989 void FakeShillManagerClient::ParseCommandLineSwitch() {
 990   // Default setup
 991   SetInitialNetworkState(shill::kTypeEthernet, shill::kStateOnline);
 992   SetInitialNetworkState(shill::kTypeWifi, shill::kStateOnline);
 993   SetInitialNetworkState(shill::kTypeCellular, shill::kStateIdle);
 994   SetInitialNetworkState(shill::kTypeVPN, shill::kStateIdle);
 995
 996   // Parse additional options
 997   CommandLine* command_line = CommandLine::ForCurrentProcess();
 998   if (!command_line->HasSwitch(switches::kShillStub))
 999     return;
1000
1001   std::string option_str =
1002       command_line->GetSwitchValueASCII(switches::kShillStub);
1003   VLOG(1) << "Parsing command line:" << option_str;
1004   base::StringPairs string_pairs;
1005   base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
1006   for (base::StringPairs::iterator iter = string_pairs.begin();
1007        iter != string_pairs.end(); ++iter) {
1008     ParseOption((*iter).first, (*iter).second);
1009   }
1010 }
1011
1012 bool FakeShillManagerClient::ParseOption(const std::string& arg0,
1013                                          const std::string& arg1) {
1014   VLOG(1) << "Parsing command line option: '" << arg0 << "=" << arg1 << "'";
1015   if ((arg0 == "clear" || arg0 == "reset") && arg1 == "1") {
1016     shill_initial_state_map_.clear();
1017     return true;
1018   } else if (arg0 == "interactive") {
1019     int seconds = 3;
1020     if (!arg1.empty())
1021       base::StringToInt(arg1, &seconds);
1022     interactive_delay_ = seconds;
1023     return true;
1024   } else if (arg0 == "sim_lock") {
1025     bool locked = (arg1 == "1") ? true : false;
1026     base::DictionaryValue* simlock_dict = new base::DictionaryValue;
1027     simlock_dict->Set(shill::kSIMLockEnabledProperty,
1028                       new base::FundamentalValue(locked));
1029   // TODO(stevenjb): Investigate why non-empty value breaks UI.
1030   std::string lock_type = "";  // shill::kSIMLockPin
1031     simlock_dict->SetString(shill::kSIMLockTypeProperty, lock_type);
1032     simlock_dict->SetInteger(shill::kSIMLockRetriesLeftProperty, 5);
1033
1034     shill_device_property_map_
1035         [shill::kTypeCellular][shill::kSIMLockStatusProperty] = simlock_dict;
1036     shill_device_property_map_
1037         [shill::kTypeCellular][shill::kTechnologyFamilyProperty] =
1038             new base::StringValue(shill::kNetworkTechnologyGsm);
1039     return true;
1040   }
1041   return SetInitialNetworkState(arg0, arg1);
1042 }
1043
1044 bool FakeShillManagerClient::SetInitialNetworkState(std::string type_arg,
1045                                                     std::string state_arg) {
1046   std::string state;
1047   state_arg = base::StringToLowerASCII(state_arg);
1048   if (state_arg.empty() || state_arg == "1" || state_arg == "on" ||
1049       state_arg == "enabled" || state_arg == "connected" ||
1050       state_arg == "online") {
1051     // Enabled and connected (default value)
1052     state = shill::kStateOnline;
1053   } else if (state_arg == "0" || state_arg == "off" ||
1054              state_arg == "inactive" || state_arg == shill::kStateIdle) {
1055     // Technology enabled, services are created but are not connected.
1056     state = shill::kStateIdle;
1057   } else if (state_arg == "disabled" || state_arg == "disconnect") {
1058     // Technology disabled but available, services created but not connected.
1059     state = kNetworkDisabled;
1060   } else if (state_arg == "none" || state_arg == "offline") {
1061     // Technology not available, do not create services.
1062     state = kTechnologyUnavailable;
1063   } else if (state_arg == "portal") {
1064     // Technology is enabled, a service is connected and in Portal state.
1065     state = shill::kStatePortal;
1066   } else if (state_arg == "active" || state_arg == "activated") {
1067     // Technology is enabled, a service is connected and Activated.
1068     state = kNetworkActivated;
1069   } else {
1070     LOG(ERROR) << "Unrecognized initial state: " << state_arg;
1071     return false;
1072   }
1073
1074   type_arg = base::StringToLowerASCII(type_arg);
1075   // Special cases
1076   if (type_arg == "wireless") {
1077     shill_initial_state_map_[shill::kTypeWifi] = state;
1078     shill_initial_state_map_[shill::kTypeCellular] = state;
1079     return true;
1080   }
1081   // Convenience synonyms.
1082   if (type_arg == "eth")
1083     type_arg = shill::kTypeEthernet;
1084
1085   if (type_arg != shill::kTypeEthernet &&
1086       type_arg != shill::kTypeWifi &&
1087       type_arg != shill::kTypeCellular &&
1088       type_arg != shill::kTypeWimax &&
1089       type_arg != shill::kTypeVPN) {
1090     LOG(WARNING) << "Unrecognized Shill network type: " << type_arg;
1091     return false;
1092   }
1093
1094   // Unconnected or disabled ethernet is the same as unavailable.
1095   if (type_arg == shill::kTypeEthernet &&
1096       (state == shill::kStateIdle || state == kNetworkDisabled)) {
1097     state = kTechnologyUnavailable;
1098   }
1099
1100   shill_initial_state_map_[type_arg] = state;
1101   return true;
1102 }
1103
1104 std::string FakeShillManagerClient::GetInitialStateForType(
1105     const std::string& type,
1106     bool* enabled) {
1107   std::map<std::string, std::string>::const_iterator iter =
1108       shill_initial_state_map_.find(type);
1109   if (iter == shill_initial_state_map_.end()) {
1110     *enabled = false;
1111     return kTechnologyUnavailable;
1112   }
1113   std::string state = iter->second;
1114   if (state == kNetworkDisabled) {
1115     *enabled = false;
1116     return shill::kStateIdle;
1117   }
1118   *enabled = true;
1119   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
1120       (state == kNetworkActivated && type != shill::kTypeCellular)) {
1121     LOG(WARNING) << "Invalid state: " << state << " for " << type;
1122     return shill::kStateIdle;
1123   }
1124   return state;
1125 }
1126
1127 }  // namespace chromeos