Remove base::FundamentalValue

chrome/browser/policy/configuration_policy_handler_list_factory.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 "chrome/browser/policy/configuration_policy_handler_list_factory.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include <utility>
@@ skipping 661 matching lines @@
     const base::Value* value = policies.GetValue(policy_name());
     if (value) {
       bool enabled;
       prefs->SetValue(prefs::kForceGoogleSafeSearch, value->CreateDeepCopy());
 
       // Note that ForceYouTubeRestrict is an int policy, we cannot simply deep
       // copy value, which is a boolean.
       if (value->GetAsBoolean(&enabled)) {
         prefs->SetValue(
             prefs::kForceYouTubeRestrict,
-            base::MakeUnique<base::FundamentalValue>(
+            base::MakeUnique<base::Value>(
                 enabled ? safe_search_util::YOUTUBE_RESTRICT_MODERATE
                         : safe_search_util::YOUTUBE_RESTRICT_OFF));
       }
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ForceSafeSearchPolicyHandler);
 };
 
 class ForceYouTubeSafetyModePolicyHandler : public TypeCheckingPolicyHandler {
  public:
   ForceYouTubeSafetyModePolicyHandler()
       : TypeCheckingPolicyHandler(key::kForceYouTubeSafetyMode,
                                   base::Value::Type::BOOLEAN) {}
   ~ForceYouTubeSafetyModePolicyHandler() override {}
 
   // ConfigurationPolicyHandler implementation:
   void ApplyPolicySettings(const PolicyMap& policies,
                            PrefValueMap* prefs) override {
     // If only the deprecated ForceYouTubeSafetyMode policy is set,
     // but not ForceYouTubeRestrict, set ForceYouTubeRestrict to Moderate.
     if (policies.GetValue(key::kForceYouTubeRestrict))
       return;
 
     const base::Value* value = policies.GetValue(policy_name());
     bool enabled;
     if (value && value->GetAsBoolean(&enabled)) {
-      prefs->SetValue(
-          prefs::kForceYouTubeRestrict,
-          base::MakeUnique<base::FundamentalValue>(
-              enabled ? safe_search_util::YOUTUBE_RESTRICT_MODERATE
-                      : safe_search_util::YOUTUBE_RESTRICT_OFF));
+      prefs->SetValue(prefs::kForceYouTubeRestrict,
+                      base::MakeUnique<base::Value>(
+                          enabled ? safe_search_util::YOUTUBE_RESTRICT_MODERATE
+                                  : safe_search_util::YOUTUBE_RESTRICT_OFF));
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ForceYouTubeSafetyModePolicyHandler);
 };
 
 class BrowsingHistoryPolicyHandler : public TypeCheckingPolicyHandler {
  public:
   BrowsingHistoryPolicyHandler()
@@ skipping 21 matching lines @@
         result) {
   // Mapping from extension type names to Manifest::Type.
   for (size_t index = 0;
        index < extensions::schema_constants::kAllowedTypesMapSize;
        ++index) {
     const extensions::schema_constants::AllowedTypesMapEntry& entry =
         extensions::schema_constants::kAllowedTypesMap[index];
     result->push_back(
         base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>(
             entry.name, std::unique_ptr<base::Value>(
-                            new base::FundamentalValue(entry.manifest_type))));
+                            new base::Value(entry.manifest_type))));
   }
 }
 
 // Piggy-back kDeveloperToolsDisabled set to true to also force-disable
 // kExtensionsUIDeveloperMode.
 class DevToolsExtensionsUIPolicyHandler : public TypeCheckingPolicyHandler {
  public:
   DevToolsExtensionsUIPolicyHandler()
       : TypeCheckingPolicyHandler(key::kDeveloperToolsDisabled,
                                   base::Value::Type::BOOLEAN) {}
   ~DevToolsExtensionsUIPolicyHandler() override {}
 
   // ConfigurationPolicyHandler implementation:
   void ApplyPolicySettings(const PolicyMap& policies,
                            PrefValueMap* prefs) override {
     const base::Value* value = policies.GetValue(policy_name());
     bool developerToolsDisabled;
     if (value && value->GetAsBoolean(&developerToolsDisabled) &&
         developerToolsDisabled) {
       prefs->SetValue(prefs::kExtensionsUIDeveloperMode,
-                      base::MakeUnique<base::FundamentalValue>(false));
+                      base::MakeUnique<base::Value>(false));
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DevToolsExtensionsUIPolicyHandler);
 };
 #endif
 
 void GetDeprecatedFeaturesMap(
     std::vector<std::unique_ptr<StringMappingListPolicyHandler::MappingEntry>>*
@@ skipping 220 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   handlers->AddHandler(base::MakeUnique<PluginPolicyHandler>());
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
   return handlers;
 }
 
 }  // namespace policy