Remove base::StringValue

chrome/browser/chromeos/policy/device_status_collector_browsertest.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 "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 1377 matching lines @@
     chromeos::NetworkHandler::Initialize();
     chromeos::ShillDeviceClient::TestInterface* test_device_client =
         chromeos::DBusThreadManager::Get()->GetShillDeviceClient()->
             GetTestInterface();
     test_device_client->ClearDevices();
     for (size_t i = 0; i < arraysize(kFakeDevices); ++i) {
       const FakeDeviceData& dev = kFakeDevices[i];
       test_device_client->AddDevice(dev.device_path, dev.type,
                                     dev.object_path);
       if (*dev.mac_address) {
-        test_device_client->SetDeviceProperty(
-            dev.device_path, shill::kAddressProperty,
-            base::StringValue(dev.mac_address));
+        test_device_client->SetDeviceProperty(dev.device_path,
+                                              shill::kAddressProperty,
+                                              base::Value(dev.mac_address));
       }
       if (*dev.meid) {
         test_device_client->SetDeviceProperty(
-            dev.device_path, shill::kMeidProperty,
-            base::StringValue(dev.meid));
+            dev.device_path, shill::kMeidProperty, base::Value(dev.meid));
       }
       if (*dev.imei) {
         test_device_client->SetDeviceProperty(
-            dev.device_path, shill::kImeiProperty,
-            base::StringValue(dev.imei));
+            dev.device_path, shill::kImeiProperty, base::Value(dev.imei));
       }
     }
 
     chromeos::ShillServiceClient::TestInterface* service_client =
         chromeos::DBusThreadManager::Get()->GetShillServiceClient()->
             GetTestInterface();
     service_client->ClearServices();
 
     // Now add services for every fake network.
     for (const FakeNetworkState& fake_network : kFakeNetworks) {
       // Shill forces non-visible networks to report a disconnected state.
       bool is_visible =
           fake_network.connection_status != shill::kStateDisconnect;
       service_client->AddService(
           fake_network.name,       /* service_path */
           fake_network.name        /* guid */,
           fake_network.name        /* name */,
           fake_network.type        /* type */,
           fake_network.connection_status,
           is_visible);
       service_client->SetServiceProperty(
           fake_network.name, shill::kSignalStrengthProperty,
           base::Value(fake_network.signal_strength));
-      service_client->SetServiceProperty(
-          fake_network.name, shill::kDeviceProperty,
-          base::StringValue(fake_network.device_path));
+      service_client->SetServiceProperty(fake_network.name,
+                                         shill::kDeviceProperty,
+                                         base::Value(fake_network.device_path));
       // Set the profile so this shows up as a configured network.
-      service_client->SetServiceProperty(
-          fake_network.name, shill::kProfileProperty,
-          base::StringValue(fake_network.name));
+      service_client->SetServiceProperty(fake_network.name,
+                                         shill::kProfileProperty,
+                                         base::Value(fake_network.name));
       if (strlen(fake_network.address) > 0) {
         // Set the IP config.
         base::DictionaryValue ip_config_properties;
         ip_config_properties.SetStringWithoutPathExpansion(
             shill::kAddressProperty, fake_network.address);
         ip_config_properties.SetStringWithoutPathExpansion(
             shill::kGatewayProperty, fake_network.gateway);
         chromeos::ShillIPConfigClient::TestInterface* ip_config_test =
             chromeos::DBusThreadManager::Get()->GetShillIPConfigClient()->
             GetTestInterface();
         const std::string kIPConfigPath = "test_ip_config";
         ip_config_test->AddIPConfig(kIPConfigPath, ip_config_properties);
-        service_client->SetServiceProperty(
-            fake_network.name, shill::kIPConfigProperty,
-            base::StringValue(kIPConfigPath));
+        service_client->SetServiceProperty(fake_network.name,
+                                           shill::kIPConfigProperty,
+                                           base::Value(kIPConfigPath));
       }
     }
 
     // Now add an unconfigured network - it should not show up in the
     // reported list of networks because it doesn't have a profile specified.
     service_client->AddService(
         kUnconfiguredNetwork.name,       /* service_path */
         kUnconfiguredNetwork.name        /* guid */,
         kUnconfiguredNetwork.name        /* name */,
         kUnconfiguredNetwork.type        /* type */,
         kUnconfiguredNetwork.connection_status,
         true /* visible */);
     service_client->SetServiceProperty(
         kUnconfiguredNetwork.name, shill::kSignalStrengthProperty,
         base::Value(kUnconfiguredNetwork.signal_strength));
     service_client->SetServiceProperty(
         kUnconfiguredNetwork.name, shill::kDeviceProperty,
-        base::StringValue(kUnconfiguredNetwork.device_path));
+        base::Value(kUnconfiguredNetwork.device_path));
 
     // Flush out pending state updates.
     base::RunLoop().RunUntilIdle();
 
     chromeos::NetworkStateHandler::NetworkStateList state_list;
     chromeos::NetworkStateHandler* network_state_handler =
         chromeos::NetworkHandler::Get()->network_state_handler();
     network_state_handler->GetNetworkListByType(
         chromeos::NetworkTypePattern::Default(),
         true,   // configured_only
@@ skipping 108 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy