Remove base::StringValue

chrome/browser/chromeos/policy/device_policy_decoder_chromeos.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_policy_decoder_chromeos.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 89 matching lines @@
     shill::kTypeEthernet,
     shill::kTypeWifi,
     shill::kTypeWimax,
     shill::kTypeBluetooth,
     shill::kTypeCellular,
   };
 
   if (value < 0 || value >= static_cast<int>(arraysize(kConnectionTypes)))
     return nullptr;
 
-  return base::MakeUnique<base::StringValue>(kConnectionTypes[value]);
+  return base::MakeUnique<base::Value>(kConnectionTypes[value]);
 }
 
 void DecodeLoginPolicies(const em::ChromeDeviceSettingsProto& policy,
                          PolicyMap* policies) {
   if (policy.has_guest_mode_enabled()) {
     const em::GuestModeEnabledProto& container(policy.guest_mode_enabled());
     if (container.has_guest_mode_enabled()) {
       policies->Set(
           key::kDeviceGuestModeEnabled, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
@@ skipping 110 matching lines @@
         entry_dict->SetIntegerWithoutPathExpansion(
             chromeos::kAccountsPrefDeviceLocalAccountsKeyType,
             DeviceLocalAccount::TYPE_PUBLIC_SESSION);
       }
       account_list->Append(std::move(entry_dict));
     }
     policies->Set(key::kDeviceLocalAccounts, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   std::move(account_list), nullptr);
     if (container.has_auto_login_id()) {
-      policies->Set(
-          key::kDeviceLocalAccountAutoLoginId, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::StringValue>(container.auto_login_id()),
-          nullptr);
+      policies->Set(key::kDeviceLocalAccountAutoLoginId, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.auto_login_id()),
+                    nullptr);
     }
     if (container.has_auto_login_delay()) {
       policies->Set(key::kDeviceLocalAccountAutoLoginDelay,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.auto_login_delay()), nullptr);
     }
     if (container.has_enable_auto_login_bailout()) {
       policies->Set(
           key::kDeviceLocalAccountAutoLoginBailoutEnabled,
@@ skipping 94 matching lines @@
       }
     }
   }
 
   if (policy.has_login_screen_domain_auto_complete()) {
     const em::LoginScreenDomainAutoCompleteProto& container(
         policy.login_screen_domain_auto_complete());
     policies->Set(key::kDeviceLoginScreenDomainAutoComplete,
                   POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                   POLICY_SOURCE_CLOUD,
-                  base::MakeUnique<base::StringValue>(
+                  base::MakeUnique<base::Value>(
                       container.login_screen_domain_auto_complete()),
                   nullptr);
   }
 
   if (policy.has_login_screen_locales()) {
     std::unique_ptr<base::ListValue> locales(new base::ListValue);
     const em::LoginScreenLocalesProto& login_screen_locales(
         policy.login_screen_locales());
     for (const auto& locale : login_screen_locales.login_screen_locales())
       locales->AppendString(locale);
@@ skipping 47 matching lines @@
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   std::move(throttling_status), nullptr);
   }
 
   if (policy.has_open_network_configuration() &&
       policy.open_network_configuration().has_open_network_configuration()) {
     std::string config(
         policy.open_network_configuration().open_network_configuration());
     policies->Set(key::kDeviceOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                  base::MakeUnique<base::StringValue>(config), nullptr);
+                  base::MakeUnique<base::Value>(config), nullptr);
   }
 }
 
 void DecodeReportingPolicies(const em::ChromeDeviceSettingsProto& policy,
                              PolicyMap* policies) {
   if (policy.has_device_reporting()) {
     const em::DeviceReportingProto& container(policy.device_reporting());
     if (container.has_report_version_info()) {
       policies->Set(
           key::kReportDeviceVersionInfo, POLICY_LEVEL_MANDATORY,
@@ skipping 87 matching lines @@
 }
 
 void DecodeAutoUpdatePolicies(const em::ChromeDeviceSettingsProto& policy,
                               PolicyMap* policies) {
   if (policy.has_release_channel()) {
     const em::ReleaseChannelProto& container(policy.release_channel());
     if (container.has_release_channel()) {
       std::string channel(container.release_channel());
       policies->Set(key::kChromeOsReleaseChannel, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::StringValue>(channel), nullptr);
+                    base::MakeUnique<base::Value>(channel), nullptr);
       // TODO(dubroy): Once http://crosbug.com/17015 is implemented, we won't
       // have to pass the channel in here, only ping the update engine to tell
       // it to fetch the channel from the policy.
       chromeos::DBusThreadManager::Get()->GetUpdateEngineClient()->
           SetChannel(channel, false);
     }
     if (container.has_release_channel_delegated()) {
       policies->Set(
           key::kChromeOsReleaseChannelDelegated, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
           base::MakeUnique<base::Value>(container.release_channel_delegated()),
           nullptr);
     }
   }
 
   if (policy.has_auto_update_settings()) {
     const em::AutoUpdateSettingsProto& container(policy.auto_update_settings());
     if (container.has_update_disabled()) {
       policies->Set(key::kDeviceAutoUpdateDisabled, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::Value>(container.update_disabled()),
                     nullptr);
     }
 
     if (container.has_target_version_prefix()) {
-      policies->Set(key::kDeviceTargetVersionPrefix, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::StringValue>(
-                        container.target_version_prefix()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceTargetVersionPrefix, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.target_version_prefix()),
+          nullptr);
     }
 
     // target_version_display_name is not actually a policy, but a display
     // string for target_version_prefix, so we ignore it.
 
     if (container.has_scatter_factor_in_seconds()) {
       // TODO(dcheng): Shouldn't this use DecodeIntegerValue?
       policies->Set(key::kDeviceUpdateScatterFactor, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::Value>(static_cast<int>(
@@ skipping 124 matching lines @@
     if (container.has_metrics_enabled()) {
       policies->Set(key::kDeviceMetricsReportingEnabled, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::Value>(container.metrics_enabled()),
                     nullptr);
     }
   }
 
   if (policy.has_system_timezone()) {
     if (policy.system_timezone().has_timezone()) {
-      policies->Set(key::kSystemTimezone, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::StringValue>(
-                        policy.system_timezone().timezone()),
-                    nullptr);
+      policies->Set(
+          key::kSystemTimezone, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+          POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(policy.system_timezone().timezone()),
+          nullptr);
     }
 
     if (policy.system_timezone().has_timezone_detection_type()) {
       std::unique_ptr<base::Value> value(DecodeIntegerValue(
           policy.system_timezone().timezone_detection_type()));
       if (value) {
         policies->Set(key::kSystemTimezoneAutomaticDetection,
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_CLOUD, std::move(value), nullptr);
       }
@@ skipping 28 matching lines @@
       policies->Set(key::kUptimeLimit, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.uptime_limit()), nullptr);
     }
   }
 
   if (policy.has_start_up_flags()) {
     const em::StartUpFlagsProto& container(policy.start_up_flags());
     std::unique_ptr<base::ListValue> flags(new base::ListValue());
     for (const auto& entry : container.flags())
-      flags->Append(base::MakeUnique<base::StringValue>(entry));
+      flags->Append(base::MakeUnique<base::Value>(entry));
     policies->Set(key::kDeviceStartUpFlags, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD, std::move(flags),
                   nullptr);
   }
 
   if (policy.has_variations_parameter()) {
     if (policy.variations_parameter().has_parameter()) {
       policies->Set(key::kDeviceVariationsRestrictParameter,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::StringValue>(
+                    base::MakeUnique<base::Value>(
                         policy.variations_parameter().parameter()),
                     nullptr);
     }
   }
 
   if (policy.has_attestation_settings()) {
     if (policy.attestation_settings().has_attestation_enabled()) {
       policies->Set(key::kAttestationEnabledForDevice, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::Value>(
@@ skipping 91 matching lines @@
   // Decode the various groups of policies.
   DecodeLoginPolicies(policy, policies);
   DecodeNetworkPolicies(policy, policies);
   DecodeReportingPolicies(policy, policies);
   DecodeAutoUpdatePolicies(policy, policies);
   DecodeAccessibilityPolicies(policy, policies);
   DecodeGenericPolicies(policy, policies);
 }
 
 }  // namespace policy