Remove base::FundamentalValue

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 29 matching lines @@
 // Decodes a protobuf integer to an IntegerValue. Returns NULL in case the input
 // value is out of bounds.
 std::unique_ptr<base::Value> DecodeIntegerValue(google::protobuf::int64 value) {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return std::unique_ptr<base::Value>();
   }
 
-  return std::unique_ptr<base::Value>(
-      new base::FundamentalValue(static_cast<int>(value)));
+  return std::unique_ptr<base::Value>(new base::Value(static_cast<int>(value)));
 }
 
 // Decodes a JSON string to a base::Value, and drops unknown properties
 // according to a policy schema. |policy_name| is the name of a policy schema
 // defined in policy_templates.json. Returns NULL in case the input is not a
 // valid JSON string.
 std::unique_ptr<base::Value> DecodeJsonStringAndDropUnknownBySchema(
     const std::string& json_string,
     const std::string& policy_name) {
   std::string error;
@@ skipping 47 matching lines @@
     return nullptr;
 
   return base::MakeUnique<base::StringValue>(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,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.guest_mode_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceGuestModeEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.guest_mode_enabled()),
+          nullptr);
     }
   }
 
   if (policy.has_reboot_on_shutdown()) {
     const em::RebootOnShutdownProto& container(policy.reboot_on_shutdown());
     if (container.has_reboot_on_shutdown()) {
-      policies->Set(key::kDeviceRebootOnShutdown, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.reboot_on_shutdown()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceRebootOnShutdown, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.reboot_on_shutdown()),
+          nullptr);
     }
   }
 
   if (policy.has_show_user_names()) {
     const em::ShowUserNamesOnSigninProto& container(policy.show_user_names());
     if (container.has_show_user_names()) {
-      policies->Set(
-          key::kDeviceShowUserNamesOnSignin, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.show_user_names()),
-          nullptr);
+      policies->Set(key::kDeviceShowUserNamesOnSignin, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.show_user_names()),
+                    nullptr);
     }
   }
 
   if (policy.has_allow_new_users()) {
     const em::AllowNewUsersProto& container(policy.allow_new_users());
     if (container.has_allow_new_users()) {
-      policies->Set(
-          key::kDeviceAllowNewUsers, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.allow_new_users()),
-          nullptr);
+      policies->Set(key::kDeviceAllowNewUsers, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.allow_new_users()),
+                    nullptr);
     }
   }
 
   if (policy.has_user_whitelist()) {
     const em::UserWhitelistProto& container(policy.user_whitelist());
     std::unique_ptr<base::ListValue> whitelist(new base::ListValue);
     for (const auto& entry : container.user_whitelist())
       whitelist->AppendString(entry);
     policies->Set(key::kDeviceUserWhitelist, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   std::move(whitelist), nullptr);
   }
 
   if (policy.has_ephemeral_users_enabled()) {
     const em::EphemeralUsersEnabledProto& container(
         policy.ephemeral_users_enabled());
     if (container.has_ephemeral_users_enabled()) {
-      policies->Set(key::kDeviceEphemeralUsersEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.ephemeral_users_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceEphemeralUsersEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.ephemeral_users_enabled()),
+          nullptr);
     }
   }
 
   if (policy.has_device_local_accounts()) {
     const em::DeviceLocalAccountsProto& container(
         policy.device_local_accounts());
     const RepeatedPtrField<em::DeviceLocalAccountInfoProto>& accounts =
         container.account();
     std::unique_ptr<base::ListValue> account_list(new base::ListValue());
     for (const auto& entry : accounts) {
@@ skipping 58 matching lines @@
           base::MakeUnique<base::StringValue>(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,
-                    POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                    POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.enable_auto_login_bailout()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceLocalAccountAutoLoginBailoutEnabled,
+          POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.enable_auto_login_bailout()),
+          nullptr);
     }
     if (container.has_prompt_for_network_when_offline()) {
       policies->Set(key::kDeviceLocalAccountPromptForNetworkWhenOffline,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         container.prompt_for_network_when_offline()),
                     nullptr);
     }
   }
 
   if (policy.has_supervised_users_settings()) {
     const em::SupervisedUsersSettingsProto& container =
         policy.supervised_users_settings();
     if (container.has_supervised_users_enabled()) {
-      policies->Set(key::kSupervisedUsersEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.supervised_users_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kSupervisedUsersEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.supervised_users_enabled()),
+          nullptr);
     }
   }
 
   if (policy.has_saml_settings()) {
     const em::SAMLSettingsProto& container(policy.saml_settings());
     if (container.has_transfer_saml_cookies()) {
-      policies->Set(key::kDeviceTransferSAMLCookies, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.transfer_saml_cookies()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceTransferSAMLCookies, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.transfer_saml_cookies()),
+          nullptr);
     }
   }
 
   if (policy.has_login_authentication_behavior()) {
     const em::LoginAuthenticationBehaviorProto& container(
         policy.login_authentication_behavior());
     if (container.has_login_authentication_behavior()) {
       policies->Set(
           key::kLoginAuthenticationBehavior, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
           DecodeIntegerValue(container.login_authentication_behavior()),
           nullptr);
     }
   }
 
   if (policy.has_allow_bluetooth()) {
     const em::AllowBluetoothProto& container(policy.allow_bluetooth());
     if (container.has_allow_bluetooth()) {
-      policies->Set(
-          key::kDeviceAllowBluetooth, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.allow_bluetooth()),
-          nullptr);
+      policies->Set(key::kDeviceAllowBluetooth, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.allow_bluetooth()),
+                    nullptr);
     }
   }
 
   if (policy.has_login_video_capture_allowed_urls()) {
     const em::LoginVideoCaptureAllowedUrlsProto& container(
         policy.login_video_capture_allowed_urls());
     std::unique_ptr<base::ListValue> urls(new base::ListValue());
     for (const auto& entry : container.urls()) {
       urls->AppendString(entry);
     }
@@ skipping 62 matching lines @@
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   std::move(input_methods), nullptr);
   }
 }
 
 void DecodeNetworkPolicies(const em::ChromeDeviceSettingsProto& policy,
                            PolicyMap* policies) {
   if (policy.has_data_roaming_enabled()) {
     const em::DataRoamingEnabledProto& container(policy.data_roaming_enabled());
     if (container.has_data_roaming_enabled()) {
-      policies->Set(key::kDeviceDataRoamingEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.data_roaming_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceDataRoamingEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.data_roaming_enabled()),
+          nullptr);
     }
   }
 
   if (policy.has_network_throttling()) {
     const em::NetworkThrottlingEnabledProto& container(
         policy.network_throttling());
     std::unique_ptr<base::DictionaryValue> throttling_status(
         new base::DictionaryValue());
     bool enabled = (container.has_enabled()) ? container.enabled() : false;
     uint32_t upload_rate_kbits =
@@ skipping 18 matching lines @@
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   base::MakeUnique<base::StringValue>(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,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_version_info()),
-                    nullptr);
+      policies->Set(
+          key::kReportDeviceVersionInfo, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.report_version_info()),
+          nullptr);
     }
     if (container.has_report_activity_times()) {
-      policies->Set(key::kReportDeviceActivityTimes, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_activity_times()),
-                    nullptr);
+      policies->Set(
+          key::kReportDeviceActivityTimes, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.report_activity_times()),
+          nullptr);
     }
     if (container.has_report_boot_mode()) {
       policies->Set(key::kReportDeviceBootMode, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_boot_mode()),
+                    base::MakeUnique<base::Value>(container.report_boot_mode()),
                     nullptr);
     }
     if (container.has_report_location()) {
+      policies->Set(key::kReportDeviceLocation, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.report_location()),
+                    nullptr);
+    }
+    if (container.has_report_network_interfaces()) {
       policies->Set(
-          key::kReportDeviceLocation, POLICY_LEVEL_MANDATORY,
+          key::kReportDeviceNetworkInterfaces, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.report_location()),
+          base::MakeUnique<base::Value>(container.report_network_interfaces()),
           nullptr);
     }
-    if (container.has_report_network_interfaces()) {
-      policies->Set(key::kReportDeviceNetworkInterfaces, POLICY_LEVEL_MANDATORY,
+    if (container.has_report_users()) {
+      policies->Set(key::kReportDeviceUsers, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_network_interfaces()),
+                    base::MakeUnique<base::Value>(container.report_users()),
                     nullptr);
     }
-    if (container.has_report_users()) {
+    if (container.has_report_hardware_status()) {
       policies->Set(
-          key::kReportDeviceUsers, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-          POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.report_users()),
+          key::kReportDeviceHardwareStatus, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.report_hardware_status()),
           nullptr);
     }
-    if (container.has_report_hardware_status()) {
-      policies->Set(key::kReportDeviceHardwareStatus, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_hardware_status()),
-                    nullptr);
-    }
     if (container.has_report_session_status()) {
-      policies->Set(key::kReportDeviceSessionStatus, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.report_session_status()),
-                    nullptr);
+      policies->Set(
+          key::kReportDeviceSessionStatus, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.report_session_status()),
+          nullptr);
     }
     if (container.has_device_status_frequency()) {
       policies->Set(key::kReportUploadFrequency, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.device_status_frequency()),
                     nullptr);
     }
   }
 
   if (policy.has_device_heartbeat_settings()) {
     const em::DeviceHeartbeatSettingsProto& container(
         policy.device_heartbeat_settings());
     if (container.has_heartbeat_enabled()) {
-      policies->Set(key::kHeartbeatEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.heartbeat_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kHeartbeatEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+          POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.heartbeat_enabled()),
+          nullptr);
     }
     if (container.has_heartbeat_frequency()) {
       policies->Set(key::kHeartbeatFrequency, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.heartbeat_frequency()),
                     nullptr);
     }
   }
 
   if (policy.has_device_log_upload_settings()) {
     const em::DeviceLogUploadSettingsProto& container(
         policy.device_log_upload_settings());
     if (container.has_system_log_upload_enabled()) {
-      policies->Set(key::kLogUploadEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.system_log_upload_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kLogUploadEnabled, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+          POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.system_log_upload_enabled()),
+          nullptr);
     }
   }
 }
 
 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);
       // 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::FundamentalValue>(
-                        container.release_channel_delegated()),
-                    nullptr);
+      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::FundamentalValue>(container.update_disabled()),
-          nullptr);
+      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);
     }
 
     // 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::FundamentalValue>(static_cast<int>(
+                    base::MakeUnique<base::Value>(static_cast<int>(
                         container.scatter_factor_in_seconds())),
                     nullptr);
     }
 
     if (container.allowed_connection_types_size()) {
       std::unique_ptr<base::ListValue> allowed_connection_types(
           new base::ListValue);
       for (const auto& entry : container.allowed_connection_types()) {
         std::unique_ptr<base::Value> value = DecodeConnectionType(entry);
         if (value)
           allowed_connection_types->Append(std::move(value));
       }
       policies->Set(key::kDeviceUpdateAllowedConnectionTypes,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD, std::move(allowed_connection_types),
                     nullptr);
     }
 
     if (container.has_http_downloads_enabled()) {
-      policies->Set(key::kDeviceUpdateHttpDownloadsEnabled,
-                    POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                    POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.http_downloads_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceUpdateHttpDownloadsEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.http_downloads_enabled()),
+          nullptr);
     }
 
     if (container.has_reboot_after_update()) {
-      policies->Set(key::kRebootAfterUpdate, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.reboot_after_update()),
-                    nullptr);
+      policies->Set(
+          key::kRebootAfterUpdate, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+          POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.reboot_after_update()),
+          nullptr);
     }
 
     if (container.has_p2p_enabled()) {
-      policies->Set(
-          key::kDeviceAutoUpdateP2PEnabled, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.p2p_enabled()),
-          nullptr);
+      policies->Set(key::kDeviceAutoUpdateP2PEnabled, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.p2p_enabled()),
+                    nullptr);
     }
   }
 
   if (policy.has_allow_kiosk_app_control_chrome_version()) {
     const em::AllowKioskAppControlChromeVersionProto& container(
         policy.allow_kiosk_app_control_chrome_version());
     if (container.has_allow_kiosk_app_control_chrome_version()) {
       policies->Set(key::kAllowKioskAppControlChromeVersion,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         container.allow_kiosk_app_control_chrome_version()),
                     nullptr);
     }
   }
 }
 
 void DecodeAccessibilityPolicies(const em::ChromeDeviceSettingsProto& policy,
                                  PolicyMap* policies) {
   if (policy.has_accessibility_settings()) {
     const em::AccessibilitySettingsProto&
         container(policy.accessibility_settings());
 
     if (container.has_login_screen_default_large_cursor_enabled()) {
       policies->Set(key::kDeviceLoginScreenDefaultLargeCursorEnabled,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         container.login_screen_default_large_cursor_enabled()),
                     nullptr);
     }
 
     if (container.has_login_screen_default_spoken_feedback_enabled()) {
       policies->Set(
           key::kDeviceLoginScreenDefaultSpokenFeedbackEnabled,
           POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(
+          base::MakeUnique<base::Value>(
               container.login_screen_default_spoken_feedback_enabled()),
           nullptr);
     }
 
     if (container.has_login_screen_default_high_contrast_enabled()) {
       policies->Set(key::kDeviceLoginScreenDefaultHighContrastEnabled,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         container.login_screen_default_high_contrast_enabled()),
                     nullptr);
     }
 
     if (container.has_login_screen_default_screen_magnifier_type()) {
       policies->Set(key::kDeviceLoginScreenDefaultScreenMagnifierType,
                     POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(
                         container.login_screen_default_screen_magnifier_type()),
                     nullptr);
     }
 
     if (container.has_login_screen_default_virtual_keyboard_enabled()) {
       policies->Set(
           key::kDeviceLoginScreenDefaultVirtualKeyboardEnabled,
           POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(
+          base::MakeUnique<base::Value>(
               container.login_screen_default_virtual_keyboard_enabled()),
           nullptr);
     }
   }
 }
 
 void DecodeGenericPolicies(const em::ChromeDeviceSettingsProto& policy,
                            PolicyMap* policies) {
   if (policy.has_device_policy_refresh_rate()) {
     const em::DevicePolicyRefreshRateProto& container(
         policy.device_policy_refresh_rate());
     if (container.has_device_policy_refresh_rate()) {
       policies->Set(key::kDevicePolicyRefreshRate, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.device_policy_refresh_rate()),
                     nullptr);
     }
   }
 
   if (policy.has_metrics_enabled()) {
     const em::MetricsEnabledProto& container(policy.metrics_enabled());
     if (container.has_metrics_enabled()) {
-      policies->Set(
-          key::kDeviceMetricsReportingEnabled, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.metrics_enabled()),
-          nullptr);
+      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);
     }
 
     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);
       }
     }
   }
 
   if (policy.has_use_24hour_clock()) {
     if (policy.use_24hour_clock().has_use_24hour_clock()) {
       policies->Set(key::kSystemUse24HourClock, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         policy.use_24hour_clock().use_24hour_clock()),
                     nullptr);
     }
   }
 
   if (policy.has_allow_redeem_offers()) {
     const em::AllowRedeemChromeOsRegistrationOffersProto& container(
         policy.allow_redeem_offers());
     if (container.has_allow_redeem_offers()) {
-      policies->Set(key::kDeviceAllowRedeemChromeOsRegistrationOffers,
-                    POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                    POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.allow_redeem_offers()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceAllowRedeemChromeOsRegistrationOffers,
+          POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.allow_redeem_offers()),
+          nullptr);
     }
   }
 
   if (policy.has_uptime_limit()) {
     const em::UptimeLimitProto& container(policy.uptime_limit());
     if (container.has_uptime_limit()) {
       policies->Set(key::kUptimeLimit, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.uptime_limit()), nullptr);
     }
@@ skipping 17 matching lines @@
                     base::MakeUnique<base::StringValue>(
                         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::FundamentalValue>(
+                    base::MakeUnique<base::Value>(
                         policy.attestation_settings().attestation_enabled()),
                     nullptr);
     }
     if (policy.attestation_settings().has_content_protection_enabled()) {
       policies->Set(
           key::kAttestationForContentProtectionEnabled, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(
+          base::MakeUnique<base::Value>(
               policy.attestation_settings().content_protection_enabled()),
           nullptr);
     }
   }
 
   if (policy.has_system_settings()) {
     const em::SystemSettingsProto& container(policy.system_settings());
     if (container.has_block_devmode()) {
-      policies->Set(
-          key::kDeviceBlockDevmode, POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-          base::MakeUnique<base::FundamentalValue>(container.block_devmode()),
-          nullptr);
+      policies->Set(key::kDeviceBlockDevmode, POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                    base::MakeUnique<base::Value>(container.block_devmode()),
+                    nullptr);
     }
   }
 
   if (policy.has_extension_cache_size()) {
     const em::ExtensionCacheSizeProto& container(policy.extension_cache_size());
     if (container.has_extension_cache_size()) {
       policies->Set(key::kExtensionCacheSize, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.extension_cache_size()),
                     nullptr);
@@ skipping 25 matching lines @@
     }
     policies->Set(key::kUsbDetachableWhitelist, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   std::move(whitelist), nullptr);
   }
 
   if (policy.has_quirks_download_enabled()) {
     const em::DeviceQuirksDownloadEnabledProto& container(
         policy.quirks_download_enabled());
     if (container.has_quirks_download_enabled()) {
-      policies->Set(key::kDeviceQuirksDownloadEnabled, POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
-                    base::MakeUnique<base::FundamentalValue>(
-                        container.quirks_download_enabled()),
-                    nullptr);
+      policies->Set(
+          key::kDeviceQuirksDownloadEnabled, POLICY_LEVEL_MANDATORY,
+          POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+          base::MakeUnique<base::Value>(container.quirks_download_enabled()),
+          nullptr);
     }
   }
 
   if (policy.has_device_wallpaper_image()) {
     const em::DeviceWallpaperImageProto& container(
         policy.device_wallpaper_image());
     if (container.has_device_wallpaper_image()) {
       std::unique_ptr<base::DictionaryValue> dict_val =
           base::DictionaryValue::From(
               base::JSONReader::Read(container.device_wallpaper_image()));
@@ skipping 11 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