NetworkChangeNotifierChromeos: Handle IPConfig property changes on the default network

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 24 matching lines @@
 const std::string kShillManagerClientStubCellular = "stub_cellular";
 
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         manager_changed_count_(0),
-        network_count_(0) {
+        network_count_(0),
+        default_network_change_count_(0) {
   }
 
   virtual ~TestObserver() {
   }
 
   virtual void NetworkManagerChanged() OVERRIDE {
     ++manager_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_ = "";
     }
   }
 
   virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE {
+    ++default_network_change_count_;
     default_network_ = network ? network->path() : "";
     default_network_connection_state_ =
         network ?  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 manager_changed_count() { return manager_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_;
   }
 
   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 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);
 };
 
 }  // namespace
@@ skipping 35 matching lines @@
     device_test->AddDevice("/device/stub_cellular_device1",
                            flimflam::kTypeCellular, "stub_cellular_device1");
 
     ShillServiceClient::TestInterface* service_test =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     service_test->ClearServices();
     const bool add_to_watchlist = true;
     service_test->AddService(kShillManagerClientStubDefaultService,
                              kShillManagerClientStubDefaultService,
                              flimflam::kTypeEthernet, flimflam::kStateOnline,
-                             add_to_watchlist);
+                             "", add_to_watchlist);
     service_test->AddService(kShillManagerClientStubDefaultWireless,
                              kShillManagerClientStubDefaultWireless,
                              flimflam::kTypeWifi, flimflam::kStateOnline,
-                             add_to_watchlist);
+                             "", add_to_watchlist);
     service_test->AddService(kShillManagerClientStubWireless2,
                              kShillManagerClientStubWireless2,
                              flimflam::kTypeWifi, flimflam::kStateIdle,
-                             add_to_watchlist);
+                             "", add_to_watchlist);
     service_test->AddService(kShillManagerClientStubCellular,
                              kShillManagerClientStubCellular,
                              flimflam::kTypeCellular, flimflam::kStateIdle,
-                             add_to_watchlist);
+                             "", add_to_watchlist);

[stevenjb, 2013/03/27 22:18:52]

I don't like adding all of these "", especially since I forsee adding more tests
that use AddService() (see my earlier comment)

   }
 
   MessageLoopForUI message_loop_;
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<TestObserver> test_observer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest);
 };
 
@@ skipping 91 matching lines @@
   const std::string wifi1 = "stub_wifi1";
   manager_test->AddServiceAtIndex(wifi1, 0, true);
   const std::string eth0 = "stub_ethernet";
   base::StringValue connection_state_idle_value(flimflam::kStateIdle);
   service_test->SetServiceProperty(eth0, flimflam::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(wifi1, test_observer_->default_network());
   EXPECT_EQ(flimflam::kStateOnline,
             test_observer_->default_network_connection_state());
+  // We should have seen 2 default network updates - for the default
+  // service change, and for the state change.
+  EXPECT_EQ(2u, test_observer_->default_network_change_count());
+
+  // Updating a property on the default network should trigger
+  // a default network change.
+  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
+      dbus::ObjectPath(wifi1),
+      flimflam::kSecurityProperty, base::StringValue("TestSecurity"),
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(3u, test_observer_->default_network_change_count());
+
+  // No default network updates for signal strength changes.
+  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
+      dbus::ObjectPath(wifi1),
+      flimflam::kSignalStrengthProperty, base::FundamentalValue(32),
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(3u, test_observer_->default_network_change_count());
 }
 
 }  // namespace chromeos