Eliminate NetworkManagerChanged

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 25 matching lines @@
 const std::string kShillManagerClientStubWireless2 = "wifi2";
 const std::string kShillManagerClientStubCellular = "cellular1";
 
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
-        manager_changed_count_(0),
+        device_list_changed_count_(0),
         network_count_(0),
         default_network_change_count_(0),
         favorite_count_(0) {
   }
 
   virtual ~TestObserver() {
   }
 
-  virtual void NetworkManagerChanged() OVERRIDE {
-    ++manager_changed_count_;
+  virtual void DeviceListChanged() OVERRIDE {
+    ++device_list_changed_count_;
   }
 
   virtual void NetworkListChanged() OVERRIDE {
     NetworkStateHandler::NetworkStateList networks;
     handler_->GetNetworkList(&networks);
     network_count_ = networks.size();
     if (network_count_ == 0) {
       default_network_ = "";
       default_network_connection_state_ = "";
     }
@@ skipping 13 matching lines @@
       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 manager_changed_count() { return manager_changed_count_; }
+  size_t device_list_changed_count() { return device_list_changed_count_; }
   size_t network_count() { return network_count_; }
   size_t default_network_change_count() {
     return default_network_change_count_;
   }
   std::string default_network() { return default_network_; }
   std::string default_network_connection_state() {
     return default_network_connection_state_;
   }
   size_t favorite_count() { return favorite_count_; }
 
   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 manager_changed_count_;
+  size_t device_list_changed_count_;
   size_t network_count_;
   size_t default_network_change_count_;
   std::string default_network_;
   std::string default_network_connection_state_;
   size_t favorite_count_;
   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 95 matching lines @@
   EXPECT_EQ(
       kShillManagerClientStubCellular,
       network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular())
           ->path());
   EXPECT_EQ(flimflam::kStateOnline,
             test_observer_->default_network_connection_state());
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyChanged) {
   // There may be several manager changes during initialization.
-  size_t initial_changed_count = test_observer_->manager_changed_count();
+  size_t initial_changed_count = test_observer_->device_list_changed_count();
   // Disable a technology.
   network_state_handler_->SetTechnologyEnabled(
       NetworkTypePattern::Wimax(), false, network_handler::ErrorCallback());
   EXPECT_NE(
       NetworkStateHandler::TECHNOLOGY_ENABLED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
-  EXPECT_EQ(initial_changed_count + 1, test_observer_->manager_changed_count());
+  EXPECT_EQ(initial_changed_count + 1,
+            test_observer_->device_list_changed_count());
   // Enable a technology.
   network_state_handler_->SetTechnologyEnabled(
       NetworkTypePattern::Wimax(), true, network_handler::ErrorCallback());
   // The technology state should immediately change to ENABLING and we should
   // receive a manager changed callback.
-  EXPECT_EQ(initial_changed_count + 2, test_observer_->manager_changed_count());
+  EXPECT_EQ(initial_changed_count + 2,
+            test_observer_->device_list_changed_count());
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_ENABLING,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
   message_loop_.RunUntilIdle();
   // Ensure we receive 2 manager changed callbacks when the technology becomes
   // avalable and enabled.
-  EXPECT_EQ(initial_changed_count + 4, test_observer_->manager_changed_count());
+  EXPECT_EQ(initial_changed_count + 4,
+            test_observer_->device_list_changed_count());
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_ENABLED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyState) {
   ShillManagerClient::TestInterface* manager_test =
       DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
   manager_test->RemoveTechnology(flimflam::kTypeWimax);
   message_loop_.RunUntilIdle();
@@ skipping 144 matching lines @@
   // Other networks should have 2 updates (inital + request).
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultService));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubWireless2));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubCellular));
 }
 
 }  // namespace chromeos