Create a Tether section in the system tray network list.

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 <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/values.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_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/device_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 char kShillManagerClientStubWifiDevice[] = "/device/stub_wifi_device1";
 const char kShillManagerClientStubCellularDevice[] =
     "/device/stub_cellular_device1";
 const char kShillManagerClientStubDefaultService[] = "/service/eth1";
 const char kShillManagerClientStubDefaultWifi[] = "/service/wifi1";
 const char kShillManagerClientStubWifi2[] = "/service/wifi2";
 const char kShillManagerClientStubCellular[] = "/service/cellular1";
 
-const char kTetherName[] = "Device";
+const char kTetherGuid1[] = "tether1";
+const char kTetherGuid2[] = "tether2";
+const char kTetherName1[] = "Device1";
+const char kTetherName2[] = "Device2";
 
 using chromeos::DeviceState;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         device_list_changed_count_(0),
@@ skipping 305 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, GetTetherNetworkList) {
+  NetworkStateHandler::NetworkStateList tether_networks;
+
+  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
+                                               &tether_networks);
+  EXPECT_EQ(0u, tether_networks.size());
+
+  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+
+  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
+                                               &tether_networks);
+  EXPECT_EQ(1u, tether_networks.size());
+
+  network_state_handler_->AddTetherNetworkState(kTetherGuid2, kTetherName2);
+
+  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
+                                               &tether_networks);
+  EXPECT_EQ(2u, tether_networks.size());
+
+  network_state_handler_->GetTetherNetworkList(1 /* no limit */,
+                                               &tether_networks);
+  EXPECT_EQ(1u, tether_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",
@@ skipping 106 matching lines @@
       NetworkStateHandler::TECHNOLOGY_ENABLED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 
   manager_test_->RemoveTechnology(shill::kTypeWimax);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 }
 
+TEST_F(NetworkStateHandlerTest, TetherTechnologyState) {
+  EXPECT_EQ(
+      NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
+      network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether()));
+
+  base::CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kEnableTether);
+
+  EXPECT_EQ(
+      NetworkStateHandler::TECHNOLOGY_ENABLED,
+      network_state_handler_->GetTechnologyState(NetworkTypePattern::Tether()));
+}
+
 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) {
   // Set a service property.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   const NetworkState* ethernet = network_state_handler_->GetNetworkState(eth1);
   ASSERT_TRUE(ethernet);
   EXPECT_EQ("", ethernet->security_class());
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1));
   base::StringValue security_class_value("TestSecurityClass");
   SetServiceProperty(eth1, shill::kSecurityClassProperty, security_class_value);
   base::RunLoop().RunUntilIdle();
@@ skipping 30 matching lines @@
 
   // 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, TetherNetworkState) {
   EXPECT_EQ(0u, test_observer_->network_list_changed_count());
 
-  const std::string& guid =
-      network_state_handler_->CreateTetherNetworkState(kTetherName);
+  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
 
   EXPECT_EQ(1u, test_observer_->network_list_changed_count());
 
   const NetworkState* tether_network =
-      network_state_handler_->GetNetworkStateFromGuid(guid);
+      network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
   ASSERT_TRUE(tether_network);
-  EXPECT_EQ(kTetherName, tether_network->name());
+  EXPECT_EQ(kTetherName1, tether_network->name());
 
-  network_state_handler_->RemoveTetherNetworkState(guid);
+  network_state_handler_->RemoveTetherNetworkState(kTetherGuid1);
 
   EXPECT_EQ(2u, test_observer_->network_list_changed_count());
 
-  ASSERT_FALSE(network_state_handler_->GetNetworkStateFromGuid(guid));
+  ASSERT_FALSE(network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1));
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   EXPECT_EQ(0, test_observer_->ConnectionStateChangesForService(eth1));
 
   // Change a network state.
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
@@ skipping 243 matching lines @@
       kShillManagerClientStubDefaultWifi, shill::kIPConfigProperty,
       base::StringValue(kIPConfigPath));
   UpdateManagerProperties();
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(
       kShillManagerClientStubWifiDevice));
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWifi));
 }
 
 }  // namespace chromeos