Remove base::StringValue

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 93 matching lines @@
                       const std::string& error_message) {
   LOG(ERROR) << error_name << ": " << error_message;
 }
 
 bool IsConnectedState(const std::string& state) {
   return state == shill::kStateOnline || state == shill::kStatePortal ||
          state == shill::kStateReady;
 }
 
 void UpdatePortaledWifiState(const std::string& service_path) {
-  DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
-      ->SetServiceProperty(service_path,
-                           shill::kStateProperty,
-                           base::StringValue(shill::kStatePortal));
+  DBusThreadManager::Get()
+      ->GetShillServiceClient()
+      ->GetTestInterface()
+      ->SetServiceProperty(service_path, shill::kStateProperty,
+                           base::Value(shill::kStatePortal));
 }
 
 bool IsCellularTechnology(const std::string& type) {
   return (type == shill::kNetworkTechnology1Xrtt ||
           type == shill::kNetworkTechnologyEvdo ||
           type == shill::kNetworkTechnologyGsm ||
           type == shill::kNetworkTechnologyGprs ||
           type == shill::kNetworkTechnologyEdge ||
           type == shill::kNetworkTechnologyUmts ||
           type == shill::kNetworkTechnologyHspa ||
@@ skipping 248 matching lines @@
 }
 
 ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() {
   return this;
 }
 
 // ShillManagerClient::TestInterface overrides.
 
 void FakeShillManagerClient::AddDevice(const std::string& device_path) {
   if (GetListProperty(shill::kDevicesProperty)
-          ->AppendIfNotPresent(
-              base::MakeUnique<base::StringValue>(device_path))) {
+          ->AppendIfNotPresent(base::MakeUnique<base::Value>(device_path))) {
     CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveDevice(const std::string& device_path) {
-  base::StringValue device_path_value(device_path);
+  base::Value device_path_value(device_path);
   if (GetListProperty(shill::kDevicesProperty)->Remove(
       device_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::ClearDevices() {
   GetListProperty(shill::kDevicesProperty)->Clear();
   CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 }
 
 void FakeShillManagerClient::AddTechnology(const std::string& type,
                                            bool enabled) {
   if (GetListProperty(shill::kAvailableTechnologiesProperty)
-          ->AppendIfNotPresent(base::MakeUnique<base::StringValue>(type))) {
+          ->AppendIfNotPresent(base::MakeUnique<base::Value>(type))) {
     CallNotifyObserversPropertyChanged(
         shill::kAvailableTechnologiesProperty);
   }
   if (enabled &&
       GetListProperty(shill::kEnabledTechnologiesProperty)
-          ->AppendIfNotPresent(base::MakeUnique<base::StringValue>(type))) {
+          ->AppendIfNotPresent(base::MakeUnique<base::Value>(type))) {
     CallNotifyObserversPropertyChanged(
         shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveTechnology(const std::string& type) {
-  base::StringValue type_value(type);
+  base::Value type_value(type);
   if (GetListProperty(shill::kAvailableTechnologiesProperty)->Remove(
       type_value, NULL)) {
     CallNotifyObserversPropertyChanged(
         shill::kAvailableTechnologiesProperty);
   }
   if (GetListProperty(shill::kEnabledTechnologiesProperty)->Remove(
       type_value, NULL)) {
     CallNotifyObserversPropertyChanged(
         shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::SetTechnologyInitializing(const std::string& type,
                                                        bool initializing) {
   if (initializing) {
     if (GetListProperty(shill::kUninitializedTechnologiesProperty)
-            ->AppendIfNotPresent(base::MakeUnique<base::StringValue>(type))) {
+            ->AppendIfNotPresent(base::MakeUnique<base::Value>(type))) {
       CallNotifyObserversPropertyChanged(
           shill::kUninitializedTechnologiesProperty);
     }
   } else {
-    if (GetListProperty(shill::kUninitializedTechnologiesProperty)->Remove(
-            base::StringValue(type), NULL)) {
+    if (GetListProperty(shill::kUninitializedTechnologiesProperty)
+            ->Remove(base::Value(type), NULL)) {
       CallNotifyObserversPropertyChanged(
           shill::kUninitializedTechnologiesProperty);
     }
   }
 }
 
 void FakeShillManagerClient::AddGeoNetwork(
     const std::string& technology,
     const base::DictionaryValue& network) {
   base::ListValue* list_value = NULL;
   if (!stub_geo_networks_.GetListWithoutPathExpansion(technology,
                                                       &list_value)) {
     list_value = new base::ListValue;
     stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
   }
   list_value->Append(network.CreateDeepCopy());
 }
 
 void FakeShillManagerClient::AddProfile(const std::string& profile_path) {
   const char* key = shill::kProfilesProperty;
   if (GetListProperty(key)->AppendIfNotPresent(
-          base::MakeUnique<base::StringValue>(profile_path))) {
+          base::MakeUnique<base::Value>(profile_path))) {
     CallNotifyObserversPropertyChanged(key);
   }
 }
 
 void FakeShillManagerClient::ClearProperties() {
   stub_properties_.Clear();
 }
 
 void FakeShillManagerClient::SetManagerProperty(const std::string& key,
                                                 const base::Value& value) {
   SetProperty(key, value,
               base::Bind(&base::DoNothing), base::Bind(&LogErrorCallback));
 }
 
 void FakeShillManagerClient::AddManagerService(
     const std::string& service_path,
     bool notify_observers) {
   VLOG(2) << "AddManagerService: " << service_path;
   GetListProperty(shill::kServiceCompleteListProperty)
-      ->AppendIfNotPresent(base::MakeUnique<base::StringValue>(service_path));
+      ->AppendIfNotPresent(base::MakeUnique<base::Value>(service_path));
   SortManagerServices(false);
   if (notify_observers)
     CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
     const std::string& service_path) {
   VLOG(2) << "RemoveManagerService: " << service_path;
-  base::StringValue service_path_value(service_path);
+  base::Value service_path_value(service_path);
   GetListProperty(shill::kServiceCompleteListProperty)->Remove(
       service_path_value, NULL);
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
   VLOG(1) << "ClearManagerServices";
   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
 }
 
 void FakeShillManagerClient::ServiceStateChanged(
     const std::string& service_path,
     const std::string& state) {
   if (service_path == default_service_ && !IsConnectedState(state)) {
     // Default service is no longer connected; clear.
     default_service_.clear();
-    base::StringValue default_service_value(default_service_);
+    base::Value default_service_value(default_service_);
     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
   }
 }
 
 void FakeShillManagerClient::SortManagerServices(bool notify) {
   VLOG(1) << "SortManagerServices";
   static const char* ordered_types[] = {shill::kTypeEthernet,
                                         shill::kTypeEthernetEap,
                                         shill::kTypeWifi,
                                         shill::kTypeCellular,
@@ skipping 41 matching lines @@
       LOG(ERROR) << "Properties not found for service: " << service_path;
     } else {
       std::string state;
       properties->GetString(shill::kStateProperty, &state);
       if (IsConnectedState(state))
         new_default_service = service_path;
     }
   }
   if (default_service_ != new_default_service) {
     default_service_ = new_default_service;
-    base::StringValue default_service_value(default_service_);
+    base::Value default_service_value(default_service_);
     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
   }
 }
 
 int FakeShillManagerClient::GetInteractiveDelay() const {
   return interactive_delay_;
 }
 
 void FakeShillManagerClient::SetBestServiceToConnect(
     const std::string& service_path) {
@@ skipping 54 matching lines @@
 
   bool enabled;
   std::string state;
 
   // Ethernet
   state = GetInitialStateForType(shill::kTypeEthernet, &enabled);
   if (state == shill::kStateOnline || state == shill::kStateIdle) {
     AddTechnology(shill::kTypeEthernet, enabled);
     devices->AddDevice(
         "/device/eth1", shill::kTypeEthernet, "stub_eth_device1");
-    devices->SetDeviceProperty("/device/eth1",
-                               shill::kAddressProperty,
-                               base::StringValue("0123456789ab"));
+    devices->SetDeviceProperty("/device/eth1", shill::kAddressProperty,
+                               base::Value("0123456789ab"));
     base::ListValue eth_ip_configs;
     eth_ip_configs.AppendString("ipconfig_v4_path");
     eth_ip_configs.AppendString("ipconfig_v6_path");
     devices->SetDeviceProperty("/device/eth1",
                                shill::kIPConfigsProperty,
                                eth_ip_configs);
     const std::string kFakeEthernetNetworkPath = "/service/eth1";
     services->AddService(kFakeEthernetNetworkPath,
                          kFakeEthernetNetworkGuid,
                          "eth1" /* name */,
@@ skipping 13 matching lines @@
 
   state = GetInitialStateForType(shill::kTypeWifi, &enabled);
   if (state != kTechnologyUnavailable) {
     bool portaled = false;
     if (state == shill::kStatePortal) {
       portaled = true;
       state = shill::kStateIdle;
     }
     AddTechnology(shill::kTypeWifi, enabled);
     devices->AddDevice("/device/wifi1", shill::kTypeWifi, "stub_wifi_device1");
-    devices->SetDeviceProperty("/device/wifi1",
-                               shill::kAddressProperty,
-                               base::StringValue("23456789abcd"));
+    devices->SetDeviceProperty("/device/wifi1", shill::kAddressProperty,
+                               base::Value("23456789abcd"));
     base::ListValue wifi_ip_configs;
     wifi_ip_configs.AppendString("ipconfig_v4_path");
     wifi_ip_configs.AppendString("ipconfig_v6_path");
     devices->SetDeviceProperty("/device/wifi1",
                                shill::kIPConfigsProperty,
                                wifi_ip_configs);
 
     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::kSecurityClassProperty,
+                                 base::Value(shill::kSecurityWep));
     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));
+                                   base::Value(shill::kSecurityWep));
+      services->SetServiceProperty(kWifi2Path, shill::kEapKeyMgmtProperty,
+                                   base::Value(shill::kKeyManagementIEEE8021X));
       services->SetServiceProperty(kWifi2Path, shill::kEapMethodProperty,
-                                   base::StringValue(shill::kEapMethodPEAP));
+                                   base::Value(shill::kEapMethodPEAP));
       services->SetServiceProperty(kWifi2Path, shill::kEapIdentityProperty,
-                                   base::StringValue("John Doe"));
+                                   base::Value("John Doe"));
     } else {
       services->SetServiceProperty(kWifi2Path, shill::kSecurityClassProperty,
-                                   base::StringValue(shill::kSecurityPsk));
+                                   base::Value(shill::kSecurityPsk));
     }
     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::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));
+                                   base::Value(shill::kSecurityNone));
       services->SetConnectBehavior(
           kPortaledWifiPath,
           base::Bind(&UpdatePortaledWifiState, kPortaledWifiPath));
       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;
@@ skipping 27 matching lines @@
   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));
+    devices->SetDeviceProperty("/device/cellular1", shill::kCarrierProperty,
+                               base::Value(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::Value(true));
     if (roaming_state_ == kRoamingRequired) {
       devices->SetDeviceProperty("/device/cellular1",
                                  shill::kProviderRequiresRoamingProperty,
                                  base::Value(true));
     }
     if (cellular_technology_ == shill::kNetworkTechnologyGsm) {
       devices->SetDeviceProperty("/device/cellular1",
                                  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_);
+    base::Value technology_value(cellular_technology_);
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kTechnologyFamilyProperty,
                                technology_value);
     services->SetServiceProperty(kCellularServicePath,
                                  shill::kNetworkTechnologyProperty,
                                  technology_value);
     base::Value strength_value(50);
     services->SetServiceProperty(
         kCellularServicePath, shill::kSignalStrengthProperty, strength_value);
 
     if (activated) {
       services->SetServiceProperty(
-          kCellularServicePath,
-          shill::kActivationStateProperty,
-          base::StringValue(shill::kActivationStateActivated));
+          kCellularServicePath, shill::kActivationStateProperty,
+          base::Value(shill::kActivationStateActivated));
       services->SetServiceProperty(
           kCellularServicePath, shill::kConnectableProperty, base::Value(true));
     } else {
       services->SetServiceProperty(
-          kCellularServicePath,
-          shill::kActivationStateProperty,
-          base::StringValue(shill::kActivationStateNotActivated));
+          kCellularServicePath, shill::kActivationStateProperty,
+          base::Value(shill::kActivationStateNotActivated));
     }
 
     std::string shill_roaming_state;
     if (roaming_state_ == kRoamingRequired)
       shill_roaming_state = shill::kRoamingStateRoaming;
     else if (roaming_state_.empty())
       shill_roaming_state = shill::kRoamingStateHome;
     else  // |roaming_state_| is expected to be a valid Shill state.
       shill_roaming_state = roaming_state_;
     services->SetServiceProperty(kCellularServicePath,
                                  shill::kRoamingStateProperty,
-                                 base::StringValue(shill_roaming_state));
+                                 base::Value(shill_roaming_state));
 
     base::DictionaryValue apn;
     apn.SetStringWithoutPathExpansion(shill::kApnProperty, "testapn");
     apn.SetStringWithoutPathExpansion(shill::kApnNameProperty, "Test APN");
     apn.SetStringWithoutPathExpansion(shill::kApnLocalizedNameProperty,
                                       "Localized Test APN");
     apn.SetStringWithoutPathExpansion(shill::kApnUsernameProperty, "User1");
     apn.SetStringWithoutPathExpansion(shill::kApnPasswordProperty, "password");
     base::DictionaryValue apn2;
     apn2.SetStringWithoutPathExpansion(shill::kApnProperty, "testapn2");
@@ skipping 122 matching lines @@
 
 bool FakeShillManagerClient::TechnologyEnabled(const std::string& type) const {
   if (type == shill::kTypeVPN)
     return true;  // VPN is always "enabled" since there is no associated device
   if (type == shill::kTypeEthernetEap)
     return true;
   bool enabled = false;
   const base::ListValue* technologies;
   if (stub_properties_.GetListWithoutPathExpansion(
           shill::kEnabledTechnologiesProperty, &technologies)) {
-    base::StringValue type_value(type);
+    base::Value type_value(type);
     if (technologies->Find(type_value) != technologies->end())
       enabled = true;
   }
   return enabled;
 }
 
 void FakeShillManagerClient::SetTechnologyEnabled(
     const std::string& type,
     const base::Closure& callback,
     bool enabled) {
   base::ListValue* enabled_list =
       GetListProperty(shill::kEnabledTechnologiesProperty);
   if (enabled)
-    enabled_list->AppendIfNotPresent(base::MakeUnique<base::StringValue>(type));
+    enabled_list->AppendIfNotPresent(base::MakeUnique<base::Value>(type));
   else
-    enabled_list->Remove(base::StringValue(type), NULL);
+    enabled_list->Remove(base::Value(type), NULL);
   CallNotifyObserversPropertyChanged(
       shill::kEnabledTechnologiesProperty);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
   // May affect available services.
   SortManagerServices(true);
 }
 
 base::ListValue* FakeShillManagerClient::GetEnabledServiceList(
     const std::string& property) const {
   base::ListValue* new_service_list = new base::ListValue;
@@ skipping 75 matching lines @@
     base::DictionaryValue* simlock_dict = new base::DictionaryValue;
     simlock_dict->SetBoolean(shill::kSIMLockEnabledProperty, true);
     std::string lock_type = locked ? shill::kSIMLockPin : "";
     simlock_dict->SetString(shill::kSIMLockTypeProperty, lock_type);
     if (locked) {
       simlock_dict->SetInteger(shill::kSIMLockRetriesLeftProperty,
                                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);
+    shill_device_property_map_[shill::kTypeCellular]
+                              [shill::kTechnologyFamilyProperty] =
+                                  new base::Value(shill::kNetworkTechnologyGsm);
     return true;
   } else if (arg0 == "sim_present") {
     bool present = (arg1 == "1");
     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);
@@ skipping 107 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