Rely on Service.Visible instead of Manager.Services

chromeos/network/network_state_handler_unittest.cc

 // Copyright (c) 2012 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/network/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 27 matching lines @@
 
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         device_list_changed_count_(0),
         device_count_(0),
+        network_list_changed_count_(0),
         network_count_(0),
         default_network_change_count_(0) {
   }
 
   virtual ~TestObserver() {
   }
 
   virtual void DeviceListChanged() OVERRIDE {
     NetworkStateHandler::DeviceStateList devices;
     handler_->GetDeviceList(&devices);
     device_count_ = devices.size();
     ++device_list_changed_count_;
   }
 
   virtual void NetworkListChanged() OVERRIDE {
     NetworkStateHandler::NetworkStateList networks;
     handler_->GetNetworkListByType(chromeos::NetworkTypePattern::Default(),
                                    false /* configured_only */,
                                    false /* visible_only */,
                                    0 /* no limit */,
                                    &networks);
     network_count_ = networks.size();
     if (network_count_ == 0) {
       default_network_ = "";
       default_network_connection_state_ = "";
     }
+    ++network_list_changed_count_;
   }
 
   virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE {
     ++default_network_change_count_;
     default_network_ = network ? network->path() : "";
     default_network_connection_state_ =
         network ? network->connection_state() : "";
     DVLOG(1) << "DefaultNetworkChanged: " << default_network_
              << " State: " << default_network_connection_state_;
   }
 
   virtual void NetworkConnectionStateChanged(
       const NetworkState* network) OVERRIDE {
     network_connection_state_[network->path()] = network->connection_state();
     connection_state_changes_[network->path()]++;
   }
 
   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE {
     DCHECK(network);
     property_updates_[network->path()]++;
   }
 
   size_t device_list_changed_count() { return device_list_changed_count_; }
   size_t device_count() { return device_count_; }
+  size_t network_list_changed_count() { return network_list_changed_count_; }
   size_t network_count() { return network_count_; }
   size_t default_network_change_count() {
     return default_network_change_count_;
   }
   void reset_change_counts() {
     DVLOG(1) << "=== RESET CHANGE COUNTS ===";
     default_network_change_count_ = 0;
     device_list_changed_count_ = 0;
+    network_list_changed_count_ = 0;
   }
   std::string default_network() { return default_network_; }
   std::string default_network_connection_state() {
     return default_network_connection_state_;
   }
 
   int PropertyUpdatesForService(const std::string& service_path) {
     return property_updates_[service_path];
   }
 
   int ConnectionStateChangesForService(const std::string& service_path) {
     return connection_state_changes_[service_path];
   }
 
   std::string NetworkConnectionStateForService(
       const std::string& service_path) {
     return network_connection_state_[service_path];
   }
 
  private:
   NetworkStateHandler* handler_;
   size_t device_list_changed_count_;
   size_t device_count_;
+  size_t network_list_changed_count_;
   size_t network_count_;
   size_t default_network_change_count_;
   std::string default_network_;
   std::string default_network_connection_state_;
   std::map<std::string, int> property_updates_;
   std::map<std::string, int> connection_state_changes_;
   std::map<std::string, std::string> network_connection_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
@@ skipping 180 matching lines @@
   EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size());
   // Get configured (profile) networks.
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
                                                true /* configured_only */,
                                                false /* visible_only */,
                                                0 /* no limit */,
                                                &networks);
   EXPECT_EQ(1u, networks.size());
 }
 
+TEST_F(NetworkStateHandlerTest, NetworkListChanged) {
+  size_t stub_network_count = test_observer_->network_count();
+  // Set up two additional visible networks.
+  const std::string wifi3 = "/service/wifi3";
+  const std::string wifi4 = "/service/wifi4";
+  service_test_->SetServiceProperties(
+      wifi3, "wifi3_guid", "wifi3",
+      shill::kTypeWifi, shill::kStateIdle, true /* visible */);
+  service_test_->SetServiceProperties(
+      wifi4, "wifi4_guid", "wifi4",
+      shill::kTypeWifi, shill::kStateIdle, true /* visible */);
+  // Add the services to the Manager. Only notify when the second service is
+  // added.
+  manager_test_->AddManagerService(wifi3, false);
+  manager_test_->AddManagerService(wifi4, true);
+  UpdateManagerProperties();
+  // Expect two service updates and one list update.
+  EXPECT_EQ(stub_network_count + 2, test_observer_->network_count());
+  EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(wifi3));
+  EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(wifi4));
+  EXPECT_EQ(1u, test_observer_->network_list_changed_count());
+}
+
 TEST_F(NetworkStateHandlerTest, GetVisibleNetworks) {
   // Ensure that the network list is the expected size.
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             test_observer_->network_count());
   // Add a non-visible network to the profile.
   const std::string profile = "/profile/profile1";
   const std::string wifi_favorite_path = "/service/wifi_faviorite";
   service_test_->AddService(wifi_favorite_path, "wifi_faviorite",
                             shill::kTypeWifi, shill::kStateIdle,
@@ skipping 330 matching lines @@
   // the NetworkState was created with the same GUID.
   AddService(wifi_path, wifi_path, shill::kTypeWifi, shill::kStateOnline);
   UpdateManagerProperties();
   network = network_state_handler_->GetNetworkStateFromServicePath(
       wifi_path, is_service_configured);
   ASSERT_TRUE(network);
   EXPECT_EQ(wifi_guid, network->guid());
 }
 
 }  // namespace chromeos