Remove base::StringValue

chrome/browser/chromeos/extensions/info_private_api.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/extensions/info_private_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 207 matching lines @@
   return true;
 }
 
 base::Value* ChromeosInfoPrivateGetFunction::GetValue(
     const std::string& property_name) {
   if (property_name == kPropertyHWID) {
     std::string hwid;
     chromeos::system::StatisticsProvider* provider =
         chromeos::system::StatisticsProvider::GetInstance();
     provider->GetMachineStatistic(chromeos::system::kHardwareClassKey, &hwid);
-    return new base::StringValue(hwid);
+    return new base::Value(hwid);
   }
 
   if (property_name == kPropertyCustomizationID) {
     std::string customization_id;
     chromeos::system::StatisticsProvider* provider =
         chromeos::system::StatisticsProvider::GetInstance();
     provider->GetMachineStatistic(chromeos::system::kCustomizationIdKey,
                                   &customization_id);
-    return new base::StringValue(customization_id);
+    return new base::Value(customization_id);
   }
 
   if (property_name == kPropertyHomeProvider) {
     const chromeos::DeviceState* cellular_device =
         NetworkHandler::Get()->network_state_handler()->GetDeviceStateByType(
             chromeos::NetworkTypePattern::Cellular());
     std::string home_provider_id;
     if (cellular_device)
       home_provider_id = cellular_device->home_provider_id();
-    return new base::StringValue(home_provider_id);
+    return new base::Value(home_provider_id);
   }
 
   if (property_name == kPropertyInitialLocale) {
-    return new base::StringValue(
-        chromeos::StartupUtils::GetInitialLocale());
+    return new base::Value(chromeos::StartupUtils::GetInitialLocale());
   }
 
   if (property_name == kPropertyBoard) {
-    return new base::StringValue(base::SysInfo::GetLsbReleaseBoard());
+    return new base::Value(base::SysInfo::GetLsbReleaseBoard());
   }
 
   if (property_name == kPropertyOwner) {
     return new base::Value(
         user_manager::UserManager::Get()->IsCurrentUserOwner());
   }
 
   if (property_name == kPropertySessionType) {
     if (ExtensionsBrowserClient::Get()->IsRunningInForcedAppMode())
-      return new base::StringValue(kSessionTypeKiosk);
+      return new base::Value(kSessionTypeKiosk);
     if (ExtensionsBrowserClient::Get()->IsLoggedInAsPublicAccount())
-      return new base::StringValue(kSessionTypePublicSession);
-    return new base::StringValue(kSessionTypeNormal);
+      return new base::Value(kSessionTypePublicSession);
+    return new base::Value(kSessionTypeNormal);
   }
 
   if (property_name == kPropertyPlayStoreStatus) {
     if (arc::IsArcAllowedForProfile(Profile::FromBrowserContext(context_)))
-      return new base::StringValue(kPlayStoreStatusEnabled);
+      return new base::Value(kPlayStoreStatusEnabled);
     if (arc::IsArcAvailable())
-      return new base::StringValue(kPlayStoreStatusAvailable);
-    return new base::StringValue(kPlayStoreStatusNotAvailable);
+      return new base::Value(kPlayStoreStatusAvailable);
+    return new base::Value(kPlayStoreStatusNotAvailable);
   }
 
   if (property_name == kPropertyManagedDeviceStatus) {
     policy::BrowserPolicyConnectorChromeOS* connector =
         g_browser_process->platform_part()->browser_policy_connector_chromeos();
     if (connector->IsEnterpriseManaged()) {
-      return new base::StringValue(kManagedDeviceStatusManaged);
+      return new base::Value(kManagedDeviceStatusManaged);
     }
-    return new base::StringValue(kManagedDeviceStatusNotManaged);
+    return new base::Value(kManagedDeviceStatusNotManaged);
   }
 
   if (property_name == kPropertyClientId) {
-    return new base::StringValue(GetClientId());
+    return new base::Value(GetClientId());
   }
 
   if (property_name == kPropertyTimezone) {
     return chromeos::CrosSettings::Get()->GetPref(
             chromeos::kSystemTimezone)->DeepCopy();
   }
 
   if (property_name == kPropertySupportedTimezones) {
     std::unique_ptr<base::ListValue> values =
         chromeos::system::GetTimezoneList();
@@ skipping 17 matching lines @@
 ChromeosInfoPrivateSetFunction::~ChromeosInfoPrivateSetFunction() {
 }
 
 ExtensionFunction::ResponseAction ChromeosInfoPrivateSetFunction::Run() {
   std::string param_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &param_name));
   if (param_name == kPropertyTimezone) {
     std::string param_value;
     EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &param_value));
     chromeos::CrosSettings::Get()->Set(chromeos::kSystemTimezone,
-                                       base::StringValue(param_value));
+                                       base::Value(param_value));
   } else {
     const char* pref_name = GetBoolPrefNameForApiProperty(param_name.c_str());
     if (pref_name) {
       bool param_value;
       EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &param_value));
       Profile::FromBrowserContext(context_)->GetPrefs()->SetBoolean(
           pref_name,
           param_value);
     } else {
       return RespondNow(Error(kPropertyNotFound, param_name));
     }
   }
 
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions