Cleanup network type matching.

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/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
+#include "chromeos/network/shill_property_util.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;
 }
@@ skipping 169 matching lines @@
 TEST_F(NetworkStateHandlerTest, NetworkStateHandlerStub) {
   // Ensure that the network list is the expected size.
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             test_observer_->network_count());
   // Ensure that the first stub network is the default network.
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             test_observer_->default_network());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
-                NetworkStateHandler::kMatchTypeDefault)->path());
+                NetworkTypePattern::Default())->path());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
-                flimflam::kTypeEthernet)->path());
+                NetworkTypePattern::Ethernet())->path());
   EXPECT_EQ(kShillManagerClientStubDefaultWireless,
             network_state_handler_->ConnectedNetworkByType(
-                NetworkStateHandler::kMatchTypeWireless)->path());
+                NetworkTypePattern::Wireless())->path());
+  EXPECT_EQ(kShillManagerClientStubCellular,
+            network_state_handler_->FirstNetworkByType(
+                NetworkTypePattern::Mobile())->path());
+  EXPECT_EQ(kShillManagerClientStubCellular,
+            network_state_handler_->FirstNetworkByType(
+                                        NetworkTypePattern::Primitive(
+                                            flimflam::kTypeCellular))->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();
   // Disable a technology.
   network_state_handler_->SetTechnologyEnabled(
-      flimflam::kTypeWimax, false, network_handler::ErrorCallback());
+      NetworkTypePattern::Primitive(flimflam::kTypeWimax),
+      false,
+      network_handler::ErrorCallback());
   EXPECT_NE(NetworkStateHandler::TECHNOLOGY_ENABLED,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
   EXPECT_EQ(initial_changed_count + 1, test_observer_->manager_changed_count());
   // Enable a technology.
   network_state_handler_->SetTechnologyEnabled(
-      flimflam::kTypeWimax, true, network_handler::ErrorCallback());
+      NetworkTypePattern::Primitive(flimflam::kTypeWimax),
+      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(NetworkStateHandler::TECHNOLOGY_ENABLING,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
   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(NetworkStateHandler::TECHNOLOGY_ENABLED,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyState) {
   ShillManagerClient::TestInterface* manager_test =
       DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
   manager_test->RemoveTechnology(flimflam::kTypeWimax);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 
   manager_test->AddTechnology(flimflam::kTypeWimax, false);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_AVAILABLE,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 
   manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, true);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNINITIALIZED,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 
   manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, false);
   network_state_handler_->SetTechnologyEnabled(
-      flimflam::kTypeWimax, true, network_handler::ErrorCallback());
+      NetworkTypePattern::Primitive(flimflam::kTypeWimax),
+      true,
+      network_handler::ErrorCallback());
   message_loop_.RunUntilIdle();
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_ENABLED,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 
   manager_test->RemoveTechnology(flimflam::kTypeWimax);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
-            network_state_handler_->GetTechnologyState(flimflam::kTypeWimax));
+            network_state_handler_->GetTechnologyState(
+                NetworkTypePattern::Primitive(flimflam::kTypeWimax)));
 }
 
 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) {
   // Set a service property.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   EXPECT_EQ("", network_state_handler_->GetNetworkState(eth1)->security());
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1));
   base::StringValue security_value("TestSecurity");
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(eth1),
@@ skipping 105 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