Index: chromeos/dbus/fake_shill_manager_client.cc |
diff --git a/chromeos/dbus/fake_shill_manager_client.cc b/chromeos/dbus/fake_shill_manager_client.cc |
index faab3d559c3f10d793128952cedbdca44d82a54e..95486b5d7d141d11722f7e06d99a037a51be55b6 100644 |
--- a/chromeos/dbus/fake_shill_manager_client.cc |
+++ b/chromeos/dbus/fake_shill_manager_client.cc |
@@ -1,104 +1,636 @@ |
-// Copyright (c) 2013 The Chromium Authors. All rights reserved. |
+// 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/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_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 { |
-FakeShillManagerClient::FakeShillManagerClient() { |
-} |
+namespace { |
-FakeShillManagerClient::~FakeShillManagerClient() { |
-} |
+// 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_; |
+}; |
-void FakeShillManagerClient::Init(dbus::Bus* bus) { |
+// Appends string entries from |service_list_in| whose entries in ServiceClient |
+// have Type |match_type| to either an active list or an inactive list |
+// based on the entry's State. |
+void AppendServicesForType( |
+ const base::ListValue* service_list_in, |
+ const char* match_type, |
+ std::vector<std::string>* active_service_list_out, |
+ std::vector<std::string>* inactive_service_list_out) { |
+ ShillServiceClient::TestInterface* service_client = |
+ DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); |
+ for (base::ListValue::const_iterator iter = service_list_in->begin(); |
+ iter != service_list_in->end(); ++iter) { |
+ std::string service_path; |
+ if (!(*iter)->GetAsString(&service_path)) |
+ continue; |
+ const base::DictionaryValue* properties = |
+ service_client->GetServiceProperties(service_path); |
+ if (!properties) { |
+ LOG(ERROR) << "Properties not found for service: " << service_path; |
+ continue; |
+ } |
+ std::string type; |
+ properties->GetString(shill::kTypeProperty, &type); |
+ if (type != match_type) |
+ continue; |
+ std::string state; |
+ properties->GetString(shill::kStateProperty, &state); |
+ if (state == shill::kStateOnline || |
+ state == shill::kStateAssociation || |
+ state == shill::kStateConfiguration || |
+ state == shill::kStatePortal || |
+ state == shill::kStateReady) { |
+ active_service_list_out->push_back(service_path); |
+ } else { |
+ inactive_service_list_out->push_back(service_path); |
+ } |
+ } |
} |
-void FakeShillManagerClient::RequestScan(const std::string& type, |
- const base::Closure& callback, |
- const ErrorCallback& error_callback) { |
-} |
+} // namespace |
-ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() { |
- return NULL; |
+FakeShillManagerClient::FakeShillManagerClient() |
+ : weak_ptr_factory_(this) { |
} |
-void FakeShillManagerClient::GetNetworksForGeolocation( |
- const DictionaryValueCallback& callback) { |
-} |
+FakeShillManagerClient::~FakeShillManagerClient() {} |
-void FakeShillManagerClient::ConnectToBestServices( |
- const base::Closure& callback, |
- const ErrorCallback& error_callback) { |
-} |
+// ShillManagerClient overrides. |
-void FakeShillManagerClient::RemovePropertyChangedObserver( |
- ShillPropertyChangedObserver* observer) { |
-} |
+void FakeShillManagerClient::Init(dbus::Bus* bus) {} |
-void FakeShillManagerClient::VerifyAndEncryptData( |
- const VerificationProperties& properties, |
- const std::string& data, |
- const StringCallback& callback, |
- const ErrorCallback& error_callback) { |
+void FakeShillManagerClient::AddPropertyChangedObserver( |
+ ShillPropertyChangedObserver* observer) { |
+ observer_list_.AddObserver(observer); |
} |
-void FakeShillManagerClient::GetService(const base::DictionaryValue& properties, |
- const ObjectPathCallback& callback, |
- const ErrorCallback& error_callback) { |
+void FakeShillManagerClient::RemovePropertyChangedObserver( |
+ ShillPropertyChangedObserver* observer) { |
+ observer_list_.RemoveObserver(observer); |
} |
-void FakeShillManagerClient::AddPropertyChangedObserver( |
- ShillPropertyChangedObserver* observer) { |
+void FakeShillManagerClient::GetProperties( |
+ const DictionaryValueCallback& callback) { |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind( |
+ &FakeShillManagerClient::PassStubProperties, |
+ weak_ptr_factory_.GetWeakPtr(), |
+ callback)); |
} |
-void FakeShillManagerClient::DisableTechnology( |
- const std::string& type, |
- const base::Closure& callback, |
- const ErrorCallback& error_callback) { |
+void FakeShillManagerClient::GetNetworksForGeolocation( |
+ const DictionaryValueCallback& callback) { |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind( |
+ &FakeShillManagerClient::PassStubGeoNetworks, |
+ weak_ptr_factory_.GetWeakPtr(), |
+ callback)); |
} |
void FakeShillManagerClient::SetProperty(const std::string& name, |
const base::Value& value, |
const base::Closure& callback, |
const ErrorCallback& error_callback) { |
+ stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy()); |
+ CallNotifyObserversPropertyChanged(name, 0); |
+ base::MessageLoop::current()->PostTask(FROM_HERE, callback); |
} |
-void FakeShillManagerClient::GetProperties( |
- const DictionaryValueCallback& callback) { |
+void FakeShillManagerClient::RequestScan(const std::string& type, |
+ const base::Closure& callback, |
+ const ErrorCallback& error_callback) { |
+ // For Stub purposes, default to a Wifi scan. |
+ std::string device_type = shill::kTypeWifi; |
+ if (!type.empty()) |
+ device_type = type; |
+ ShillDeviceClient::TestInterface* device_client = |
+ DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface(); |
+ std::string device_path = device_client->GetDevicePathForType(device_type); |
+ if (!device_path.empty()) { |
+ device_client->SetDeviceProperty(device_path, |
+ shill::kScanningProperty, |
+ base::FundamentalValue(true)); |
+ } |
+ const int kScanDurationSeconds = 3; |
+ int scan_duration_seconds = kScanDurationSeconds; |
+ if (!CommandLine::ForCurrentProcess()->HasSwitch( |
+ chromeos::switches::kEnableStubInteractive)) { |
+ scan_duration_seconds = 0; |
+ } |
+ base::MessageLoop::current()->PostDelayedTask( |
+ FROM_HERE, |
+ base::Bind(&FakeShillManagerClient::ScanCompleted, |
+ weak_ptr_factory_.GetWeakPtr(), device_path, callback), |
+ base::TimeDelta::FromSeconds(scan_duration_seconds)); |
} |
-void FakeShillManagerClient::VerifyAndEncryptCredentials( |
- const VerificationProperties& properties, |
- const std::string& service_path, |
- const StringCallback& callback, |
+void FakeShillManagerClient::EnableTechnology( |
+ const std::string& type, |
+ const base::Closure& callback, |
const ErrorCallback& error_callback) { |
+ base::ListValue* enabled_list = NULL; |
+ if (!stub_properties_.GetListWithoutPathExpansion( |
+ shill::kEnabledTechnologiesProperty, &enabled_list)) { |
+ base::MessageLoop::current()->PostTask(FROM_HERE, callback); |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, |
+ base::Bind(error_callback, "StubError", "Property not found")); |
+ return; |
+ } |
+ if (CommandLine::ForCurrentProcess()->HasSwitch( |
+ chromeos::switches::kEnableStubInteractive)) { |
+ const int kEnableTechnologyDelaySeconds = 3; |
+ base::MessageLoop::current()->PostDelayedTask( |
+ FROM_HERE, |
+ base::Bind(&FakeShillManagerClient::SetTechnologyEnabled, |
+ weak_ptr_factory_.GetWeakPtr(), type, callback, true), |
+ base::TimeDelta::FromSeconds(kEnableTechnologyDelaySeconds)); |
+ } else { |
+ SetTechnologyEnabled(type, callback, true); |
+ } |
} |
-void FakeShillManagerClient::EnableTechnology( |
+void FakeShillManagerClient::DisableTechnology( |
const std::string& type, |
const base::Closure& callback, |
const ErrorCallback& error_callback) { |
+ base::ListValue* enabled_list = NULL; |
+ if (!stub_properties_.GetListWithoutPathExpansion( |
+ shill::kEnabledTechnologiesProperty, &enabled_list)) { |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, |
+ base::Bind(error_callback, "StubError", "Property not found")); |
+ return; |
+ } |
+ if (CommandLine::ForCurrentProcess()->HasSwitch( |
+ chromeos::switches::kEnableStubInteractive)) { |
+ const int kDisableTechnologyDelaySeconds = 3; |
+ base::MessageLoop::current()->PostDelayedTask( |
+ FROM_HERE, |
+ base::Bind(&FakeShillManagerClient::SetTechnologyEnabled, |
+ weak_ptr_factory_.GetWeakPtr(), type, callback, false), |
+ base::TimeDelta::FromSeconds(kDisableTechnologyDelaySeconds)); |
+ } else { |
+ SetTechnologyEnabled(type, callback, false); |
+ } |
} |
void FakeShillManagerClient::ConfigureService( |
const base::DictionaryValue& properties, |
const ObjectPathCallback& callback, |
const ErrorCallback& error_callback) { |
+ ShillServiceClient::TestInterface* service_client = |
+ DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); |
+ |
+ std::string guid; |
+ std::string type; |
+ if (!properties.GetString(shill::kGuidProperty, &guid) || |
+ !properties.GetString(shill::kTypeProperty, &type)) { |
+ LOG(ERROR) << "ConfigureService requies GUID and Type to be defined"; |
+ // If the properties aren't filled out completely, then just return an empty |
+ // object path. |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind(callback, dbus::ObjectPath())); |
+ return; |
+ } |
+ |
+ // For the purposes of this stub, we're going to assume that the GUID property |
+ // is set to the service path because we don't want to re-implement Shill's |
+ // property matching magic here. |
+ std::string service_path = guid; |
+ |
+ std::string ipconfig_path; |
+ properties.GetString(shill::kIPConfigProperty, &ipconfig_path); |
+ |
+ // Merge the new properties with existing properties, if any. |
+ const base::DictionaryValue* existing_properties = |
+ service_client->GetServiceProperties(service_path); |
+ if (!existing_properties) { |
+ // Add a new service to the service client stub because none exists, yet. |
+ // This calls AddManagerService. |
+ service_client->AddServiceWithIPConfig(service_path, guid, type, |
+ shill::kStateIdle, ipconfig_path, |
+ true /* visible */, |
+ true /* watch */); |
+ existing_properties = service_client->GetServiceProperties(service_path); |
+ } |
+ |
+ scoped_ptr<base::DictionaryValue> merged_properties( |
+ existing_properties->DeepCopy()); |
+ merged_properties->MergeDictionary(&properties); |
+ |
+ // Now set all the properties. |
+ for (base::DictionaryValue::Iterator iter(*merged_properties); |
+ !iter.IsAtEnd(); iter.Advance()) { |
+ service_client->SetServiceProperty(service_path, iter.key(), iter.value()); |
+ } |
+ |
+ // If the Profile property is set, add it to ProfileClient. |
+ std::string profile_path; |
+ merged_properties->GetStringWithoutPathExpansion(shill::kProfileProperty, |
+ &profile_path); |
+ if (!profile_path.empty()) { |
+ DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()-> |
+ AddService(profile_path, service_path); |
+ } |
+ |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind(callback, dbus::ObjectPath(service_path))); |
+} |
+ |
+void FakeShillManagerClient::ConfigureServiceForProfile( |
+ const dbus::ObjectPath& profile_path, |
+ const base::DictionaryValue& properties, |
+ const ObjectPathCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ std::string profile_property; |
+ properties.GetStringWithoutPathExpansion(shill::kProfileProperty, |
+ &profile_property); |
+ CHECK(profile_property == profile_path.value()); |
+ ConfigureService(properties, callback, error_callback); |
+} |
+ |
+ |
+void FakeShillManagerClient::GetService( |
+ const base::DictionaryValue& properties, |
+ const ObjectPathCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind(callback, dbus::ObjectPath())); |
} |
void FakeShillManagerClient::VerifyDestination( |
const VerificationProperties& properties, |
const BooleanCallback& callback, |
const ErrorCallback& error_callback) { |
+ base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true)); |
} |
-void FakeShillManagerClient::ConfigureServiceForProfile( |
- const dbus::ObjectPath& profile_path, |
- const base::DictionaryValue& properties, |
- const ObjectPathCallback& callback, |
+void FakeShillManagerClient::VerifyAndEncryptCredentials( |
+ const VerificationProperties& properties, |
+ const std::string& service_path, |
+ const StringCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ base::MessageLoop::current()->PostTask( |
+ FROM_HERE, base::Bind(callback, "encrypted_credentials")); |
+} |
+ |
+void FakeShillManagerClient::VerifyAndEncryptData( |
+ const VerificationProperties& properties, |
+ const std::string& data, |
+ const StringCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ base::MessageLoop::current()->PostTask(FROM_HERE, |
+ base::Bind(callback, "encrypted_data")); |
+} |
+ |
+void FakeShillManagerClient::ConnectToBestServices( |
+ const base::Closure& callback, |
const ErrorCallback& error_callback) { |
} |
-} // namespace chromeos |
+ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() { |
+ return this; |
+} |
+ |
+// ShillManagerClient::TestInterface overrides. |
+ |
+void FakeShillManagerClient::AddDevice(const std::string& device_path) { |
+ if (GetListProperty(shill::kDevicesProperty)->AppendIfNotPresent( |
+ base::Value::CreateStringValue(device_path))) { |
+ CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::RemoveDevice(const std::string& device_path) { |
+ base::StringValue device_path_value(device_path); |
+ if (GetListProperty(shill::kDevicesProperty)->Remove( |
+ device_path_value, NULL)) { |
+ CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::ClearDevices() { |
+ GetListProperty(shill::kDevicesProperty)->Clear(); |
+ CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0); |
+} |
+ |
+void FakeShillManagerClient::AddTechnology(const std::string& type, |
+ bool enabled) { |
+ if (GetListProperty(shill::kAvailableTechnologiesProperty)-> |
+ AppendIfNotPresent(base::Value::CreateStringValue(type))) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kAvailableTechnologiesProperty, 0); |
+ } |
+ if (enabled && |
+ GetListProperty(shill::kEnabledTechnologiesProperty)-> |
+ AppendIfNotPresent(base::Value::CreateStringValue(type))) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kEnabledTechnologiesProperty, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::RemoveTechnology(const std::string& type) { |
+ base::StringValue type_value(type); |
+ if (GetListProperty(shill::kAvailableTechnologiesProperty)->Remove( |
+ type_value, NULL)) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kAvailableTechnologiesProperty, 0); |
+ } |
+ if (GetListProperty(shill::kEnabledTechnologiesProperty)->Remove( |
+ type_value, NULL)) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kEnabledTechnologiesProperty, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::SetTechnologyInitializing(const std::string& type, |
+ bool initializing) { |
+ if (initializing) { |
+ if (GetListProperty(shill::kUninitializedTechnologiesProperty)-> |
+ AppendIfNotPresent(base::Value::CreateStringValue(type))) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kUninitializedTechnologiesProperty, 0); |
+ } |
+ } else { |
+ if (GetListProperty(shill::kUninitializedTechnologiesProperty)->Remove( |
+ base::StringValue(type), NULL)) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kUninitializedTechnologiesProperty, 0); |
+ } |
+ } |
+} |
+ |
+void FakeShillManagerClient::ClearProperties() { |
+ stub_properties_.Clear(); |
+} |
+ |
+void FakeShillManagerClient::AddManagerService(const std::string& service_path, |
+ bool add_to_visible_list, |
+ bool add_to_watch_list) { |
+ // Always add to ServiceCompleteListProperty. |
+ GetListProperty(shill::kServiceCompleteListProperty)->AppendIfNotPresent( |
+ base::Value::CreateStringValue(service_path)); |
+ // If visible, add to Services and notify if new. |
+ if (add_to_visible_list && |
+ GetListProperty(shill::kServicesProperty)->AppendIfNotPresent( |
+ base::Value::CreateStringValue(service_path))) { |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+ } |
+ if (add_to_watch_list) |
+ AddServiceToWatchList(service_path); |
+} |
+ |
+void FakeShillManagerClient::RemoveManagerService( |
+ const std::string& service_path) { |
+ base::StringValue service_path_value(service_path); |
+ if (GetListProperty(shill::kServicesProperty)->Remove( |
+ service_path_value, NULL)) { |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+ } |
+ GetListProperty(shill::kServiceCompleteListProperty)->Remove( |
+ service_path_value, NULL); |
+ if (GetListProperty(shill::kServiceWatchListProperty)->Remove( |
+ service_path_value, NULL)) { |
+ CallNotifyObserversPropertyChanged( |
+ shill::kServiceWatchListProperty, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::ClearManagerServices() { |
+ GetListProperty(shill::kServicesProperty)->Clear(); |
+ GetListProperty(shill::kServiceCompleteListProperty)->Clear(); |
+ GetListProperty(shill::kServiceWatchListProperty)->Clear(); |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+ CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0); |
+} |
+ |
+void FakeShillManagerClient::SortManagerServices() { |
+ static const char* ordered_types[] = { |
+ shill::kTypeEthernet, |
+ shill::kTypeWifi, |
+ shill::kTypeCellular, |
+ shill::kTypeWimax, |
+ shill::kTypeVPN |
+ }; |
+ base::ListValue* service_list = GetListProperty(shill::kServicesProperty); |
+ if (!service_list || service_list->empty()) |
+ return; |
+ std::vector<std::string> active_services; |
+ std::vector<std::string> inactive_services; |
+ for (size_t i = 0; i < arraysize(ordered_types); ++i) { |
+ AppendServicesForType(service_list, ordered_types[i], |
+ &active_services, &inactive_services); |
+ } |
+ service_list->Clear(); |
+ for (size_t i = 0; i < active_services.size(); ++i) |
+ service_list->AppendString(active_services[i]); |
+ for (size_t i = 0; i < inactive_services.size(); ++i) |
+ service_list->AppendString(inactive_services[i]); |
+ |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+} |
+ |
+void FakeShillManagerClient::AddGeoNetwork( |
+ const std::string& technology, |
+ const base::DictionaryValue& network) { |
+ base::ListValue* list_value = NULL; |
+ if (!stub_geo_networks_.GetListWithoutPathExpansion( |
+ technology, &list_value)) { |
+ list_value = new base::ListValue; |
+ stub_geo_networks_.SetWithoutPathExpansion(technology, list_value); |
+ } |
+ list_value->Append(network.DeepCopy()); |
+} |
+ |
+void FakeShillManagerClient::AddProfile(const std::string& profile_path) { |
+ const char* key = shill::kProfilesProperty; |
+ if (GetListProperty(key)->AppendIfNotPresent( |
+ new base::StringValue(profile_path))) { |
+ CallNotifyObserversPropertyChanged(key, 0); |
+ } |
+} |
+ |
+void FakeShillManagerClient::AddServiceToWatchList( |
+ const std::string& service_path) { |
+ // Remove and insert the service, moving it to the front of the watch list. |
+ GetListProperty(shill::kServiceWatchListProperty)->Remove( |
+ base::StringValue(service_path), NULL); |
+ GetListProperty(shill::kServiceWatchListProperty)->Insert( |
+ 0, base::Value::CreateStringValue(service_path)); |
+ CallNotifyObserversPropertyChanged( |
+ shill::kServiceWatchListProperty, 0); |
+} |
+ |
+void FakeShillManagerClient::PassStubProperties( |
+ const DictionaryValueCallback& callback) const { |
+ scoped_ptr<base::DictionaryValue> stub_properties( |
+ stub_properties_.DeepCopy()); |
+ // Remove disabled services from the list. |
+ stub_properties->SetWithoutPathExpansion( |
+ shill::kServicesProperty, |
+ GetEnabledServiceList(shill::kServicesProperty)); |
+ stub_properties->SetWithoutPathExpansion( |
+ shill::kServiceWatchListProperty, |
+ GetEnabledServiceList(shill::kServiceWatchListProperty)); |
+ callback.Run(DBUS_METHOD_CALL_SUCCESS, *stub_properties); |
+} |
+ |
+void FakeShillManagerClient::PassStubGeoNetworks( |
+ const DictionaryValueCallback& callback) const { |
+ callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_); |
+} |
+ |
+void FakeShillManagerClient::CallNotifyObserversPropertyChanged( |
+ const std::string& property, |
+ int delay_ms) { |
+ // Avoid unnecessary delayed task if we have no observers (e.g. during |
+ // initial setup). |
+ if (!observer_list_.might_have_observers()) |
+ return; |
+ if (!CommandLine::ForCurrentProcess()->HasSwitch( |
+ chromeos::switches::kEnableStubInteractive)) { |
+ delay_ms = 0; |
+ } |
+ base::MessageLoop::current()->PostDelayedTask( |
+ FROM_HERE, |
+ base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged, |
+ weak_ptr_factory_.GetWeakPtr(), |
+ property), |
+ base::TimeDelta::FromMilliseconds(delay_ms)); |
+} |
+ |
+void FakeShillManagerClient::NotifyObserversPropertyChanged( |
+ const std::string& property) { |
+ if (property == shill::kServicesProperty || |
+ property == shill::kServiceWatchListProperty) { |
+ scoped_ptr<base::ListValue> services(GetEnabledServiceList(property)); |
+ FOR_EACH_OBSERVER(ShillPropertyChangedObserver, |
+ observer_list_, |
+ OnPropertyChanged(property, *(services.get()))); |
+ return; |
+ } |
+ base::Value* value = NULL; |
+ if (!stub_properties_.GetWithoutPathExpansion(property, &value)) { |
+ LOG(ERROR) << "Notify for unknown property: " << property; |
+ return; |
+ } |
+ FOR_EACH_OBSERVER(ShillPropertyChangedObserver, |
+ observer_list_, |
+ OnPropertyChanged(property, *value)); |
+} |
+ |
+base::ListValue* FakeShillManagerClient::GetListProperty( |
+ const std::string& property) { |
+ base::ListValue* list_property = NULL; |
+ if (!stub_properties_.GetListWithoutPathExpansion( |
+ property, &list_property)) { |
+ list_property = new base::ListValue; |
+ stub_properties_.SetWithoutPathExpansion(property, list_property); |
+ } |
+ return list_property; |
+} |
+ |
+bool FakeShillManagerClient::TechnologyEnabled(const std::string& type) const { |
+ if (type == shill::kTypeVPN) |
+ return true; // VPN is always "enabled" since there is no associated device |
+ bool enabled = false; |
+ const base::ListValue* technologies; |
+ if (stub_properties_.GetListWithoutPathExpansion( |
+ shill::kEnabledTechnologiesProperty, &technologies)) { |
+ base::StringValue type_value(type); |
+ if (technologies->Find(type_value) != technologies->end()) |
+ enabled = true; |
+ } |
+ return enabled; |
+} |
+ |
+void FakeShillManagerClient::SetTechnologyEnabled( |
+ const std::string& type, |
+ const base::Closure& callback, |
+ bool enabled) { |
+ base::ListValue* enabled_list = NULL; |
+ stub_properties_.GetListWithoutPathExpansion( |
+ shill::kEnabledTechnologiesProperty, &enabled_list); |
+ DCHECK(enabled_list); |
+ if (enabled) |
+ enabled_list->AppendIfNotPresent(new base::StringValue(type)); |
+ else |
+ enabled_list->Remove(base::StringValue(type), NULL); |
+ CallNotifyObserversPropertyChanged( |
+ shill::kEnabledTechnologiesProperty, 0 /* already delayed */); |
+ base::MessageLoop::current()->PostTask(FROM_HERE, callback); |
+ // May affect available services |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+ CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0); |
+} |
+ |
+base::ListValue* FakeShillManagerClient::GetEnabledServiceList( |
+ const std::string& property) const { |
+ base::ListValue* new_service_list = new base::ListValue; |
+ const base::ListValue* service_list; |
+ if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) { |
+ ShillServiceClient::TestInterface* service_client = |
+ DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); |
+ for (base::ListValue::const_iterator iter = service_list->begin(); |
+ iter != service_list->end(); ++iter) { |
+ std::string service_path; |
+ if (!(*iter)->GetAsString(&service_path)) |
+ continue; |
+ const base::DictionaryValue* properties = |
+ service_client->GetServiceProperties(service_path); |
+ if (!properties) { |
+ LOG(ERROR) << "Properties not found for service: " << service_path; |
+ continue; |
+ } |
+ std::string name; |
+ properties->GetString(shill::kNameProperty, &name); |
+ std::string type; |
+ properties->GetString(shill::kTypeProperty, &type); |
+ if (TechnologyEnabled(type)) |
+ new_service_list->Append((*iter)->DeepCopy()); |
+ } |
+ } |
+ return new_service_list; |
+} |
+ |
+void FakeShillManagerClient::ScanCompleted(const std::string& device_path, |
+ const base::Closure& callback) { |
+ if (!device_path.empty()) { |
+ DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()-> |
+ SetDeviceProperty(device_path, |
+ shill::kScanningProperty, |
+ base::FundamentalValue(false)); |
+ } |
+ CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0); |
+ CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0); |
+ base::MessageLoop::current()->PostTask(FROM_HERE, callback); |
+} |
+ |
+} // namespace chromeos |