Merge FavoriteState into NetworkState

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>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
-#include "chromeos/network/favorite_state.h"
 #include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "dbus/object_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 void ErrorCallbackFunction(const std::string& error_name,
                            const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 const std::string kShillManagerClientStubDefaultService = "/service/eth1";
 const std::string kShillManagerClientStubDefaultWifi = "/service/wifi1";
 const std::string kShillManagerClientStubWifi2 = "/service/wifi2";
 const std::string kShillManagerClientStubCellular = "/service/cellular1";
 
 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_count_(0),
-        default_network_change_count_(0),
-        favorite_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_->GetNetworkList(&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_ = "";
     }
-    NetworkStateHandler::FavoriteStateList favorites;
-    handler_->GetFavoriteList(&favorites);
-    favorite_count_ = favorites.size();
   }
 
   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_;
   }
@@ skipping 17 matching lines @@
   }
   void reset_change_counts() {
     DVLOG(1) << "=== RESET CHANGE COUNTS ===";
     default_network_change_count_ = 0;
     device_list_changed_count_ = 0;
   }
   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 device_list_changed_count_;
   size_t device_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);
 };
 
 }  // namespace
 
 namespace chromeos {
@@ skipping 73 matching lines @@
                shill::kTypeWifi,
                shill::kStateIdle);
     AddService(kShillManagerClientStubCellular,
                "cellular1",
                shill::kTypeCellular,
                shill::kStateIdle);
   }
 
   void UpdateManagerProperties() {
     message_loop_.RunUntilIdle();
-    network_state_handler_->UpdateManagerProperties();
-    message_loop_.RunUntilIdle();
   }
 
   base::MessageLoopForUI message_loop_;
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<TestObserver> test_observer_;
   ShillDeviceClient::TestInterface* device_test_;
   ShillManagerClient::TestInterface* manager_test_;
   ShillProfileClient::TestInterface* profile_test_;
   ShillServiceClient::TestInterface* service_test_;
 
@@ skipping 25 matching lines @@
             network_state_handler_->FirstNetworkByType(
                 NetworkTypePattern::Mobile())->path());
   EXPECT_EQ(
       kShillManagerClientStubCellular,
       network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular())
           ->path());
   EXPECT_EQ(shill::kStateOnline,
             test_observer_->default_network_connection_state());
 }
 
+TEST_F(NetworkStateHandlerTest, GetNetworkList) {
+  // 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,
+                            false /* add_to_visible */);
+  profile_test_->AddProfile(profile, "" /* userhash */);
+  EXPECT_TRUE(profile_test_->AddService(profile, wifi_favorite_path));
+  UpdateManagerProperties();
+  message_loop_.RunUntilIdle();
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
+            test_observer_->network_count());
+
+  // Get all networks.
+  NetworkStateHandler::NetworkStateList networks;
+  network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
+                                               false /* configured_only */,
+                                               false /* visible_only */,
+                                               0 /* no limit */,
+                                               &networks);
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, networks.size());
+  // Limit number of results.
+  network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
+                                               false /* configured_only */,
+                                               false /* visible_only */,
+                                               2 /* limit */,
+                                               &networks);
+  EXPECT_EQ(2u, networks.size());
+  // Get all wifi networks.
+  network_state_handler_->GetNetworkListByType(NetworkTypePattern::WiFi(),
+                                               false /* configured_only */,
+                                               false /* visible_only */,
+                                               0 /* no limit */,
+                                               &networks);
+  EXPECT_EQ(3u, networks.size());
+  // Get visible networks.
+  network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
+                                               false /* configured_only */,
+                                               true /* visible_only */,
+                                               0 /* no limit */,
+                                               &networks);
+  EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size());
+  network_state_handler_->GetVisibleNetworkList(&networks);
+  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, TechnologyChanged) {
   // Disable a technology. Will immediately set the state to AVAILABLE and
   // notify observers.
   network_state_handler_->SetTechnologyEnabled(
       NetworkTypePattern::WiFi(), false, network_handler::ErrorCallback());
   EXPECT_EQ(1u, test_observer_->device_list_changed_count());
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_AVAILABLE,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::WiFi()));
 
@@ skipping 87 matching lines @@
 
 TEST_F(NetworkStateHandlerTest, GetState) {
   const std::string profile = "/profile/profile1";
   const std::string wifi_path = kShillManagerClientStubDefaultWifi;
 
   // Add a wifi service to a Profile.
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
   UpdateManagerProperties();
 
-  // Ensure that a NetworkState and corresponding FavoriteState exist.
+  // Ensure that a NetworkState exists.
   const NetworkState* wifi_network =
-      network_state_handler_->GetNetworkState(wifi_path);
+      network_state_handler_->GetNetworkStateFromServicePath(
+          wifi_path, true /* configured_only */);
   ASSERT_TRUE(wifi_network);
-  const FavoriteState* wifi_favorite =
-      network_state_handler_->GetFavoriteStateFromServicePath(
-          wifi_path, true /* configured_only */);
-  ASSERT_TRUE(wifi_favorite);
-  EXPECT_EQ(wifi_network->path(), wifi_favorite->path());
-
-  // Ensure that we are notified that a Favorite was added.
-  EXPECT_EQ(1u, test_observer_->favorite_count());
 
   // Test looking up by GUID.
-  ASSERT_FALSE(wifi_favorite->guid().empty());
-  const FavoriteState* wifi_favorite_guid =
-      network_state_handler_->GetFavoriteStateFromGuid(wifi_favorite->guid());
-  EXPECT_EQ(wifi_favorite, wifi_favorite_guid);
+  ASSERT_FALSE(wifi_network->guid().empty());
+  const NetworkState* wifi_network_guid =
+      network_state_handler_->GetNetworkStateFromGuid(wifi_network->guid());
+  EXPECT_EQ(wifi_network, wifi_network_guid);
 
   // Remove the service, verify that there is no longer a NetworkState for it.
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
   EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path));
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
   // Change a network state.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(shill::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth1));
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
   // Confirm that changing the connection state to the same value does *not*
   // signal the observer.
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceDisconnected) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   const std::string wifi1 = kShillManagerClientStubDefaultWifi;
 
+  EXPECT_EQ(0u, test_observer_->default_network_change_count());
   // Disconnect ethernet.
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_idle_value);
   message_loop_.RunUntilIdle();
   // Expect two changes: first when eth1 becomes disconnected, second when
   // wifi1 becomes the default.
   EXPECT_EQ(2u, test_observer_->default_network_change_count());
   EXPECT_EQ(wifi1, test_observer_->default_network());
 
@@ skipping 98 matching lines @@
       wifi_guid,
       wifi_path  /* name */,
       shill::kTypeWifi,
       shill::kStateOnline,
       "" /* ipconfig_path */,
       true /* add_to_visible */);
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
   UpdateManagerProperties();
 
-  // Verify that a FavoriteState exists with a matching GUID.
-  const FavoriteState* favorite =
-      network_state_handler_->GetFavoriteStateFromServicePath(
+  // Verify that a NetworkState exists with a matching GUID.
+  const NetworkState* network =
+      network_state_handler_->GetNetworkStateFromServicePath(
           wifi_path, is_service_configured);
-  ASSERT_TRUE(favorite);
-  EXPECT_EQ(wifi_guid, favorite->guid());
-
-  // Verify that a NetworkState exists with the same GUID.
-  const NetworkState* network =
-      network_state_handler_->GetNetworkState(wifi_path);
   ASSERT_TRUE(network);
   EXPECT_EQ(wifi_guid, network->guid());
 
   // Remove the service (simulating a network going out of range).
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
   EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path));
 
   // Add the service (simulating a network coming back in range) and verify that
   // the NetworkState was created with the same GUID.
   AddService(wifi_path, wifi_path, shill::kTypeWifi, shill::kStateOnline);
   UpdateManagerProperties();
-  network = network_state_handler_->GetNetworkState(wifi_path);
+  network = network_state_handler_->GetNetworkStateFromServicePath(
+      wifi_path, is_service_configured);
   ASSERT_TRUE(network);
   EXPECT_EQ(wifi_guid, network->guid());
-
-  // Also verify FavoriteState (mostly to test the stub behavior).
-  favorite = network_state_handler_->GetFavoriteStateFromServicePath(
-      wifi_path, is_service_configured);
-  ASSERT_TRUE(favorite);
-  EXPECT_EQ(wifi_guid, favorite->guid());
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkGuidNotInProfile) {
   const std::string wifi_path = "/service/wifi_with_guid";
   const bool is_service_configured = false;
 
   // Add a network without adding it to a profile.
   AddService(wifi_path, wifi_path, shill::kTypeWifi, shill::kStateOnline);
   UpdateManagerProperties();
 
-  // Verify that a FavoriteState exists with an assigned GUID.
-  const FavoriteState* favorite =
-      network_state_handler_->GetFavoriteStateFromServicePath(
+  // Verify that a NetworkState exists with an assigned GUID.
+  const NetworkState* network =
+      network_state_handler_->GetNetworkStateFromServicePath(
           wifi_path, is_service_configured);
-  ASSERT_TRUE(favorite);
-  std::string wifi_guid = favorite->guid();
+  ASSERT_TRUE(network);
+  std::string wifi_guid = network->guid();
   EXPECT_FALSE(wifi_guid.empty());
 
-  // Verify that a NetworkState exists with the same GUID.
-  const NetworkState* network =
-      network_state_handler_->GetNetworkState(wifi_path);
-  ASSERT_TRUE(network);
-  EXPECT_EQ(wifi_guid, network->guid());
-
   // Remove the service (simulating a network going out of range).
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
   EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path));
 
   // Add the service (simulating a network coming back in range) and verify that
   // the NetworkState was created with the same GUID.
   AddService(wifi_path, wifi_path, shill::kTypeWifi, shill::kStateOnline);
   UpdateManagerProperties();
-  network = network_state_handler_->GetNetworkState(wifi_path);
+  network = network_state_handler_->GetNetworkStateFromServicePath(
+      wifi_path, is_service_configured);
   ASSERT_TRUE(network);
   EXPECT_EQ(wifi_guid, network->guid());
-
-  // Also verify FavoriteState (mostly to test the stub behavior).
-  favorite = network_state_handler_->GetFavoriteStateFromServicePath(
-      wifi_path, is_service_configured);
-  ASSERT_TRUE(favorite);
-  EXPECT_EQ(wifi_guid, favorite->guid());
 }
 
 }  // namespace chromeos