| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 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/shill_service_client_stub.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/command_line.h" | |
| 10 #include "base/message_loop/message_loop.h" | |
| 11 #include "base/stl_util.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_manager_client.h" | |
| 17 #include "chromeos/dbus/shill_property_changed_observer.h" | |
| 18 #include "chromeos/dbus/shill_stub_helper.h" | |
| 19 #include "chromeos/network/shill_property_util.h" | |
| 20 #include "dbus/bus.h" | |
| 21 #include "dbus/message.h" | |
| 22 #include "dbus/object_path.h" | |
| 23 #include "third_party/cros_system_api/dbus/service_constants.h" | |
| 24 | |
| 25 namespace chromeos { | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 void ErrorFunction(const std::string& error_name, | |
| 30 const std::string& error_message) { | |
| 31 LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message; | |
| 32 } | |
| 33 | |
| 34 void PassStubListValue(const ShillServiceClient::ListValueCallback& callback, | |
| 35 base::ListValue* value) { | |
| 36 callback.Run(*value); | |
| 37 } | |
| 38 | |
| 39 void PassStubServiceProperties( | |
| 40 const ShillServiceClient::DictionaryValueCallback& callback, | |
| 41 DBusMethodCallStatus call_status, | |
| 42 const base::DictionaryValue* properties) { | |
| 43 callback.Run(call_status, *properties); | |
| 44 } | |
| 45 | |
| 46 } // namespace | |
| 47 | |
| 48 ShillServiceClientStub::ShillServiceClientStub() : weak_ptr_factory_(this) { | |
| 49 } | |
| 50 | |
| 51 ShillServiceClientStub::~ShillServiceClientStub() { | |
| 52 STLDeleteContainerPairSecondPointers( | |
| 53 observer_list_.begin(), observer_list_.end()); | |
| 54 } | |
| 55 | |
| 56 | |
| 57 // ShillServiceClient overrides. | |
| 58 | |
| 59 void ShillServiceClientStub::Init(dbus::Bus* bus) { | |
| 60 } | |
| 61 | |
| 62 void ShillServiceClientStub::AddPropertyChangedObserver( | |
| 63 const dbus::ObjectPath& service_path, | |
| 64 ShillPropertyChangedObserver* observer) { | |
| 65 GetObserverList(service_path).AddObserver(observer); | |
| 66 } | |
| 67 | |
| 68 void ShillServiceClientStub::RemovePropertyChangedObserver( | |
| 69 const dbus::ObjectPath& service_path, | |
| 70 ShillPropertyChangedObserver* observer) { | |
| 71 GetObserverList(service_path).RemoveObserver(observer); | |
| 72 } | |
| 73 | |
| 74 void ShillServiceClientStub::GetProperties( | |
| 75 const dbus::ObjectPath& service_path, | |
| 76 const DictionaryValueCallback& callback) { | |
| 77 base::DictionaryValue* nested_dict = NULL; | |
| 78 scoped_ptr<base::DictionaryValue> result_properties; | |
| 79 DBusMethodCallStatus call_status; | |
| 80 stub_services_.GetDictionaryWithoutPathExpansion(service_path.value(), | |
| 81 &nested_dict); | |
| 82 if (nested_dict) { | |
| 83 result_properties.reset(nested_dict->DeepCopy()); | |
| 84 // Remove credentials that Shill wouldn't send. | |
| 85 result_properties->RemoveWithoutPathExpansion(shill::kPassphraseProperty, | |
| 86 NULL); | |
| 87 call_status = DBUS_METHOD_CALL_SUCCESS; | |
| 88 } else { | |
| 89 LOG(ERROR) << "Properties not found for: " << service_path.value(); | |
| 90 result_properties.reset(new base::DictionaryValue); | |
| 91 call_status = DBUS_METHOD_CALL_FAILURE; | |
| 92 } | |
| 93 | |
| 94 base::MessageLoop::current()->PostTask( | |
| 95 FROM_HERE, | |
| 96 base::Bind(&PassStubServiceProperties, | |
| 97 callback, | |
| 98 call_status, | |
| 99 base::Owned(result_properties.release()))); | |
| 100 } | |
| 101 | |
| 102 void ShillServiceClientStub::SetProperty(const dbus::ObjectPath& service_path, | |
| 103 const std::string& name, | |
| 104 const base::Value& value, | |
| 105 const base::Closure& callback, | |
| 106 const ErrorCallback& error_callback) { | |
| 107 if (!SetServiceProperty(service_path.value(), name, value)) { | |
| 108 LOG(ERROR) << "Service not found: " << service_path.value(); | |
| 109 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 110 return; | |
| 111 } | |
| 112 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 113 } | |
| 114 | |
| 115 void ShillServiceClientStub::SetProperties( | |
| 116 const dbus::ObjectPath& service_path, | |
| 117 const base::DictionaryValue& properties, | |
| 118 const base::Closure& callback, | |
| 119 const ErrorCallback& error_callback) { | |
| 120 for (base::DictionaryValue::Iterator iter(properties); | |
| 121 !iter.IsAtEnd(); iter.Advance()) { | |
| 122 if (!SetServiceProperty(service_path.value(), iter.key(), iter.value())) { | |
| 123 LOG(ERROR) << "Service not found: " << service_path.value(); | |
| 124 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 125 return; | |
| 126 } | |
| 127 } | |
| 128 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 129 } | |
| 130 | |
| 131 void ShillServiceClientStub::ClearProperty( | |
| 132 const dbus::ObjectPath& service_path, | |
| 133 const std::string& name, | |
| 134 const base::Closure& callback, | |
| 135 const ErrorCallback& error_callback) { | |
| 136 base::DictionaryValue* dict = NULL; | |
| 137 if (!stub_services_.GetDictionaryWithoutPathExpansion( | |
| 138 service_path.value(), &dict)) { | |
| 139 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 140 return; | |
| 141 } | |
| 142 dict->RemoveWithoutPathExpansion(name, NULL); | |
| 143 // Note: Shill does not send notifications when properties are cleared. | |
| 144 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 145 } | |
| 146 | |
| 147 void ShillServiceClientStub::ClearProperties( | |
| 148 const dbus::ObjectPath& service_path, | |
| 149 const std::vector<std::string>& names, | |
| 150 const ListValueCallback& callback, | |
| 151 const ErrorCallback& error_callback) { | |
| 152 base::DictionaryValue* dict = NULL; | |
| 153 if (!stub_services_.GetDictionaryWithoutPathExpansion( | |
| 154 service_path.value(), &dict)) { | |
| 155 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 156 return; | |
| 157 } | |
| 158 scoped_ptr<base::ListValue> results(new base::ListValue); | |
| 159 for (std::vector<std::string>::const_iterator iter = names.begin(); | |
| 160 iter != names.end(); ++iter) { | |
| 161 dict->RemoveWithoutPathExpansion(*iter, NULL); | |
| 162 // Note: Shill does not send notifications when properties are cleared. | |
| 163 results->AppendBoolean(true); | |
| 164 } | |
| 165 base::MessageLoop::current()->PostTask( | |
| 166 FROM_HERE, | |
| 167 base::Bind(&PassStubListValue, | |
| 168 callback, base::Owned(results.release()))); | |
| 169 } | |
| 170 | |
| 171 void ShillServiceClientStub::Connect(const dbus::ObjectPath& service_path, | |
| 172 const base::Closure& callback, | |
| 173 const ErrorCallback& error_callback) { | |
| 174 VLOG(1) << "ShillServiceClientStub::Connect: " << service_path.value(); | |
| 175 base::DictionaryValue* service_properties = NULL; | |
| 176 if (!stub_services_.GetDictionary( | |
| 177 service_path.value(), &service_properties)) { | |
| 178 LOG(ERROR) << "Service not found: " << service_path.value(); | |
| 179 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 180 return; | |
| 181 } | |
| 182 | |
| 183 // Set any other services of the same Type to 'offline' first, before setting | |
| 184 // State to Association which will trigger sorting Manager.Services and | |
| 185 // sending an update. | |
| 186 SetOtherServicesOffline(service_path.value()); | |
| 187 | |
| 188 // Set Associating. | |
| 189 base::StringValue associating_value(shill::kStateAssociation); | |
| 190 SetServiceProperty(service_path.value(), | |
| 191 shill::kStateProperty, | |
| 192 associating_value); | |
| 193 | |
| 194 // Stay Associating until the state is changed again after a delay. | |
| 195 base::TimeDelta delay; | |
| 196 if (CommandLine::ForCurrentProcess()->HasSwitch( | |
| 197 chromeos::switches::kEnableStubInteractive)) { | |
| 198 const int kConnectDelaySeconds = 5; | |
| 199 delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); | |
| 200 } | |
| 201 base::MessageLoop::current()->PostDelayedTask( | |
| 202 FROM_HERE, | |
| 203 base::Bind(&ShillServiceClientStub::ContinueConnect, | |
| 204 weak_ptr_factory_.GetWeakPtr(), | |
| 205 service_path.value()), | |
| 206 delay); | |
| 207 | |
| 208 callback.Run(); | |
| 209 } | |
| 210 | |
| 211 void ShillServiceClientStub::Disconnect(const dbus::ObjectPath& service_path, | |
| 212 const base::Closure& callback, | |
| 213 const ErrorCallback& error_callback) { | |
| 214 base::Value* service; | |
| 215 if (!stub_services_.Get(service_path.value(), &service)) { | |
| 216 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 217 return; | |
| 218 } | |
| 219 base::TimeDelta delay; | |
| 220 if (CommandLine::ForCurrentProcess()->HasSwitch( | |
| 221 chromeos::switches::kEnableStubInteractive)) { | |
| 222 const int kConnectDelaySeconds = 2; | |
| 223 delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); | |
| 224 } | |
| 225 // Set Idle after a delay | |
| 226 base::StringValue idle_value(shill::kStateIdle); | |
| 227 base::MessageLoop::current()->PostDelayedTask( | |
| 228 FROM_HERE, | |
| 229 base::Bind(&ShillServiceClientStub::SetProperty, | |
| 230 weak_ptr_factory_.GetWeakPtr(), | |
| 231 service_path, | |
| 232 shill::kStateProperty, | |
| 233 idle_value, | |
| 234 base::Bind(&base::DoNothing), | |
| 235 error_callback), | |
| 236 delay); | |
| 237 callback.Run(); | |
| 238 } | |
| 239 | |
| 240 void ShillServiceClientStub::Remove(const dbus::ObjectPath& service_path, | |
| 241 const base::Closure& callback, | |
| 242 const ErrorCallback& error_callback) { | |
| 243 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 244 } | |
| 245 | |
| 246 void ShillServiceClientStub::ActivateCellularModem( | |
| 247 const dbus::ObjectPath& service_path, | |
| 248 const std::string& carrier, | |
| 249 const base::Closure& callback, | |
| 250 const ErrorCallback& error_callback) { | |
| 251 base::DictionaryValue* service_properties = | |
| 252 GetModifiableServiceProperties(service_path.value(), false); | |
| 253 if (!service_properties) { | |
| 254 LOG(ERROR) << "Service not found: " << service_path.value(); | |
| 255 error_callback.Run("Error.InvalidService", "Invalid Service"); | |
| 256 } | |
| 257 SetServiceProperty(service_path.value(), | |
| 258 shill::kActivationStateProperty, | |
| 259 base::StringValue(shill::kActivationStateActivating)); | |
| 260 base::TimeDelta delay; | |
| 261 if (CommandLine::ForCurrentProcess()->HasSwitch( | |
| 262 chromeos::switches::kEnableStubInteractive)) { | |
| 263 const int kConnectDelaySeconds = 2; | |
| 264 delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); | |
| 265 } | |
| 266 // Set Activated after a delay | |
| 267 base::MessageLoop::current()->PostDelayedTask( | |
| 268 FROM_HERE, | |
| 269 base::Bind(&ShillServiceClientStub::SetCellularActivated, | |
| 270 weak_ptr_factory_.GetWeakPtr(), | |
| 271 service_path, | |
| 272 error_callback), | |
| 273 delay); | |
| 274 | |
| 275 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 276 } | |
| 277 | |
| 278 void ShillServiceClientStub::CompleteCellularActivation( | |
| 279 const dbus::ObjectPath& service_path, | |
| 280 const base::Closure& callback, | |
| 281 const ErrorCallback& error_callback) { | |
| 282 base::MessageLoop::current()->PostTask(FROM_HERE, callback); | |
| 283 } | |
| 284 | |
| 285 void ShillServiceClientStub::GetLoadableProfileEntries( | |
| 286 const dbus::ObjectPath& service_path, | |
| 287 const DictionaryValueCallback& callback) { | |
| 288 // Provide a dictionary with a single { profile_path, service_path } entry | |
| 289 // if the Profile property is set, or an empty dictionary. | |
| 290 scoped_ptr<base::DictionaryValue> result_properties( | |
| 291 new base::DictionaryValue); | |
| 292 base::DictionaryValue* service_properties = | |
| 293 GetModifiableServiceProperties(service_path.value(), false); | |
| 294 if (service_properties) { | |
| 295 std::string profile_path; | |
| 296 if (service_properties->GetStringWithoutPathExpansion( | |
| 297 shill::kProfileProperty, &profile_path)) { | |
| 298 result_properties->SetStringWithoutPathExpansion( | |
| 299 profile_path, service_path.value()); | |
| 300 } | |
| 301 } else { | |
| 302 LOG(WARNING) << "Service not in profile: " << service_path.value(); | |
| 303 } | |
| 304 | |
| 305 DBusMethodCallStatus call_status = DBUS_METHOD_CALL_SUCCESS; | |
| 306 base::MessageLoop::current()->PostTask( | |
| 307 FROM_HERE, | |
| 308 base::Bind(&PassStubServiceProperties, | |
| 309 callback, | |
| 310 call_status, | |
| 311 base::Owned(result_properties.release()))); | |
| 312 } | |
| 313 | |
| 314 ShillServiceClient::TestInterface* ShillServiceClientStub::GetTestInterface() { | |
| 315 return this; | |
| 316 } | |
| 317 | |
| 318 // ShillServiceClient::TestInterface overrides. | |
| 319 | |
| 320 void ShillServiceClientStub::AddService(const std::string& service_path, | |
| 321 const std::string& name, | |
| 322 const std::string& type, | |
| 323 const std::string& state, | |
| 324 bool add_to_visible_list, | |
| 325 bool add_to_watch_list) { | |
| 326 std::string nstate = state; | |
| 327 if (CommandLine::ForCurrentProcess()->HasSwitch( | |
| 328 chromeos::switches::kDefaultStubNetworkStateIdle)) { | |
| 329 nstate = shill::kStateIdle; | |
| 330 } | |
| 331 AddServiceWithIPConfig(service_path, name, type, nstate, "", | |
| 332 add_to_visible_list, add_to_watch_list); | |
| 333 } | |
| 334 | |
| 335 void ShillServiceClientStub::AddServiceWithIPConfig( | |
| 336 const std::string& service_path, | |
| 337 const std::string& name, | |
| 338 const std::string& type, | |
| 339 const std::string& state, | |
| 340 const std::string& ipconfig_path, | |
| 341 bool add_to_visible_list, | |
| 342 bool add_to_watch_list) { | |
| 343 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> | |
| 344 AddManagerService(service_path, add_to_visible_list, add_to_watch_list); | |
| 345 | |
| 346 base::DictionaryValue* properties = | |
| 347 GetModifiableServiceProperties(service_path, true); | |
| 348 connect_behavior_.erase(service_path); | |
| 349 shill_property_util::SetSSID(name, properties); | |
| 350 properties->SetWithoutPathExpansion( | |
| 351 shill::kNameProperty, | |
| 352 base::Value::CreateStringValue(name)); | |
| 353 properties->SetWithoutPathExpansion( | |
| 354 shill::kDeviceProperty, | |
| 355 base::Value::CreateStringValue( | |
| 356 shill_stub_helper::DevicePathForType(type))); | |
| 357 properties->SetWithoutPathExpansion( | |
| 358 shill::kTypeProperty, | |
| 359 base::Value::CreateStringValue(type)); | |
| 360 properties->SetWithoutPathExpansion( | |
| 361 shill::kStateProperty, | |
| 362 base::Value::CreateStringValue(state)); | |
| 363 if (!ipconfig_path.empty()) | |
| 364 properties->SetWithoutPathExpansion( | |
| 365 shill::kIPConfigProperty, | |
| 366 base::Value::CreateStringValue(ipconfig_path)); | |
| 367 } | |
| 368 | |
| 369 void ShillServiceClientStub::RemoveService(const std::string& service_path) { | |
| 370 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> | |
| 371 RemoveManagerService(service_path); | |
| 372 | |
| 373 stub_services_.RemoveWithoutPathExpansion(service_path, NULL); | |
| 374 connect_behavior_.erase(service_path); | |
| 375 } | |
| 376 | |
| 377 bool ShillServiceClientStub::SetServiceProperty(const std::string& service_path, | |
| 378 const std::string& property, | |
| 379 const base::Value& value) { | |
| 380 base::DictionaryValue* dict = NULL; | |
| 381 if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, &dict)) | |
| 382 return false; | |
| 383 | |
| 384 VLOG(1) << "Service.SetProperty: " << property << " = " << value | |
| 385 << " For: " << service_path; | |
| 386 | |
| 387 base::DictionaryValue new_properties; | |
| 388 std::string changed_property; | |
| 389 bool case_sensitive = true; | |
| 390 if (StartsWithASCII(property, "Provider.", case_sensitive) || | |
| 391 StartsWithASCII(property, "OpenVPN.", case_sensitive) || | |
| 392 StartsWithASCII(property, "L2TPIPsec.", case_sensitive)) { | |
| 393 // These properties are only nested within the Provider dictionary if read | |
| 394 // from Shill. | |
| 395 base::DictionaryValue* provider = new base::DictionaryValue; | |
| 396 provider->SetWithoutPathExpansion(property, value.DeepCopy()); | |
| 397 new_properties.SetWithoutPathExpansion(shill::kProviderProperty, provider); | |
| 398 changed_property = shill::kProviderProperty; | |
| 399 } else { | |
| 400 new_properties.SetWithoutPathExpansion(property, value.DeepCopy()); | |
| 401 changed_property = property; | |
| 402 } | |
| 403 | |
| 404 dict->MergeDictionary(&new_properties); | |
| 405 | |
| 406 if (property == shill::kStateProperty) { | |
| 407 // When State changes the sort order of Services may change. | |
| 408 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> | |
| 409 SortManagerServices(); | |
| 410 } | |
| 411 | |
| 412 base::MessageLoop::current()->PostTask( | |
| 413 FROM_HERE, | |
| 414 base::Bind(&ShillServiceClientStub::NotifyObserversPropertyChanged, | |
| 415 weak_ptr_factory_.GetWeakPtr(), | |
| 416 dbus::ObjectPath(service_path), changed_property)); | |
| 417 return true; | |
| 418 } | |
| 419 | |
| 420 const base::DictionaryValue* ShillServiceClientStub::GetServiceProperties( | |
| 421 const std::string& service_path) const { | |
| 422 const base::DictionaryValue* properties = NULL; | |
| 423 stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties); | |
| 424 return properties; | |
| 425 } | |
| 426 | |
| 427 void ShillServiceClientStub::ClearServices() { | |
| 428 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> | |
| 429 ClearManagerServices(); | |
| 430 | |
| 431 stub_services_.Clear(); | |
| 432 connect_behavior_.clear(); | |
| 433 } | |
| 434 | |
| 435 void ShillServiceClientStub::SetConnectBehavior(const std::string& service_path, | |
| 436 const base::Closure& behavior) { | |
| 437 connect_behavior_[service_path] = behavior; | |
| 438 } | |
| 439 | |
| 440 void ShillServiceClientStub::NotifyObserversPropertyChanged( | |
| 441 const dbus::ObjectPath& service_path, | |
| 442 const std::string& property) { | |
| 443 base::DictionaryValue* dict = NULL; | |
| 444 std::string path = service_path.value(); | |
| 445 if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &dict)) { | |
| 446 LOG(ERROR) << "Notify for unknown service: " << path; | |
| 447 return; | |
| 448 } | |
| 449 base::Value* value = NULL; | |
| 450 if (!dict->GetWithoutPathExpansion(property, &value)) { | |
| 451 LOG(ERROR) << "Notify for unknown property: " | |
| 452 << path << " : " << property; | |
| 453 return; | |
| 454 } | |
| 455 FOR_EACH_OBSERVER(ShillPropertyChangedObserver, | |
| 456 GetObserverList(service_path), | |
| 457 OnPropertyChanged(property, *value)); | |
| 458 } | |
| 459 | |
| 460 base::DictionaryValue* ShillServiceClientStub::GetModifiableServiceProperties( | |
| 461 const std::string& service_path, bool create_if_missing) { | |
| 462 base::DictionaryValue* properties = NULL; | |
| 463 if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, | |
| 464 &properties) && | |
| 465 create_if_missing) { | |
| 466 properties = new base::DictionaryValue; | |
| 467 stub_services_.Set(service_path, properties); | |
| 468 } | |
| 469 return properties; | |
| 470 } | |
| 471 | |
| 472 ShillServiceClientStub::PropertyObserverList& | |
| 473 ShillServiceClientStub::GetObserverList(const dbus::ObjectPath& device_path) { | |
| 474 std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter = | |
| 475 observer_list_.find(device_path); | |
| 476 if (iter != observer_list_.end()) | |
| 477 return *(iter->second); | |
| 478 PropertyObserverList* observer_list = new PropertyObserverList(); | |
| 479 observer_list_[device_path] = observer_list; | |
| 480 return *observer_list; | |
| 481 } | |
| 482 | |
| 483 void ShillServiceClientStub::SetOtherServicesOffline( | |
| 484 const std::string& service_path) { | |
| 485 const base::DictionaryValue* service_properties = GetServiceProperties( | |
| 486 service_path); | |
| 487 if (!service_properties) { | |
| 488 LOG(ERROR) << "Missing service: " << service_path; | |
| 489 return; | |
| 490 } | |
| 491 std::string service_type; | |
| 492 service_properties->GetString(shill::kTypeProperty, &service_type); | |
| 493 // Set all other services of the same type to offline (Idle). | |
| 494 for (base::DictionaryValue::Iterator iter(stub_services_); | |
| 495 !iter.IsAtEnd(); iter.Advance()) { | |
| 496 std::string path = iter.key(); | |
| 497 if (path == service_path) | |
| 498 continue; | |
| 499 base::DictionaryValue* properties; | |
| 500 if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &properties)) | |
| 501 NOTREACHED(); | |
| 502 | |
| 503 std::string type; | |
| 504 properties->GetString(shill::kTypeProperty, &type); | |
| 505 if (type != service_type) | |
| 506 continue; | |
| 507 properties->SetWithoutPathExpansion( | |
| 508 shill::kStateProperty, | |
| 509 base::Value::CreateStringValue(shill::kStateIdle)); | |
| 510 } | |
| 511 } | |
| 512 | |
| 513 void ShillServiceClientStub::SetCellularActivated( | |
| 514 const dbus::ObjectPath& service_path, | |
| 515 const ErrorCallback& error_callback) { | |
| 516 SetProperty(service_path, | |
| 517 shill::kActivationStateProperty, | |
| 518 base::StringValue(shill::kActivationStateActivated), | |
| 519 base::Bind(&base::DoNothing), | |
| 520 error_callback); | |
| 521 SetProperty(service_path, | |
| 522 shill::kConnectableProperty, | |
| 523 base::FundamentalValue(true), | |
| 524 base::Bind(&base::DoNothing), | |
| 525 error_callback); | |
| 526 } | |
| 527 | |
| 528 void ShillServiceClientStub::ContinueConnect( | |
| 529 const std::string& service_path) { | |
| 530 VLOG(1) << "ShillServiceClientStub::ContinueConnect: " << service_path; | |
| 531 base::DictionaryValue* service_properties = NULL; | |
| 532 if (!stub_services_.GetDictionary(service_path, &service_properties)) { | |
| 533 LOG(ERROR) << "Service not found: " << service_path; | |
| 534 return; | |
| 535 } | |
| 536 | |
| 537 if (ContainsKey(connect_behavior_, service_path)) { | |
| 538 const base::Closure& custom_connect_behavior = | |
| 539 connect_behavior_[service_path]; | |
| 540 custom_connect_behavior.Run(); | |
| 541 return; | |
| 542 } | |
| 543 | |
| 544 // No custom connect behavior set, continue with the default connect behavior. | |
| 545 std::string passphrase; | |
| 546 service_properties->GetStringWithoutPathExpansion( | |
| 547 shill::kPassphraseProperty, &passphrase); | |
| 548 if (passphrase == "failure") { | |
| 549 // Simulate a password failure. | |
| 550 SetServiceProperty(service_path, | |
| 551 shill::kStateProperty, | |
| 552 base::StringValue(shill::kStateFailure)); | |
| 553 base::MessageLoop::current()->PostTask( | |
| 554 FROM_HERE, | |
| 555 base::Bind( | |
| 556 base::IgnoreResult(&ShillServiceClientStub::SetServiceProperty), | |
| 557 weak_ptr_factory_.GetWeakPtr(), | |
| 558 service_path, | |
| 559 shill::kErrorProperty, | |
| 560 base::StringValue(shill::kErrorBadPassphrase))); | |
| 561 } else { | |
| 562 // Set Online. | |
| 563 SetServiceProperty(service_path, | |
| 564 shill::kStateProperty, | |
| 565 base::StringValue(shill::kStateOnline)); | |
| 566 } | |
| 567 } | |
| 568 | |
| 569 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 31773002:
cryptohome: Convet all *Stub classes into Fake* classes (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src