Use std::unique_ptr to express ownership of base::Value in PolicyMap::Entry

chrome/browser/chromeos/policy/configuration_policy_handler_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/configuration_policy_handler_chromeos.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
 #include "components/onc/onc_constants.h"
@@ skipping 229 matching lines @@
   // Currently, only the per-network configuration is stored in a pref. Ignore
   // |global_network_config| and |certificates|.
   prefs->SetValue(pref_path_, std::move(network_configs));
 }
 
 void NetworkConfigurationPolicyHandler::PrepareForDisplaying(
     PolicyMap* policies) const {
   const PolicyMap::Entry* entry = policies->Get(policy_name());
   if (!entry)
     return;
-  base::Value* sanitized_config = SanitizeNetworkConfig(entry->value);
+  std::unique_ptr<base::Value> sanitized_config =
+      SanitizeNetworkConfig(entry->value.get());
   if (!sanitized_config)
-    sanitized_config = base::Value::CreateNullValue().release();
+    sanitized_config = base::Value::CreateNullValue();
 
-  policies->Set(policy_name(), entry->level, entry->scope,
-                entry->source, sanitized_config, nullptr);
+  policies->Set(policy_name(), entry->level, entry->scope, entry->source,
+                std::move(sanitized_config), nullptr);
 }
 
 NetworkConfigurationPolicyHandler::NetworkConfigurationPolicyHandler(
     const char* policy_name,
     onc::ONCSource onc_source,
     const char* pref_path)
     : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_STRING),
       onc_source_(onc_source),
       pref_path_(pref_path) {
 }
 
 // static
-base::Value* NetworkConfigurationPolicyHandler::SanitizeNetworkConfig(
+std::unique_ptr<base::Value>
+NetworkConfigurationPolicyHandler::SanitizeNetworkConfig(
     const base::Value* config) {
   std::string json_string;
   if (!config->GetAsString(&json_string))
     return NULL;
 
   std::unique_ptr<base::DictionaryValue> toplevel_dict =
       chromeos::onc::ReadDictionaryFromJson(json_string);
   if (!toplevel_dict)
     return NULL;
 
   // Placeholder to insert in place of the filtered setting.
   const char kPlaceholder[] = "********";
 
   toplevel_dict = chromeos::onc::MaskCredentialsInOncObject(
       chromeos::onc::kToplevelConfigurationSignature,
       *toplevel_dict,
       kPlaceholder);
 
   base::JSONWriter::WriteWithOptions(
       *toplevel_dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_string);
-  return new base::StringValue(json_string);
+  return base::WrapUnique(new base::StringValue(json_string));
 }
 
 PinnedLauncherAppsPolicyHandler::PinnedLauncherAppsPolicyHandler()
     : ExtensionListPolicyHandler(key::kPinnedLauncherApps,
                                  prefs::kPolicyPinnedLauncherApps,
                                  false) {}
 
 PinnedLauncherAppsPolicyHandler::~PinnedLauncherAppsPolicyHandler() {}
 
 void PinnedLauncherAppsPolicyHandler::ApplyPolicySettings(
@@ skipping 158 matching lines @@
 
   value = GetValue(dict, kScreenLockDelayAC);
   if (value)
     prefs->SetValue(prefs::kPowerAcScreenLockDelayMs, std::move(value));
   value = GetValue(dict, kScreenLockDelayBattery);
   if (value)
     prefs->SetValue(prefs::kPowerBatteryScreenLockDelayMs, std::move(value));
 }
 
 }  // namespace policy