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.
5 #include "chromeos/dbus/fake_shill_manager_client.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"
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"
31 // Used to compare values for finding entries to erase in a ListValue.
32 // (ListValue only implements a const_iterator version of Find).
34 explicit ValueEquals(const base::Value
* first
) : first_(first
) {}
35 bool operator()(const base::Value
* second
) const {
36 return first_
->Equals(second
);
38 const base::Value
* first_
;
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
))
57 const base::DictionaryValue
* properties
=
58 service_client
->GetServiceProperties(service_path
);
60 LOG(ERROR
) << "Properties not found for service: " << service_path
;
64 properties
->GetString(shill::kTypeProperty
, &type
);
65 if (type
!= match_type
)
68 if (technology_enabled
)
69 properties
->GetBoolean(shill::kVisibleProperty
, &visible
);
71 disabled_service_list_out
->push_back(service_path
);
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
);
83 inactive_service_list_out
->push_back(service_path
);
88 void LogErrorCallback(const std::string
& error_name
,
89 const std::string
& error_message
) {
90 LOG(ERROR
) << error_name
<< ": " << error_message
;
93 bool IsConnectedState(const std::string
& state
) {
94 return state
== shill::kStateOnline
|| state
== shill::kStatePortal
||
95 state
== shill::kStateReady
;
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
));
105 const char* kTechnologyUnavailable
= "unavailable";
106 const char* kNetworkActivated
= "activated";
107 const char* kNetworkDisabled
= "disabled";
108 const char* kCellularServicePath
= "/service/cellular1";
113 const char FakeShillManagerClient::kFakeEthernetNetworkGuid
[] = "eth1_guid";
115 FakeShillManagerClient::FakeShillManagerClient()
116 : interactive_delay_(0),
117 weak_ptr_factory_(this) {
118 ParseCommandLineSwitch();
121 FakeShillManagerClient::~FakeShillManagerClient() {}
123 // ShillManagerClient overrides.
125 void FakeShillManagerClient::Init(dbus::Bus
* bus
) {}
127 void FakeShillManagerClient::AddPropertyChangedObserver(
128 ShillPropertyChangedObserver
* observer
) {
129 observer_list_
.AddObserver(observer
);
132 void FakeShillManagerClient::RemovePropertyChangedObserver(
133 ShillPropertyChangedObserver
* observer
) {
134 observer_list_
.RemoveObserver(observer
);
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(),
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(),
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
);
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
;
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));
180 base::MessageLoop::current()->PostDelayedTask(
182 base::Bind(&FakeShillManagerClient::ScanCompleted
,
183 weak_ptr_factory_
.GetWeakPtr(),
186 base::TimeDelta::FromSeconds(interactive_delay_
));
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(
199 base::Bind(error_callback
, "StubError", "Property not found"));
202 base::MessageLoop::current()->PostDelayedTask(
204 base::Bind(&FakeShillManagerClient::SetTechnologyEnabled
,
205 weak_ptr_factory_
.GetWeakPtr(),
209 base::TimeDelta::FromSeconds(interactive_delay_
));
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(
221 base::Bind(error_callback
, "StubError", "Property not found"));
224 base::MessageLoop::current()->PostDelayedTask(
226 base::Bind(&FakeShillManagerClient::SetTechnologyEnabled
,
227 weak_ptr_factory_
.GetWeakPtr(),
231 base::TimeDelta::FromSeconds(interactive_delay_
));
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();
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
248 base::MessageLoop::current()->PostTask(
249 FROM_HERE
, base::Bind(callback
, dbus::ObjectPath()));
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
;
258 std::string ipconfig_path
;
259 properties
.GetString(shill::kIPConfigProperty
, &ipconfig_path
);
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
,
274 existing_properties
= service_client
->GetServiceProperties(service_path
);
277 scoped_ptr
<base::DictionaryValue
> merged_properties(
278 existing_properties
->DeepCopy());
279 merged_properties
->MergeDictionary(&properties
);
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());
287 // If the Profile property is set, add it to ProfileClient.
288 std::string profile_path
;
289 merged_properties
->GetStringWithoutPathExpansion(shill::kProfileProperty
,
291 if (!profile_path
.empty()) {
292 DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
293 AddService(profile_path
, service_path
);
296 base::MessageLoop::current()->PostTask(
297 FROM_HERE
, base::Bind(callback
, dbus::ObjectPath(service_path
)));
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
,
308 CHECK(profile_property
== profile_path
.value());
309 ConfigureService(properties
, callback
, error_callback
);
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()));
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));
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"));
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"));
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.";
354 DBusThreadManager::Get()->GetShillServiceClient()->Connect(
355 dbus::ObjectPath(best_service_
), callback
, error_callback
);
358 ShillManagerClient::TestInterface
* FakeShillManagerClient::GetTestInterface() {
362 // ShillManagerClient::TestInterface overrides.
364 void FakeShillManagerClient::AddDevice(const std::string
& device_path
) {
365 if (GetListProperty(shill::kDevicesProperty
)
366 ->AppendIfNotPresent(new base::StringValue(device_path
))) {
367 CallNotifyObserversPropertyChanged(shill::kDevicesProperty
);
371 void FakeShillManagerClient::RemoveDevice(const std::string
& device_path
) {
372 base::StringValue
device_path_value(device_path
);
373 if (GetListProperty(shill::kDevicesProperty
)->Remove(
374 device_path_value
, NULL
)) {
375 CallNotifyObserversPropertyChanged(shill::kDevicesProperty
);
379 void FakeShillManagerClient::ClearDevices() {
380 GetListProperty(shill::kDevicesProperty
)->Clear();
381 CallNotifyObserversPropertyChanged(shill::kDevicesProperty
);
384 void FakeShillManagerClient::AddTechnology(const std::string
& type
,
386 if (GetListProperty(shill::kAvailableTechnologiesProperty
)
387 ->AppendIfNotPresent(new base::StringValue(type
))) {
388 CallNotifyObserversPropertyChanged(
389 shill::kAvailableTechnologiesProperty
);
392 GetListProperty(shill::kEnabledTechnologiesProperty
)
393 ->AppendIfNotPresent(new base::StringValue(type
))) {
394 CallNotifyObserversPropertyChanged(
395 shill::kEnabledTechnologiesProperty
);
399 void FakeShillManagerClient::RemoveTechnology(const std::string
& type
) {
400 base::StringValue
type_value(type
);
401 if (GetListProperty(shill::kAvailableTechnologiesProperty
)->Remove(
403 CallNotifyObserversPropertyChanged(
404 shill::kAvailableTechnologiesProperty
);
406 if (GetListProperty(shill::kEnabledTechnologiesProperty
)->Remove(
408 CallNotifyObserversPropertyChanged(
409 shill::kEnabledTechnologiesProperty
);
413 void FakeShillManagerClient::SetTechnologyInitializing(const std::string
& type
,
416 if (GetListProperty(shill::kUninitializedTechnologiesProperty
)
417 ->AppendIfNotPresent(new base::StringValue(type
))) {
418 CallNotifyObserversPropertyChanged(
419 shill::kUninitializedTechnologiesProperty
);
422 if (GetListProperty(shill::kUninitializedTechnologiesProperty
)->Remove(
423 base::StringValue(type
), NULL
)) {
424 CallNotifyObserversPropertyChanged(
425 shill::kUninitializedTechnologiesProperty
);
430 void FakeShillManagerClient::AddGeoNetwork(
431 const std::string
& technology
,
432 const base::DictionaryValue
& network
) {
433 base::ListValue
* list_value
= NULL
;
434 if (!stub_geo_networks_
.GetListWithoutPathExpansion(technology
,
436 list_value
= new base::ListValue
;
437 stub_geo_networks_
.SetWithoutPathExpansion(technology
, list_value
);
439 list_value
->Append(network
.DeepCopy());
442 void FakeShillManagerClient::AddProfile(const std::string
& profile_path
) {
443 const char* key
= shill::kProfilesProperty
;
444 if (GetListProperty(key
)
445 ->AppendIfNotPresent(new base::StringValue(profile_path
))) {
446 CallNotifyObserversPropertyChanged(key
);
450 void FakeShillManagerClient::ClearProperties() {
451 stub_properties_
.Clear();
454 void FakeShillManagerClient::SetManagerProperty(const std::string
& key
,
455 const base::Value
& value
) {
456 SetProperty(key
, value
,
457 base::Bind(&base::DoNothing
), base::Bind(&LogErrorCallback
));
460 void FakeShillManagerClient::AddManagerService(
461 const std::string
& service_path
,
462 bool notify_observers
) {
463 DVLOG(2) << "AddManagerService: " << service_path
;
464 GetListProperty(shill::kServiceCompleteListProperty
)
465 ->AppendIfNotPresent(new base::StringValue(service_path
));
466 SortManagerServices(false);
467 if (notify_observers
)
468 CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty
);
471 void FakeShillManagerClient::RemoveManagerService(
472 const std::string
& service_path
) {
473 DVLOG(2) << "RemoveManagerService: " << service_path
;
474 base::StringValue
service_path_value(service_path
);
475 GetListProperty(shill::kServiceCompleteListProperty
)->Remove(
476 service_path_value
, NULL
);
477 CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty
);
480 void FakeShillManagerClient::ClearManagerServices() {
481 DVLOG(1) << "ClearManagerServices";
482 GetListProperty(shill::kServiceCompleteListProperty
)->Clear();
483 CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty
);
486 void FakeShillManagerClient::ServiceStateChanged(
487 const std::string
& service_path
,
488 const std::string
& state
) {
489 if (service_path
== default_service_
&& !IsConnectedState(state
)) {
490 // Default service is no longer connected; clear.
491 default_service_
.clear();
492 base::StringValue
default_service_value(default_service_
);
493 SetManagerProperty(shill::kDefaultServiceProperty
, default_service_value
);
497 void FakeShillManagerClient::SortManagerServices(bool notify
) {
498 DVLOG(1) << "SortManagerServices";
499 static const char* ordered_types
[] = {shill::kTypeEthernet
,
500 shill::kTypeEthernetEap
,
502 shill::kTypeCellular
,
506 base::ListValue
* complete_list
=
507 GetListProperty(shill::kServiceCompleteListProperty
);
508 if (complete_list
->empty())
510 scoped_ptr
<base::ListValue
> prev_complete_list(complete_list
->DeepCopy());
512 std::vector
<std::string
> active_services
;
513 std::vector
<std::string
> inactive_services
;
514 std::vector
<std::string
> disabled_services
;
515 for (size_t i
= 0; i
< arraysize(ordered_types
); ++i
) {
516 AppendServicesForType(complete_list
,
518 TechnologyEnabled(ordered_types
[i
]),
523 complete_list
->Clear();
524 for (size_t i
= 0; i
< active_services
.size(); ++i
)
525 complete_list
->AppendString(active_services
[i
]);
526 for (size_t i
= 0; i
< inactive_services
.size(); ++i
)
527 complete_list
->AppendString(inactive_services
[i
]);
528 for (size_t i
= 0; i
< disabled_services
.size(); ++i
)
529 complete_list
->AppendString(disabled_services
[i
]);
531 if (notify
&& !complete_list
->Equals(prev_complete_list
.get()))
532 CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty
);
534 // Set the first active service as the Default service.
535 std::string new_default_service
;
536 if (!active_services
.empty()) {
537 ShillServiceClient::TestInterface
* service_client
=
538 DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
539 std::string service_path
= active_services
[0];
540 const base::DictionaryValue
* properties
=
541 service_client
->GetServiceProperties(service_path
);
543 LOG(ERROR
) << "Properties not found for service: " << service_path
;
546 properties
->GetString(shill::kStateProperty
, &state
);
547 if (IsConnectedState(state
))
548 new_default_service
= service_path
;
551 if (default_service_
!= new_default_service
) {
552 default_service_
= new_default_service
;
553 base::StringValue
default_service_value(default_service_
);
554 SetManagerProperty(shill::kDefaultServiceProperty
, default_service_value
);
558 int FakeShillManagerClient::GetInteractiveDelay() const {
559 return interactive_delay_
;
562 void FakeShillManagerClient::SetBestServiceToConnect(
563 const std::string
& service_path
) {
564 best_service_
= service_path
;
567 void FakeShillManagerClient::SetupDefaultEnvironment() {
568 // Bail out from setup if there is no message loop. This will be the common
569 // case for tests that are not testing Shill.
570 if (!base::MessageLoop::current())
573 DBusThreadManager
* dbus_manager
= DBusThreadManager::Get();
574 ShillServiceClient::TestInterface
* services
=
575 dbus_manager
->GetShillServiceClient()->GetTestInterface();
577 ShillProfileClient::TestInterface
* profiles
=
578 dbus_manager
->GetShillProfileClient()->GetTestInterface();
580 ShillDeviceClient::TestInterface
* devices
=
581 dbus_manager
->GetShillDeviceClient()->GetTestInterface();
583 ShillIPConfigClient::TestInterface
* ip_configs
=
584 dbus_manager
->GetShillIPConfigClient()->GetTestInterface();
587 const std::string shared_profile
= ShillProfileClient::GetSharedProfilePath();
588 profiles
->AddProfile(shared_profile
, std::string());
590 const bool add_to_visible
= true;
593 base::DictionaryValue ipconfig_v4_dictionary
;
594 ipconfig_v4_dictionary
.SetStringWithoutPathExpansion(
595 shill::kAddressProperty
, "0.0.0.0");
596 ipconfig_v4_dictionary
.SetStringWithoutPathExpansion(
597 shill::kGatewayProperty
, "0.0.0.1");
598 ipconfig_v4_dictionary
.SetIntegerWithoutPathExpansion(
599 shill::kPrefixlenProperty
, 0);
600 ipconfig_v4_dictionary
.SetStringWithoutPathExpansion(
601 shill::kMethodProperty
, shill::kTypeIPv4
);
602 ip_configs
->AddIPConfig("ipconfig_v4_path", ipconfig_v4_dictionary
);
603 base::DictionaryValue ipconfig_v6_dictionary
;
604 ipconfig_v6_dictionary
.SetStringWithoutPathExpansion(
605 shill::kAddressProperty
, "0:0:0:0:0:0:0:0");
606 ipconfig_v6_dictionary
.SetStringWithoutPathExpansion(
607 shill::kMethodProperty
, shill::kTypeIPv6
);
608 ip_configs
->AddIPConfig("ipconfig_v6_path", ipconfig_v6_dictionary
);
614 state
= GetInitialStateForType(shill::kTypeEthernet
, &enabled
);
615 if (state
== shill::kStateOnline
) {
616 AddTechnology(shill::kTypeEthernet
, enabled
);
618 "/device/eth1", shill::kTypeEthernet
, "stub_eth_device1");
619 devices
->SetDeviceProperty("/device/eth1",
620 shill::kAddressProperty
,
621 base::StringValue("0123456789ab"));
622 base::ListValue eth_ip_configs
;
623 eth_ip_configs
.AppendString("ipconfig_v4_path");
624 eth_ip_configs
.AppendString("ipconfig_v6_path");
625 devices
->SetDeviceProperty("/device/eth1",
626 shill::kIPConfigsProperty
,
628 const std::string kFakeEthernetNetworkPath
= "/service/eth1";
629 services
->AddService(kFakeEthernetNetworkPath
,
630 kFakeEthernetNetworkGuid
,
632 shill::kTypeEthernet
,
635 profiles
->AddService(shared_profile
, kFakeEthernetNetworkPath
);
639 state
= GetInitialStateForType(shill::kTypeWifi
, &enabled
);
640 if (state
!= kTechnologyUnavailable
) {
641 bool portaled
= false;
642 if (state
== shill::kStatePortal
) {
644 state
= shill::kStateIdle
;
646 AddTechnology(shill::kTypeWifi
, enabled
);
647 devices
->AddDevice("/device/wifi1", shill::kTypeWifi
, "stub_wifi_device1");
648 devices
->SetDeviceProperty("/device/wifi1",
649 shill::kAddressProperty
,
650 base::StringValue("23456789abc"));
651 base::ListValue wifi_ip_configs
;
652 wifi_ip_configs
.AppendString("ipconfig_v4_path");
653 wifi_ip_configs
.AppendString("ipconfig_v6_path");
654 devices
->SetDeviceProperty("/device/wifi1",
655 shill::kIPConfigsProperty
,
658 const std::string kWifi1Path
= "/service/wifi1";
659 services
->AddService(kWifi1Path
,
665 services
->SetServiceProperty(kWifi1Path
,
666 shill::kSecurityProperty
,
667 base::StringValue(shill::kSecurityWep
));
668 services
->SetServiceProperty(kWifi1Path
,
669 shill::kConnectableProperty
,
670 base::FundamentalValue(true));
671 profiles
->AddService(shared_profile
, kWifi1Path
);
673 const std::string kWifi2Path
= "/service/wifi2";
674 services
->AddService(kWifi2Path
,
676 "wifi2_PSK" /* name */,
680 services
->SetServiceProperty(kWifi2Path
,
681 shill::kSecurityProperty
,
682 base::StringValue(shill::kSecurityPsk
));
684 base::FundamentalValue
strength_value(80);
685 services
->SetServiceProperty(
686 kWifi2Path
, shill::kSignalStrengthProperty
, strength_value
);
687 profiles
->AddService(shared_profile
, kWifi2Path
);
690 const std::string kPortaledWifiPath
= "/service/portaled_wifi";
691 services
->AddService(kPortaledWifiPath
,
692 "portaled_wifi_guid",
693 "Portaled Wifi" /* name */,
697 services
->SetServiceProperty(kPortaledWifiPath
,
698 shill::kSecurityProperty
,
699 base::StringValue(shill::kSecurityNone
));
700 services
->SetConnectBehavior(kPortaledWifiPath
,
701 base::Bind(&UpdatePortaledWifiState
,
703 services
->SetServiceProperty(kPortaledWifiPath
,
704 shill::kConnectableProperty
,
705 base::FundamentalValue(true));
706 profiles
->AddService(shared_profile
, kPortaledWifiPath
);
711 state
= GetInitialStateForType(shill::kTypeWimax
, &enabled
);
712 if (state
!= kTechnologyUnavailable
) {
713 AddTechnology(shill::kTypeWimax
, enabled
);
715 "/device/wimax1", shill::kTypeWimax
, "stub_wimax_device1");
717 services
->AddService("/service/wimax1",
723 services
->SetServiceProperty("/service/wimax1",
724 shill::kConnectableProperty
,
725 base::FundamentalValue(true));
726 base::FundamentalValue
strength_value(80);
727 services
->SetServiceProperty(
728 "/service/wimax1", shill::kSignalStrengthProperty
, strength_value
);
729 base::StringValue
identity_value("test.identity");
730 services
->SetServiceProperty(
731 "/service/wimax1", shill::kEapIdentityProperty
, identity_value
);
735 state
= GetInitialStateForType(shill::kTypeCellular
, &enabled
);
736 if (state
!= kTechnologyUnavailable
) {
737 bool activated
= false;
738 if (state
== kNetworkActivated
) {
740 state
= shill::kStateIdle
;
742 AddTechnology(shill::kTypeCellular
, enabled
);
744 "/device/cellular1", shill::kTypeCellular
, "stub_cellular_device1");
745 devices
->SetDeviceProperty("/device/cellular1",
746 shill::kCarrierProperty
,
747 base::StringValue(shill::kCarrierSprint
));
748 base::ListValue carrier_list
;
749 carrier_list
.AppendString(shill::kCarrierSprint
);
750 carrier_list
.AppendString(shill::kCarrierGenericUMTS
);
751 devices
->SetDeviceProperty("/device/cellular1",
752 shill::kSupportedCarriersProperty
,
755 services
->AddService(kCellularServicePath
,
757 "cellular1" /* name */,
758 shill::kTypeCellular
,
761 base::StringValue
technology_value(shill::kNetworkTechnologyGsm
);
762 services
->SetServiceProperty(kCellularServicePath
,
763 shill::kNetworkTechnologyProperty
,
767 services
->SetServiceProperty(
768 kCellularServicePath
,
769 shill::kActivationStateProperty
,
770 base::StringValue(shill::kActivationStateActivated
));
771 services
->SetServiceProperty(kCellularServicePath
,
772 shill::kConnectableProperty
,
773 base::FundamentalValue(true));
775 services
->SetServiceProperty(
776 kCellularServicePath
,
777 shill::kActivationStateProperty
,
778 base::StringValue(shill::kActivationStateNotActivated
));
781 services
->SetServiceProperty(kCellularServicePath
,
782 shill::kRoamingStateProperty
,
783 base::StringValue(shill::kRoamingStateHome
));
787 state
= GetInitialStateForType(shill::kTypeVPN
, &enabled
);
788 if (state
!= kTechnologyUnavailable
) {
789 // Set the "Provider" dictionary properties. Note: when setting these in
790 // Shill, "Provider.Type", etc keys are used, but when reading the values
791 // "Provider" . "Type", etc keys are used. Here we are setting the values
792 // that will be read (by the UI, tests, etc).
793 base::DictionaryValue provider_properties_openvpn
;
794 provider_properties_openvpn
.SetString(shill::kTypeProperty
,
795 shill::kProviderOpenVpn
);
796 provider_properties_openvpn
.SetString(shill::kHostProperty
, "vpn_host");
798 services
->AddService("/service/vpn1",
804 services
->SetServiceProperty(
805 "/service/vpn1", shill::kProviderProperty
, provider_properties_openvpn
);
806 profiles
->AddService(shared_profile
, "/service/vpn1");
808 base::DictionaryValue provider_properties_l2tp
;
809 provider_properties_l2tp
.SetString(shill::kTypeProperty
,
810 shill::kProviderL2tpIpsec
);
811 provider_properties_l2tp
.SetString(shill::kHostProperty
, "vpn_host2");
813 services
->AddService("/service/vpn2",
819 services
->SetServiceProperty(
820 "/service/vpn2", shill::kProviderProperty
, provider_properties_l2tp
);
823 // Additional device states
824 for (DevicePropertyMap::iterator iter1
= shill_device_property_map_
.begin();
825 iter1
!= shill_device_property_map_
.end(); ++iter1
) {
826 std::string device_type
= iter1
->first
;
827 std::string device_path
= devices
->GetDevicePathForType(device_type
);
828 for (ShillPropertyMap::iterator iter2
= iter1
->second
.begin();
829 iter2
!= iter1
->second
.end(); ++iter2
) {
830 devices
->SetDeviceProperty(device_path
, iter2
->first
, *(iter2
->second
));
831 delete iter2
->second
;
835 SortManagerServices(true);
840 void FakeShillManagerClient::PassStubProperties(
841 const DictionaryValueCallback
& callback
) const {
842 scoped_ptr
<base::DictionaryValue
> stub_properties(
843 stub_properties_
.DeepCopy());
844 stub_properties
->SetWithoutPathExpansion(
845 shill::kServiceCompleteListProperty
,
846 GetEnabledServiceList(shill::kServiceCompleteListProperty
));
847 callback
.Run(DBUS_METHOD_CALL_SUCCESS
, *stub_properties
);
850 void FakeShillManagerClient::PassStubGeoNetworks(
851 const DictionaryValueCallback
& callback
) const {
852 callback
.Run(DBUS_METHOD_CALL_SUCCESS
, stub_geo_networks_
);
855 void FakeShillManagerClient::CallNotifyObserversPropertyChanged(
856 const std::string
& property
) {
857 // Avoid unnecessary delayed task if we have no observers (e.g. during
859 if (!observer_list_
.might_have_observers())
861 base::MessageLoop::current()->PostTask(
863 base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged
,
864 weak_ptr_factory_
.GetWeakPtr(),
868 void FakeShillManagerClient::NotifyObserversPropertyChanged(
869 const std::string
& property
) {
870 DVLOG(1) << "NotifyObserversPropertyChanged: " << property
;
871 base::Value
* value
= NULL
;
872 if (!stub_properties_
.GetWithoutPathExpansion(property
, &value
)) {
873 LOG(ERROR
) << "Notify for unknown property: " << property
;
876 if (property
== shill::kServiceCompleteListProperty
) {
877 scoped_ptr
<base::ListValue
> services(GetEnabledServiceList(property
));
878 FOR_EACH_OBSERVER(ShillPropertyChangedObserver
,
880 OnPropertyChanged(property
, *(services
.get())));
883 FOR_EACH_OBSERVER(ShillPropertyChangedObserver
,
885 OnPropertyChanged(property
, *value
));
888 base::ListValue
* FakeShillManagerClient::GetListProperty(
889 const std::string
& property
) {
890 base::ListValue
* list_property
= NULL
;
891 if (!stub_properties_
.GetListWithoutPathExpansion(
892 property
, &list_property
)) {
893 list_property
= new base::ListValue
;
894 stub_properties_
.SetWithoutPathExpansion(property
, list_property
);
896 return list_property
;
899 bool FakeShillManagerClient::TechnologyEnabled(const std::string
& type
) const {
900 if (type
== shill::kTypeVPN
)
901 return true; // VPN is always "enabled" since there is no associated device
902 if (type
== shill::kTypeEthernetEap
)
904 bool enabled
= false;
905 const base::ListValue
* technologies
;
906 if (stub_properties_
.GetListWithoutPathExpansion(
907 shill::kEnabledTechnologiesProperty
, &technologies
)) {
908 base::StringValue
type_value(type
);
909 if (technologies
->Find(type_value
) != technologies
->end())
915 void FakeShillManagerClient::SetTechnologyEnabled(
916 const std::string
& type
,
917 const base::Closure
& callback
,
919 base::ListValue
* enabled_list
=
920 GetListProperty(shill::kEnabledTechnologiesProperty
);
922 enabled_list
->AppendIfNotPresent(new base::StringValue(type
));
924 enabled_list
->Remove(base::StringValue(type
), NULL
);
925 CallNotifyObserversPropertyChanged(
926 shill::kEnabledTechnologiesProperty
);
927 base::MessageLoop::current()->PostTask(FROM_HERE
, callback
);
928 // May affect available services.
929 SortManagerServices(true);
932 base::ListValue
* FakeShillManagerClient::GetEnabledServiceList(
933 const std::string
& property
) const {
934 base::ListValue
* new_service_list
= new base::ListValue
;
935 const base::ListValue
* service_list
;
936 if (stub_properties_
.GetListWithoutPathExpansion(property
, &service_list
)) {
937 ShillServiceClient::TestInterface
* service_client
=
938 DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
939 for (base::ListValue::const_iterator iter
= service_list
->begin();
940 iter
!= service_list
->end(); ++iter
) {
941 std::string service_path
;
942 if (!(*iter
)->GetAsString(&service_path
))
944 const base::DictionaryValue
* properties
=
945 service_client
->GetServiceProperties(service_path
);
947 LOG(ERROR
) << "Properties not found for service: " << service_path
;
951 properties
->GetString(shill::kTypeProperty
, &type
);
952 if (TechnologyEnabled(type
))
953 new_service_list
->Append((*iter
)->DeepCopy());
956 return new_service_list
;
959 void FakeShillManagerClient::ScanCompleted(const std::string
& device_path
,
960 const base::Closure
& callback
) {
961 if (!device_path
.empty()) {
962 DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
963 SetDeviceProperty(device_path
,
964 shill::kScanningProperty
,
965 base::FundamentalValue(false));
967 DVLOG(2) << "ScanCompleted";
968 CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty
);
969 base::MessageLoop::current()->PostTask(FROM_HERE
, callback
);
972 void FakeShillManagerClient::ParseCommandLineSwitch() {
974 SetInitialNetworkState(shill::kTypeEthernet
, shill::kStateOnline
);
975 SetInitialNetworkState(shill::kTypeWifi
, shill::kStateOnline
);
976 SetInitialNetworkState(shill::kTypeCellular
, shill::kStateIdle
);
977 SetInitialNetworkState(shill::kTypeVPN
, shill::kStateIdle
);
979 // Parse additional options
980 CommandLine
* command_line
= CommandLine::ForCurrentProcess();
981 if (!command_line
->HasSwitch(switches::kShillStub
))
984 std::string option_str
=
985 command_line
->GetSwitchValueASCII(switches::kShillStub
);
986 VLOG(1) << "Parsing command line:" << option_str
;
987 base::StringPairs string_pairs
;
988 base::SplitStringIntoKeyValuePairs(option_str
, '=', ',', &string_pairs
);
989 for (base::StringPairs::iterator iter
= string_pairs
.begin();
990 iter
!= string_pairs
.end(); ++iter
) {
991 ParseOption((*iter
).first
, (*iter
).second
);
995 bool FakeShillManagerClient::ParseOption(const std::string
& arg0
,
996 const std::string
& arg1
) {
997 VLOG(1) << "Parsing command line option: '" << arg0
<< "=" << arg1
<< "'";
998 if ((arg0
== "clear" || arg0
== "reset") && arg1
== "1") {
999 shill_initial_state_map_
.clear();
1001 } else if (arg0
== "interactive") {
1004 base::StringToInt(arg1
, &seconds
);
1005 interactive_delay_
= seconds
;
1007 } else if (arg0
== "sim_lock") {
1008 bool locked
= (arg1
== "1") ? true : false;
1009 base::DictionaryValue
* simlock_dict
= new base::DictionaryValue
;
1010 simlock_dict
->Set(shill::kSIMLockEnabledProperty
,
1011 new base::FundamentalValue(locked
));
1012 // TODO(stevenjb): Investigate why non-empty value breaks UI.
1013 std::string lock_type
= ""; // shill::kSIMLockPin
1014 simlock_dict
->SetString(shill::kSIMLockTypeProperty
, lock_type
);
1015 simlock_dict
->SetInteger(shill::kSIMLockRetriesLeftProperty
, 5);
1017 shill_device_property_map_
1018 [shill::kTypeCellular
][shill::kSIMLockStatusProperty
] = simlock_dict
;
1019 shill_device_property_map_
1020 [shill::kTypeCellular
][shill::kTechnologyFamilyProperty
] =
1021 new base::StringValue(shill::kNetworkTechnologyGsm
);
1024 return SetInitialNetworkState(arg0
, arg1
);
1027 bool FakeShillManagerClient::SetInitialNetworkState(std::string type_arg
,
1028 std::string state_arg
) {
1030 state_arg
= base::StringToLowerASCII(state_arg
);
1031 if (state_arg
.empty() || state_arg
== "1" || state_arg
== "on" ||
1032 state_arg
== "enabled" || state_arg
== "connected" ||
1033 state_arg
== "online") {
1034 // Enabled and connected (default value)
1035 state
= shill::kStateOnline
;
1036 } else if (state_arg
== "0" || state_arg
== "off" ||
1037 state_arg
== "inactive" || state_arg
== shill::kStateIdle
) {
1038 // Technology enabled, services are created but are not connected.
1039 state
= shill::kStateIdle
;
1040 } else if (state_arg
== "disabled" || state_arg
== "disconnect") {
1041 // Technology disabled but available, services created but not connected.
1042 state
= kNetworkDisabled
;
1043 } else if (state_arg
== "none" || state_arg
== "offline") {
1044 // Technology not available, do not create services.
1045 state
= kTechnologyUnavailable
;
1046 } else if (state_arg
== "portal") {
1047 // Technology is enabled, a service is connected and in Portal state.
1048 state
= shill::kStatePortal
;
1049 } else if (state_arg
== "active" || state_arg
== "activated") {
1050 // Technology is enabled, a service is connected and Activated.
1051 state
= kNetworkActivated
;
1053 LOG(ERROR
) << "Unrecognized initial state: " << state_arg
;
1057 type_arg
= base::StringToLowerASCII(type_arg
);
1059 if (type_arg
== "wireless") {
1060 shill_initial_state_map_
[shill::kTypeWifi
] = state
;
1061 shill_initial_state_map_
[shill::kTypeCellular
] = state
;
1064 // Convenience synonyms.
1065 if (type_arg
== "eth")
1066 type_arg
= shill::kTypeEthernet
;
1068 if (type_arg
!= shill::kTypeEthernet
&&
1069 type_arg
!= shill::kTypeWifi
&&
1070 type_arg
!= shill::kTypeCellular
&&
1071 type_arg
!= shill::kTypeWimax
&&
1072 type_arg
!= shill::kTypeVPN
) {
1073 LOG(WARNING
) << "Unrecognized Shill network type: " << type_arg
;
1077 // Unconnected or disabled ethernet is the same as unavailable.
1078 if (type_arg
== shill::kTypeEthernet
&&
1079 (state
== shill::kStateIdle
|| state
== kNetworkDisabled
)) {
1080 state
= kTechnologyUnavailable
;
1083 shill_initial_state_map_
[type_arg
] = state
;
1087 std::string
FakeShillManagerClient::GetInitialStateForType(
1088 const std::string
& type
,
1090 std::map
<std::string
, std::string
>::const_iterator iter
=
1091 shill_initial_state_map_
.find(type
);
1092 if (iter
== shill_initial_state_map_
.end()) {
1094 return kTechnologyUnavailable
;
1096 std::string state
= iter
->second
;
1097 if (state
== kNetworkDisabled
) {
1099 return shill::kStateIdle
;
1102 if ((state
== shill::kStatePortal
&& type
!= shill::kTypeWifi
) ||
1103 (state
== kNetworkActivated
&& type
!= shill::kTypeCellular
)) {
1104 LOG(WARNING
) << "Invalid state: " << state
<< " for " << type
;
1105 return shill::kStateIdle
;
1110 } // namespace chromeos