Remove base::StringValue

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>
@@ skipping 528 matching lines @@
       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");
+  base::Value security_class_value("TestSecurityClass");
   SetServiceProperty(eth1, shill::kSecurityClassProperty, security_class_value);
   base::RunLoop().RunUntilIdle();
   ethernet = network_state_handler_->GetNetworkState(eth1);
   EXPECT_EQ("TestSecurityClass", ethernet->security_class());
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1));
 
   // Changing a service to the existing value should not trigger an update.
   SetServiceProperty(eth1, shill::kSecurityClassProperty, security_class_value);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1));
@@ skipping 67 matching lines @@
   network_state_handler_->SetTetherNetworkStateDisconnected(kTetherGuid1);
   EXPECT_FALSE(tether_network->IsConnectingState());
   EXPECT_FALSE(tether_network->IsConnectedState());
 }
 
 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);
+  base::Value connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(shill::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth1));
   EXPECT_EQ(1, 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);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, 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);
+  base::Value connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_idle_value);
   base::RunLoop().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());
 
   // Disconnect wifi.
   test_observer_->reset_change_counts();
   service_test_->SetServiceProperty(wifi1, shill::kStateProperty,
                                     connection_state_idle_value);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
   EXPECT_EQ("", test_observer_->default_network());
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceConnected) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   const std::string wifi1 = kShillManagerClientStubDefaultWifi;
 
   // Disconnect ethernet and wifi.
-  base::StringValue connection_state_idle_value(shill::kStateIdle);
+  base::Value connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_idle_value);
   service_test_->SetServiceProperty(wifi1, shill::kStateProperty,
                                     connection_state_idle_value);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(std::string(), test_observer_->default_network());
 
   // Connect ethernet, should become the default network.
   test_observer_->reset_change_counts();
-  base::StringValue connection_state_ready_value(shill::kStateReady);
+  base::Value connection_state_ready_value(shill::kStateReady);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_ready_value);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(eth1, test_observer_->default_network());
   EXPECT_EQ(shill::kStateReady,
             test_observer_->default_network_connection_state());
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   // The default service should be eth1.
   EXPECT_EQ(eth1, test_observer_->default_network());
 
   // Change the default network by changing Manager.DefaultService.
   // This should only generate one default network notification when the
   // DefaultService property changes.
   const std::string wifi1 = kShillManagerClientStubDefaultWifi;
   SetServiceProperty(eth1, shill::kStateProperty,
-                     base::StringValue(shill::kStateIdle));
+                     base::Value(shill::kStateIdle));
   manager_test_->SetManagerProperty(shill::kDefaultServiceProperty,
-                                    base::StringValue(wifi1));
+                                    base::Value(wifi1));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(wifi1, test_observer_->default_network());
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 
   // Change the state of the default network. This should generate a
   // default network notification.
   test_observer_->reset_change_counts();
   service_test_->SetServiceProperty(wifi1, shill::kStateProperty,
-                                    base::StringValue(shill::kStateReady));
+                                    base::Value(shill::kStateReady));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(shill::kStateReady,
             test_observer_->default_network_connection_state());
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 
   // Updating a property on the default network should also trigger
   // a default network change.
   test_observer_->reset_change_counts();
   SetServiceProperty(wifi1, shill::kSecurityClassProperty,
-                     base::StringValue("TestSecurityClass"));
+                     base::Value("TestSecurityClass"));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 
   // No default network updates for signal strength changes.
   test_observer_->reset_change_counts();
   SetServiceProperty(wifi1, shill::kSignalStrengthProperty, base::Value(32));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, test_observer_->default_network_change_count());
 
   // Change the default network to a Connecting network, then set the
   // state to Connected. The DefaultNetworkChange notification should only
   // fire once when the network is connected.
   test_observer_->reset_change_counts();
   SetServiceProperty(wifi1, shill::kStateProperty,
-                     base::StringValue(shill::kStateIdle));
+                     base::Value(shill::kStateIdle));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
   EXPECT_EQ(std::string(), test_observer_->default_network());
 
   const std::string wifi2 = kShillManagerClientStubWifi2;
   manager_test_->SetManagerProperty(shill::kDefaultServiceProperty,
-                                    base::StringValue(wifi2));
+                                    base::Value(wifi2));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
   // Change the connection state of the default network, observer should fire.
   SetServiceProperty(wifi2, shill::kStateProperty,
-                     base::StringValue(shill::kStateReady));
+                     base::Value(shill::kStateReady));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(wifi2, test_observer_->default_network());
   EXPECT_EQ(2u, test_observer_->default_network_change_count());
 }
 
 TEST_F(NetworkStateHandlerTest, RequestUpdate) {
   // Request an update for kShillManagerClientStubDefaultWifi.
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWifi));
   network_state_handler_->RequestUpdateForNetwork(
@@ skipping 101 matching lines @@
   ShillIPConfigClient::TestInterface* ip_config_test =
       DBusThreadManager::Get()->GetShillIPConfigClient()->GetTestInterface();
   const std::string kIPConfigPath = "test_ip_config";
   base::DictionaryValue ip_config_properties;
   ip_config_test->AddIPConfig(kIPConfigPath, ip_config_properties);
   base::ListValue device_ip_configs;
   device_ip_configs.AppendString(kIPConfigPath);
   device_test_->SetDeviceProperty(
       kShillManagerClientStubWifiDevice, shill::kIPConfigsProperty,
       device_ip_configs);
-  service_test_->SetServiceProperty(
-      kShillManagerClientStubDefaultWifi, shill::kIPConfigProperty,
-      base::StringValue(kIPConfigPath));
+  service_test_->SetServiceProperty(kShillManagerClientStubDefaultWifi,
+                                    shill::kIPConfigProperty,
+                                    base::Value(kIPConfigPath));
   UpdateManagerProperties();
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(
       kShillManagerClientStubWifiDevice));
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWifi));
 }
 
 }  // namespace chromeos