Remove base::FundamentalValue

chromeos/network/network_device_handler_unittest.cc

 // Copyright 2013 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 <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 110 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
   std::string type;
   properties_->GetString(shill::kTypeProperty, &type);
   EXPECT_EQ(shill::kTypeWifi, type);
 }
 
 TEST_F(NetworkDeviceHandlerTest, SetDeviceProperty) {
   // Set the shill::kScanIntervalProperty to true. The call
   // should succeed and the value should be set.
-  network_device_handler_->SetDeviceProperty(kDefaultCellularDevicePath,
-                                             shill::kScanIntervalProperty,
-                                             base::FundamentalValue(1),
-                                             success_callback_,
-                                             error_callback_);
+  network_device_handler_->SetDeviceProperty(
+      kDefaultCellularDevicePath, shill::kScanIntervalProperty, base::Value(1),
+      success_callback_, error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
 
   // GetDeviceProperties should return the value set by SetDeviceProperty.
   network_device_handler_->GetDeviceProperties(kDefaultCellularDevicePath,
                                                properties_success_callback_,
                                                error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
   int interval = 0;
   EXPECT_TRUE(properties_->GetIntegerWithoutPathExpansion(
       shill::kScanIntervalProperty, &interval));
   EXPECT_EQ(1, interval);
 
   // Repeat the same with value false.
-  network_device_handler_->SetDeviceProperty(kDefaultCellularDevicePath,
-                                             shill::kScanIntervalProperty,
-                                             base::FundamentalValue(2),
-                                             success_callback_,
-                                             error_callback_);
+  network_device_handler_->SetDeviceProperty(
+      kDefaultCellularDevicePath, shill::kScanIntervalProperty, base::Value(2),
+      success_callback_, error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
 
   network_device_handler_->GetDeviceProperties(kDefaultCellularDevicePath,
                                                properties_success_callback_,
                                                error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
   EXPECT_TRUE(properties_->GetIntegerWithoutPathExpansion(
       shill::kScanIntervalProperty, &interval));
   EXPECT_EQ(2, interval);
 
   // Set property on an invalid path.
-  network_device_handler_->SetDeviceProperty(kUnknownCellularDevicePath,
-                                             shill::kScanIntervalProperty,
-                                             base::FundamentalValue(1),
-                                             success_callback_,
-                                             error_callback_);
+  network_device_handler_->SetDeviceProperty(
+      kUnknownCellularDevicePath, shill::kScanIntervalProperty, base::Value(1),
+      success_callback_, error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);
 
   // Setting a owner-protected device property through SetDeviceProperty must
   // fail.
   network_device_handler_->SetDeviceProperty(
-      kDefaultCellularDevicePath,
-      shill::kCellularAllowRoamingProperty,
-      base::FundamentalValue(true),
-      success_callback_,
-      error_callback_);
+      kDefaultCellularDevicePath, shill::kCellularAllowRoamingProperty,
+      base::Value(true), success_callback_, error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_NE(kResultSuccess, result_);
 }
 
 TEST_F(NetworkDeviceHandlerTest, CellularAllowRoaming) {
   // Start with disabled data roaming.
   ShillDeviceClient::TestInterface* device_test =
       fake_device_client_->GetTestInterface();
   device_test->SetDeviceProperty(kDefaultCellularDevicePath,
                                  shill::kCellularAllowRoamingProperty,
-                                 base::FundamentalValue(false));
+                                 base::Value(false));
 
   network_device_handler_->SetCellularAllowRoaming(true);
   base::RunLoop().RunUntilIdle();
 
   // Roaming should be enabled now.
   network_device_handler_->GetDeviceProperties(kDefaultCellularDevicePath,
                                                properties_success_callback_,
                                                error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kResultSuccess, result_);
@@ skipping 185 matching lines @@
 
   // Test that the shill error propagates to the error callback.
   network_device_handler_->ChangePin(kDefaultCellularDevicePath, kIncorrectPin,
                                      kNewPin, success_callback_,
                                      error_callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NetworkDeviceHandler::kErrorIncorrectPin, result_);
 }
 
 }  // namespace chromeos