Remove base::FundamentalValue

chromeos/dbus/fake_shill_manager_client.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 "chromeos/dbus/fake_shill_manager_client.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 183 matching lines @@
                                          const ErrorCallback& error_callback) {
   VLOG(1) << "RequestScan: " << type;
   // For Stub purposes, default to a Wifi scan.
   std::string device_type = shill::kTypeWifi;
   if (!type.empty())
     device_type = type;
   ShillDeviceClient::TestInterface* device_client =
       DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
   std::string device_path = device_client->GetDevicePathForType(device_type);
   if (!device_path.empty()) {
-    device_client->SetDeviceProperty(
-        device_path, shill::kScanningProperty, base::FundamentalValue(true));
+    device_client->SetDeviceProperty(device_path, shill::kScanningProperty,
+                                     base::Value(true));
   }
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::ScanCompleted,
                  weak_ptr_factory_.GetWeakPtr(), device_path, callback),
       base::TimeDelta::FromSeconds(interactive_delay_));
 }
 
 void FakeShillManagerClient::EnableTechnology(
     const std::string& type,
@@ skipping 480 matching lines @@
     const std::string kWifi1Path = "/service/wifi1";
     services->AddService(kWifi1Path,
                          "wifi1_guid",
                          "wifi1" /* name */,
                          shill::kTypeWifi,
                          state,
                          add_to_visible);
     services->SetServiceProperty(kWifi1Path,
                                  shill::kSecurityClassProperty,
                                  base::StringValue(shill::kSecurityWep));
-    services->SetServiceProperty(kWifi1Path,
-                                 shill::kConnectableProperty,
-                                 base::FundamentalValue(true));
+    services->SetServiceProperty(kWifi1Path, shill::kConnectableProperty,
+                                 base::Value(true));
     profiles->AddService(shared_profile, kWifi1Path);
 
     const std::string kWifi2Path = "/service/wifi2";
     services->AddService(kWifi2Path, "wifi2_guid",
                          s_dynamic_wep ? "wifi2_WEP" : "wifi2_PSK" /* name */,
                          shill::kTypeWifi, shill::kStateIdle, add_to_visible);
     if (s_dynamic_wep) {
       services->SetServiceProperty(kWifi2Path, shill::kSecurityClassProperty,
                                    base::StringValue(shill::kSecurityWep));
       services->SetServiceProperty(
           kWifi2Path, shill::kEapKeyMgmtProperty,
           base::StringValue(shill::kKeyManagementIEEE8021X));
       services->SetServiceProperty(kWifi2Path, shill::kEapMethodProperty,
                                    base::StringValue(shill::kEapMethodPEAP));
       services->SetServiceProperty(kWifi2Path, shill::kEapIdentityProperty,
                                    base::StringValue("John Doe"));
     } else {
       services->SetServiceProperty(kWifi2Path, shill::kSecurityClassProperty,
                                    base::StringValue(shill::kSecurityPsk));
     }
-    services->SetServiceProperty(
-        kWifi2Path, shill::kSignalStrengthProperty, base::FundamentalValue(80));
+    services->SetServiceProperty(kWifi2Path, shill::kSignalStrengthProperty,
+                                 base::Value(80));
     profiles->AddService(shared_profile, kWifi2Path);
 
     const std::string kWifi3Path = "/service/wifi3";
     services->AddService(kWifi3Path,
                          "",  /* empty GUID */
                          "wifi3" /* name */,
                          shill::kTypeWifi,
                          shill::kStateIdle,
                          add_to_visible);
-    services->SetServiceProperty(
-        kWifi3Path, shill::kSignalStrengthProperty, base::FundamentalValue(40));
+    services->SetServiceProperty(kWifi3Path, shill::kSignalStrengthProperty,
+                                 base::Value(40));
 
     if (portaled) {
       const std::string kPortaledWifiPath = "/service/portaled_wifi";
       services->AddService(kPortaledWifiPath, "portaled_wifi_guid",
                            "Portaled Wifi" /* name */, shill::kTypeWifi,
                            shill::kStateIdle, add_to_visible);
       services->SetServiceProperty(kPortaledWifiPath,
                                    shill::kSecurityClassProperty,
                                    base::StringValue(shill::kSecurityNone));
       services->SetConnectBehavior(
           kPortaledWifiPath,
           base::Bind(&UpdatePortaledWifiState, kPortaledWifiPath));
-      services->SetServiceProperty(kPortaledWifiPath,
-                                   shill::kConnectableProperty,
-                                   base::FundamentalValue(true));
+      services->SetServiceProperty(
+          kPortaledWifiPath, shill::kConnectableProperty, base::Value(true));
       profiles->AddService(shared_profile, kPortaledWifiPath);
     }
 
     for (int i = 0; i < s_extra_wifi_networks; ++i) {
       int id = 4 + i;
       std::string path = base::StringPrintf("/service/wifi%d", id);
       std::string guid = base::StringPrintf("wifi%d_guid", id);
       std::string name = base::StringPrintf("wifi%d", id);
       services->AddService(path, guid, name, shill::kTypeWifi,
                            shill::kStateIdle, add_to_visible);
     }
   }
 
   // Wimax
   const std::string kWimaxPath = "/service/wimax1";
   state = GetInitialStateForType(shill::kTypeWimax, &enabled);
   if (state != kTechnologyUnavailable) {
     AddTechnology(shill::kTypeWimax, enabled);
     devices->AddDevice(
         "/device/wimax1", shill::kTypeWimax, "stub_wimax_device1");
 
     services->AddService(kWimaxPath, "wimax1_guid", "wimax1" /* name */,
                          shill::kTypeWimax, state, add_to_visible);
     services->SetServiceProperty(kWimaxPath, shill::kConnectableProperty,
-                                 base::FundamentalValue(true));
-    base::FundamentalValue strength_value(80);
+                                 base::Value(true));
+    base::Value strength_value(80);
     services->SetServiceProperty(kWimaxPath, shill::kSignalStrengthProperty,
                                  strength_value);
     profiles->AddService(shared_profile, kWimaxPath);
   }
 
   // Cellular
   state = GetInitialStateForType(shill::kTypeCellular, &enabled);
   if (state != kTechnologyUnavailable) {
     bool activated = false;
     if (state == kNetworkActivated) {
       activated = true;
       state = shill::kStateOnline;
     }
     AddTechnology(shill::kTypeCellular, enabled);
     devices->AddDevice(
         "/device/cellular1", shill::kTypeCellular, "stub_cellular_device1");
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kCarrierProperty,
                                base::StringValue(shill::kCarrierSprint));
     base::ListValue carrier_list;
     carrier_list.AppendString(shill::kCarrierSprint);
     carrier_list.AppendString(shill::kCarrierGenericUMTS);
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kSupportedCarriersProperty,
                                carrier_list);
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kSupportNetworkScanProperty,
-                               base::FundamentalValue(true));
+                               base::Value(true));
     if (roaming_state_ == kRoamingRequired) {
       devices->SetDeviceProperty("/device/cellular1",
                                  shill::kProviderRequiresRoamingProperty,
-                                 base::FundamentalValue(true));
+                                 base::Value(true));
     }
     if (cellular_technology_ == shill::kNetworkTechnologyGsm) {
       devices->SetDeviceProperty("/device/cellular1",
-                                 shill::kSIMPresentProperty,
-                                 base::FundamentalValue(true));
+                                 shill::kSIMPresentProperty, base::Value(true));
       devices->SetSimLocked("/device/cellular1", false);
     }
 
     services->AddService(kCellularServicePath,
                          "cellular1_guid",
                          "cellular1" /* name */,
                          shill::kTypeCellular,
                          state,
                          add_to_visible);
     base::StringValue technology_value(cellular_technology_);
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kTechnologyFamilyProperty,
                                technology_value);
     services->SetServiceProperty(kCellularServicePath,
                                  shill::kNetworkTechnologyProperty,
                                  technology_value);
-    base::FundamentalValue strength_value(50);
+    base::Value strength_value(50);
     services->SetServiceProperty(
         kCellularServicePath, shill::kSignalStrengthProperty, strength_value);
 
     if (activated) {
       services->SetServiceProperty(
           kCellularServicePath,
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateActivated));
-      services->SetServiceProperty(kCellularServicePath,
-                                   shill::kConnectableProperty,
-                                   base::FundamentalValue(true));
+      services->SetServiceProperty(
+          kCellularServicePath, shill::kConnectableProperty, base::Value(true));
     } else {
       services->SetServiceProperty(
           kCellularServicePath,
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateNotActivated));
     }
 
     std::string shill_roaming_state;
     if (roaming_state_ == kRoamingRequired)
       shill_roaming_state = shill::kRoamingStateRoaming;
@@ skipping 193 matching lines @@
       if (TechnologyEnabled(type))
         new_service_list->Append((*iter)->CreateDeepCopy());
     }
   }
   return new_service_list;
 }
 
 void FakeShillManagerClient::ScanCompleted(const std::string& device_path,
                                            const base::Closure& callback) {
   if (!device_path.empty()) {
-    DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
-        SetDeviceProperty(device_path,
-                          shill::kScanningProperty,
-                          base::FundamentalValue(false));
+    DBusThreadManager::Get()
+        ->GetShillDeviceClient()
+        ->GetTestInterface()
+        ->SetDeviceProperty(device_path, shill::kScanningProperty,
+                            base::Value(false));
   }
   VLOG(1) << "ScanCompleted";
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::ParseCommandLineSwitch() {
   // Default setup
   SetInitialNetworkState(shill::kTypeEthernet, shill::kStateOnline);
   SetInitialNetworkState(shill::kTypeWifi, shill::kStateOnline);
@@ skipping 39 matching lines @@
                                FakeShillDeviceClient::kSimPinRetryCount);
     }
     shill_device_property_map_[shill::kTypeCellular]
                               [shill::kSIMLockStatusProperty] = simlock_dict;
     shill_device_property_map_
         [shill::kTypeCellular][shill::kTechnologyFamilyProperty] =
             new base::StringValue(shill::kNetworkTechnologyGsm);
     return true;
   } else if (arg0 == "sim_present") {
     bool present = (arg1 == "1");
-    base::FundamentalValue* sim_present = new base::FundamentalValue(present);
+    base::Value* sim_present = new base::Value(present);
     shill_device_property_map_[shill::kTypeCellular]
                               [shill::kSIMPresentProperty] = sim_present;
     return true;
   } else if (arg0 == "tdls_busy") {
     if (!arg1.empty())
       base::StringToInt(arg1, &s_tdls_busy_count);
     else
       s_tdls_busy_count = 1;
     return true;
   } else if (arg0 == "roaming") {
@@ skipping 103 matching lines @@
       LOG(WARNING) << "Invalid state: " << state << " for " << type;
       result = shill::kStateIdle;
     }
   }
   VLOG(1) << "Initial state for: " << type << " = " << result
           << " Enabled: " << *enabled;
   return result;
 }
 
 }  // namespace chromeos