1 // Copyright (c) 2012 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/network/shill_property_handler.h"
6
7 #include <map>
8 #include <set>
9 #include <string>
10
11 #include "base/bind.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/message_loop/message_loop.h"
14 #include "base/values.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_manager_client.h"
19 #include "chromeos/dbus/shill_profile_client.h"
20 #include "chromeos/dbus/shill_service_client.h"
21 #include "dbus/object_path.h"
22 #include "testing/gtest/include/gtest/gtest.h"
23 #include "third_party/cros_system_api/dbus/service_constants.h"
24
25 namespace chromeos {
26
27 namespace {
28
DoNothingWithCallStatus(DBusMethodCallStatus call_status)29 void DoNothingWithCallStatus(DBusMethodCallStatus call_status) {
30 }
31
ErrorCallbackFunction(const std::string & error_name,const std::string & error_message)32 void ErrorCallbackFunction(const std::string& error_name,
33 const std::string& error_message) {
34 LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
35 }
36
37 class TestListener : public internal::ShillPropertyHandler::Listener {
38 public:
TestListener()39 TestListener() : technology_list_updates_(0),
40 errors_(0) {
41 }
42
UpdateManagedList(ManagedState::ManagedType type,const base::ListValue & entries)43 virtual void UpdateManagedList(ManagedState::ManagedType type,
44 const base::ListValue& entries) OVERRIDE {
45 UpdateEntries(GetTypeString(type), entries);
46 }
47
UpdateManagedStateProperties(ManagedState::ManagedType type,const std::string & path,const base::DictionaryValue & properties)48 virtual void UpdateManagedStateProperties(
49 ManagedState::ManagedType type,
50 const std::string& path,
51 const base::DictionaryValue& properties) OVERRIDE {
52 AddInitialPropertyUpdate(GetTypeString(type), path);
53 }
54
ProfileListChanged()55 virtual void ProfileListChanged() OVERRIDE {
56 }
57
UpdateNetworkServiceProperty(const std::string & service_path,const std::string & key,const base::Value & value)58 virtual void UpdateNetworkServiceProperty(
59 const std::string& service_path,
60 const std::string& key,
61 const base::Value& value) OVERRIDE {
62 AddPropertyUpdate(shill::kServicesProperty, service_path);
63 }
64
UpdateDeviceProperty(const std::string & device_path,const std::string & key,const base::Value & value)65 virtual void UpdateDeviceProperty(
66 const std::string& device_path,
67 const std::string& key,
68 const base::Value& value) OVERRIDE {
69 AddPropertyUpdate(shill::kDevicesProperty, device_path);
70 }
71
TechnologyListChanged()72 virtual void TechnologyListChanged() OVERRIDE {
73 ++technology_list_updates_;
74 }
75
CheckPortalListChanged(const std::string & check_portal_list)76 virtual void CheckPortalListChanged(
77 const std::string& check_portal_list) OVERRIDE {
78 }
79
ManagedStateListChanged(ManagedState::ManagedType type)80 virtual void ManagedStateListChanged(
81 ManagedState::ManagedType type) OVERRIDE {
82 AddStateListUpdate(GetTypeString(type));
83 }
84
entries(const std::string & type)85 std::vector<std::string>& entries(const std::string& type) {
86 return entries_[type];
87 }
property_updates(const std::string & type)88 std::map<std::string, int>& property_updates(const std::string& type) {
89 return property_updates_[type];
90 }
initial_property_updates(const std::string & type)91 std::map<std::string, int>& initial_property_updates(
92 const std::string& type) {
93 return initial_property_updates_[type];
94 }
list_updates(const std::string & type)95 int list_updates(const std::string& type) { return list_updates_[type]; }
technology_list_updates()96 int technology_list_updates() { return technology_list_updates_; }
errors()97 int errors() { return errors_; }
98
99 private:
GetTypeString(ManagedState::ManagedType type)100 std::string GetTypeString(ManagedState::ManagedType type) {
101 if (type == ManagedState::MANAGED_TYPE_NETWORK) {
102 return shill::kServicesProperty;
103 } else if (type == ManagedState::MANAGED_TYPE_FAVORITE) {
104 return shill::kServiceCompleteListProperty;
105 } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
106 return shill::kDevicesProperty;
107 }
108 LOG(ERROR) << "UpdateManagedList called with unrecognized type: " << type;
109 ++errors_;
110 return std::string();
111 }
112
UpdateEntries(const std::string & type,const base::ListValue & entries)113 void UpdateEntries(const std::string& type, const base::ListValue& entries) {
114 if (type.empty())
115 return;
116 entries_[type].clear();
117 for (base::ListValue::const_iterator iter = entries.begin();
118 iter != entries.end(); ++iter) {
119 std::string path;
120 if ((*iter)->GetAsString(&path))
121 entries_[type].push_back(path);
122 }
123 }
124
AddPropertyUpdate(const std::string & type,const std::string & path)125 void AddPropertyUpdate(const std::string& type, const std::string& path) {
126 if (type.empty())
127 return;
128 property_updates(type)[path] += 1;
129 }
130
AddInitialPropertyUpdate(const std::string & type,const std::string & path)131 void AddInitialPropertyUpdate(const std::string& type,
132 const std::string& path) {
133 if (type.empty())
134 return;
135 initial_property_updates(type)[path] += 1;
136 }
137
AddStateListUpdate(const std::string & type)138 void AddStateListUpdate(const std::string& type) {
139 if (type.empty())
140 return;
141 list_updates_[type] += 1;
142 }
143
144 // Map of list-type -> paths
145 std::map<std::string, std::vector<std::string> > entries_;
146 // Map of list-type -> map of paths -> update counts
147 std::map<std::string, std::map<std::string, int> > property_updates_;
148 std::map<std::string, std::map<std::string, int> > initial_property_updates_;
149 // Map of list-type -> list update counts
150 std::map<std::string, int > list_updates_;
151 int technology_list_updates_;
152 int errors_;
153 };
154
155 } // namespace
156
157 class ShillPropertyHandlerTest : public testing::Test {
158 public:
ShillPropertyHandlerTest()159 ShillPropertyHandlerTest()
160 : manager_test_(NULL),
161 device_test_(NULL),
162 service_test_(NULL),
163 profile_test_(NULL) {
164 }
~ShillPropertyHandlerTest()165 virtual ~ShillPropertyHandlerTest() {
166 }
167
SetUp()168 virtual void SetUp() OVERRIDE {
169 // Initialize DBusThreadManager with a stub implementation.
170 DBusThreadManager::InitializeWithStub();
171 // Get the test interface for manager / device / service and clear the
172 // default stub properties.
173 manager_test_ =
174 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
175 ASSERT_TRUE(manager_test_);
176 device_test_ =
177 DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
178 ASSERT_TRUE(device_test_);
179 service_test_ =
180 DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
181 ASSERT_TRUE(service_test_);
182 profile_test_ =
183 DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
184 ASSERT_TRUE(profile_test_);
185 SetupShillPropertyHandler();
186 message_loop_.RunUntilIdle();
187 }
188
TearDown()189 virtual void TearDown() OVERRIDE {
190 shill_property_handler_.reset();
191 listener_.reset();
192 DBusThreadManager::Shutdown();
193 }
194
AddDevice(const std::string & type,const std::string & id)195 void AddDevice(const std::string& type, const std::string& id) {
196 ASSERT_TRUE(IsValidType(type));
197 device_test_->AddDevice(id, type, std::string("/device/" + id));
198 }
199
RemoveDevice(const std::string & id)200 void RemoveDevice(const std::string& id) {
201 device_test_->RemoveDevice(id);
202 }
203
AddService(const std::string & type,const std::string & id,const std::string & state,bool add_to_watch_list)204 void AddService(const std::string& type,
205 const std::string& id,
206 const std::string& state,
207 bool add_to_watch_list) {
208 ASSERT_TRUE(IsValidType(type));
209 service_test_->AddService(id, id, type, state,
210 true /* visible */, add_to_watch_list);
211 }
212
AddServiceWithIPConfig(const std::string & type,const std::string & id,const std::string & state,const std::string & ipconfig_path,bool add_to_watch_list)213 void AddServiceWithIPConfig(const std::string& type,
214 const std::string& id,
215 const std::string& state,
216 const std::string& ipconfig_path,
217 bool add_to_watch_list) {
218 ASSERT_TRUE(IsValidType(type));
219 service_test_->AddServiceWithIPConfig(id, id, type, state,
220 ipconfig_path,
221 true /* visible */,
222 add_to_watch_list);
223 }
224
AddServiceToProfile(const std::string & type,const std::string & id,bool visible)225 void AddServiceToProfile(const std::string& type,
226 const std::string& id,
227 bool visible) {
228 service_test_->AddService(id, id, type, shill::kStateIdle,
229 visible, false /* watch */);
230 std::vector<std::string> profiles;
231 profile_test_->GetProfilePaths(&profiles);
232 ASSERT_TRUE(profiles.size() > 0);
233 base::DictionaryValue properties; // Empty entry
234 profile_test_->AddService(profiles[0], id);
235 }
236
RemoveService(const std::string & id)237 void RemoveService(const std::string& id) {
238 service_test_->RemoveService(id);
239 }
240
241 // Call this after any initial Shill client setup
SetupShillPropertyHandler()242 void SetupShillPropertyHandler() {
243 SetupDefaultShillState();
244 listener_.reset(new TestListener);
245 shill_property_handler_.reset(
246 new internal::ShillPropertyHandler(listener_.get()));
247 shill_property_handler_->Init();
248 }
249
IsValidType(const std::string & type)250 bool IsValidType(const std::string& type) {
251 return (type == shill::kTypeEthernet ||
252 type == shill::kTypeEthernetEap ||
253 type == shill::kTypeWifi ||
254 type == shill::kTypeWimax ||
255 type == shill::kTypeBluetooth ||
256 type == shill::kTypeCellular ||
257 type == shill::kTypeVPN);
258 }
259
260 protected:
SetupDefaultShillState()261 void SetupDefaultShillState() {
262 message_loop_.RunUntilIdle(); // Process any pending updates
263 device_test_->ClearDevices();
264 AddDevice(shill::kTypeWifi, "stub_wifi_device1");
265 AddDevice(shill::kTypeCellular, "stub_cellular_device1");
266 service_test_->ClearServices();
267 const bool add_to_watchlist = true;
268 AddService(shill::kTypeEthernet, "stub_ethernet",
269 shill::kStateOnline, add_to_watchlist);
270 AddService(shill::kTypeWifi, "stub_wifi1",
271 shill::kStateOnline, add_to_watchlist);
272 AddService(shill::kTypeWifi, "stub_wifi2",
273 shill::kStateIdle, add_to_watchlist);
274 AddService(shill::kTypeCellular, "stub_cellular1",
275 shill::kStateIdle, add_to_watchlist);
276 }
277
278 base::MessageLoopForUI message_loop_;
279 scoped_ptr<TestListener> listener_;
280 scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
281 ShillManagerClient::TestInterface* manager_test_;
282 ShillDeviceClient::TestInterface* device_test_;
283 ShillServiceClient::TestInterface* service_test_;
284 ShillProfileClient::TestInterface* profile_test_;
285
286 private:
287 DISALLOW_COPY_AND_ASSIGN(ShillPropertyHandlerTest);
288 };
289
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerStub)290 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerStub) {
291 EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable(shill::kTypeWifi));
292 EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWifi));
293 const size_t kNumShillManagerClientStubImplDevices = 2;
294 EXPECT_EQ(kNumShillManagerClientStubImplDevices,
295 listener_->entries(shill::kDevicesProperty).size());
296 const size_t kNumShillManagerClientStubImplServices = 4;
297 EXPECT_EQ(kNumShillManagerClientStubImplServices,
298 listener_->entries(shill::kServicesProperty).size());
299
300 EXPECT_EQ(0, listener_->errors());
301 }
302
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerTechnologyChanged)303 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerTechnologyChanged) {
304 const int initial_technology_updates = 2; // Available and Enabled lists
305 EXPECT_EQ(initial_technology_updates, listener_->technology_list_updates());
306
307 // Remove a technology. Updates both the Available and Enabled lists.
308 manager_test_->RemoveTechnology(shill::kTypeWimax);
309 message_loop_.RunUntilIdle();
310 EXPECT_EQ(initial_technology_updates + 2,
311 listener_->technology_list_updates());
312
313 // Add a disabled technology.
314 manager_test_->AddTechnology(shill::kTypeWimax, false);
315 message_loop_.RunUntilIdle();
316 EXPECT_EQ(initial_technology_updates + 3,
317 listener_->technology_list_updates());
318 EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable(
319 shill::kTypeWimax));
320 EXPECT_FALSE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWimax));
321
322 // Enable the technology.
323 DBusThreadManager::Get()->GetShillManagerClient()->EnableTechnology(
324 shill::kTypeWimax,
325 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
326 message_loop_.RunUntilIdle();
327 EXPECT_EQ(initial_technology_updates + 4,
328 listener_->technology_list_updates());
329 EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWimax));
330
331 EXPECT_EQ(0, listener_->errors());
332 }
333
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerDevicePropertyChanged)334 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerDevicePropertyChanged) {
335 EXPECT_EQ(1, listener_->list_updates(shill::kDevicesProperty));
336 const size_t kNumShillManagerClientStubImplDevices = 2;
337 EXPECT_EQ(kNumShillManagerClientStubImplDevices,
338 listener_->entries(shill::kDevicesProperty).size());
339 // Add a device.
340 const std::string kTestDevicePath("test_wifi_device1");
341 AddDevice(shill::kTypeWifi, kTestDevicePath);
342 message_loop_.RunUntilIdle();
343 EXPECT_EQ(2, listener_->list_updates(shill::kDevicesProperty));
344 EXPECT_EQ(kNumShillManagerClientStubImplDevices + 1,
345 listener_->entries(shill::kDevicesProperty).size());
346 // Device changes are not observed.
347 // Remove a device
348 RemoveDevice(kTestDevicePath);
349 message_loop_.RunUntilIdle();
350 EXPECT_EQ(3, listener_->list_updates(shill::kDevicesProperty));
351 EXPECT_EQ(kNumShillManagerClientStubImplDevices,
352 listener_->entries(shill::kDevicesProperty).size());
353
354 EXPECT_EQ(0, listener_->errors());
355 }
356
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerServicePropertyChanged)357 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServicePropertyChanged) {
358 EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
359 const size_t kNumShillManagerClientStubImplServices = 4;
360 EXPECT_EQ(kNumShillManagerClientStubImplServices,
361 listener_->entries(shill::kServicesProperty).size());
362
363 // Add an unwatched service.
364 const std::string kTestServicePath("test_wifi_service1");
365 AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle, false);
366 message_loop_.RunUntilIdle();
367 // Watched and unwatched services trigger a service list update.
368 EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty));
369 EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
370 listener_->entries(shill::kServicesProperty).size());
371 // Service receives an initial property update.
372 EXPECT_EQ(1, listener_->initial_property_updates(
373 shill::kServicesProperty)[kTestServicePath]);
374 // Change a property.
375 base::FundamentalValue scan_interval(3);
376 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
377 dbus::ObjectPath(kTestServicePath),
378 shill::kScanIntervalProperty,
379 scan_interval,
380 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
381 message_loop_.RunUntilIdle();
382 // Property change triggers an update.
383 EXPECT_EQ(1, listener_->property_updates(
384 shill::kServicesProperty)[kTestServicePath]);
385
386 // Add the existing service to the watch list.
387 AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle, true);
388 message_loop_.RunUntilIdle();
389 // Service list update should be received when watch list changes.
390 EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty));
391 // Number of services shouldn't change.
392 EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
393 listener_->entries(shill::kServicesProperty).size());
394
395 // Change a property.
396 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
397 dbus::ObjectPath(kTestServicePath),
398 shill::kScanIntervalProperty,
399 scan_interval,
400 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
401 message_loop_.RunUntilIdle();
402 // Property change should trigger another update.
403 EXPECT_EQ(2, listener_->property_updates(
404 shill::kServicesProperty)[kTestServicePath]);
405
406 // Remove a service
407 RemoveService(kTestServicePath);
408 message_loop_.RunUntilIdle();
409 EXPECT_EQ(3, listener_->list_updates(shill::kServicesProperty));
410 EXPECT_EQ(kNumShillManagerClientStubImplServices,
411 listener_->entries(shill::kServicesProperty).size());
412
413 EXPECT_EQ(0, listener_->errors());
414 }
415
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerIPConfigPropertyChanged)416 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) {
417 // Set the properties for an IP Config object.
418 const std::string kTestIPConfigPath("test_ip_config_path");
419
420 base::StringValue ip_address("192.168.1.1");
421 DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
422 dbus::ObjectPath(kTestIPConfigPath),
423 shill::kAddressProperty, ip_address,
424 base::Bind(&DoNothingWithCallStatus));
425 base::ListValue dns_servers;
426 dns_servers.Append(base::Value::CreateStringValue("192.168.1.100"));
427 dns_servers.Append(base::Value::CreateStringValue("192.168.1.101"));
428 DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
429 dbus::ObjectPath(kTestIPConfigPath),
430 shill::kNameServersProperty, dns_servers,
431 base::Bind(&DoNothingWithCallStatus));
432 base::FundamentalValue prefixlen(8);
433 DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
434 dbus::ObjectPath(kTestIPConfigPath),
435 shill::kPrefixlenProperty, prefixlen,
436 base::Bind(&DoNothingWithCallStatus));
437 base::StringValue gateway("192.0.0.1");
438 DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
439 dbus::ObjectPath(kTestIPConfigPath),
440 shill::kGatewayProperty, gateway,
441 base::Bind(&DoNothingWithCallStatus));
442 message_loop_.RunUntilIdle();
443
444 // Add a service with an empty ipconfig and then update
445 // its ipconfig property.
446 const std::string kTestServicePath1("test_wifi_service1");
447 AddService(shill::kTypeWifi, kTestServicePath1, shill::kStateIdle, true);
448 message_loop_.RunUntilIdle();
449 // This is the initial property update.
450 EXPECT_EQ(1, listener_->initial_property_updates(
451 shill::kServicesProperty)[kTestServicePath1]);
452 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
453 dbus::ObjectPath(kTestServicePath1),
454 shill::kIPConfigProperty,
455 base::StringValue(kTestIPConfigPath),
456 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
457 message_loop_.RunUntilIdle();
458 // IPConfig property change on the service should trigger property updates for
459 // IP Address, DNS, prefixlen, and gateway.
460 EXPECT_EQ(4, listener_->property_updates(
461 shill::kServicesProperty)[kTestServicePath1]);
462
463 // Now, Add a new watched service with the IPConfig already set.
464 const std::string kTestServicePath2("test_wifi_service2");
465 AddServiceWithIPConfig(shill::kTypeWifi, kTestServicePath2,
466 shill::kStateIdle, kTestIPConfigPath, true);
467 message_loop_.RunUntilIdle();
468 // A watched service with the IPConfig property already set must trigger
469 // property updates for IP Address, DNS, prefixlen, and gateway when added.
470 EXPECT_EQ(4, listener_->property_updates(
471 shill::kServicesProperty)[kTestServicePath2]);
472 }
473
TEST_F(ShillPropertyHandlerTest,ShillPropertyHandlerServiceCompleteList)474 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceCompleteList) {
475 // Initial list updates.
476 EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
477 EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
478
479 // Add a new entry to the profile only; should trigger a single list update
480 // for both Services and ServiceCompleteList, and a single property update
481 // for ServiceCompleteList.
482 const std::string kTestServicePath1("stub_wifi_profile_only1");
483 AddServiceToProfile(shill::kTypeWifi, kTestServicePath1, false);
484 shill_property_handler_->UpdateManagerProperties();
485 message_loop_.RunUntilIdle();
486 EXPECT_EQ(2, listener_->list_updates(shill::kServicesProperty));
487 EXPECT_EQ(2, listener_->list_updates(shill::kServiceCompleteListProperty));
488 EXPECT_EQ(0, listener_->initial_property_updates(
489 shill::kServicesProperty)[kTestServicePath1]);
490 EXPECT_EQ(1, listener_->initial_property_updates(
491 shill::kServiceCompleteListProperty)[kTestServicePath1]);
492 EXPECT_EQ(0, listener_->property_updates(
493 shill::kServicesProperty)[kTestServicePath1]);
494 EXPECT_EQ(0, listener_->property_updates(
495 shill::kServiceCompleteListProperty)[kTestServicePath1]);
496
497 // Add a new entry to the services and the profile; should also trigger a
498 // single list update for both Services and ServiceCompleteList, and should
499 // trigger tow property updates for Services (one when the Profile propety
500 // changes, and one for the Request) and one ServiceCompleteList change for
501 // the Request.
502 const std::string kTestServicePath2("stub_wifi_profile_only2");
503 AddServiceToProfile(shill::kTypeWifi, kTestServicePath2, true);
504 shill_property_handler_->UpdateManagerProperties();
505 message_loop_.RunUntilIdle();
506 EXPECT_EQ(3, listener_->list_updates(shill::kServicesProperty));
507 EXPECT_EQ(3, listener_->list_updates(shill::kServiceCompleteListProperty));
508 EXPECT_EQ(1, listener_->initial_property_updates(
509 shill::kServicesProperty)[kTestServicePath2]);
510 EXPECT_EQ(1, listener_->initial_property_updates(
511 shill::kServiceCompleteListProperty)[kTestServicePath2]);
512 // Expect one property update for the Profile property of the Network.
513 EXPECT_EQ(1, listener_->property_updates(
514 shill::kServicesProperty)[kTestServicePath2]);
515 EXPECT_EQ(0, listener_->property_updates(
516 shill::kServiceCompleteListProperty)[kTestServicePath2]);
517
518 // Change a property of a Network in a Profile.
519 base::FundamentalValue scan_interval(3);
520 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
521 dbus::ObjectPath(kTestServicePath2),
522 shill::kScanIntervalProperty,
523 scan_interval,
524 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
525 message_loop_.RunUntilIdle();
526 // Property change should trigger an update for the Network only; no
527 // property updates pushed by Shill affect Favorites.
528 EXPECT_EQ(2, listener_->property_updates(
529 shill::kServicesProperty)[kTestServicePath2]);
530 EXPECT_EQ(0, listener_->property_updates(
531 shill::kServiceCompleteListProperty)[kTestServicePath2]);
532 }
533
534 } // namespace chromeos
535