Stop passing raw pointers to base::Value API in c/b/ui

chrome/browser/ui/webui/options/core_options_handler.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/ui/webui/options/core_options_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
@@ skipping 220 matching lines @@
 void CoreOptionsHandler::HandleInitialize(const base::ListValue* args) {
   DCHECK(handlers_host_);
   handlers_host_->InitializeHandlers();
 }
 
 void CoreOptionsHandler::OnFinishedLoading(const base::ListValue* args) {
   DCHECK(handlers_host_);
   handlers_host_->OnFinishedLoading();
 }
 
-base::Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
+std::unique_ptr<base::Value> CoreOptionsHandler::FetchPref(
+    const std::string& pref_name) {
   return CreateValueForPref(pref_name, std::string());
 }
 
 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
   if (g_browser_process->local_state()->FindPreference(pref_name)) {
     local_state_registrar_.Add(
         pref_name,
         base::Bind(&CoreOptionsHandler::OnPreferenceChanged,
                    base::Unretained(this),
                    local_state_registrar_.prefs()));
@@ skipping 91 matching lines @@
   base::ListValue result_value;
   result_value.AppendString(name);
   result_value.Append(std::move(value));
   for (PreferenceCallbackMap::const_iterator iter = range.first;
        iter != range.second; ++iter) {
     const std::string& callback_function = iter->second;
     web_ui()->CallJavascriptFunctionUnsafe(callback_function, result_value);
   }
 }
 
-base::Value* CoreOptionsHandler::CreateValueForPref(
+std::unique_ptr<base::Value> CoreOptionsHandler::CreateValueForPref(
     const std::string& pref_name,
     const std::string& controlling_pref_name) {
   const PrefService* pref_service = FindServiceForPref(pref_name);
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name);
   if (!pref) {
     NOTREACHED();
-    return new base::Value();
+    return base::MakeUnique<base::Value>();
   }
   const PrefService::Preference* controlling_pref =
       pref_service->FindPreference(controlling_pref_name);
   if (!controlling_pref)
     controlling_pref = pref;
 
-  base::DictionaryValue* dict = new base::DictionaryValue;
-  dict->Set("value", pref->GetValue()->DeepCopy());
+  auto dict = base::MakeUnique<base::DictionaryValue>();
+  dict->Set("value", base::MakeUnique<base::Value>(*pref->GetValue()));
   if (controlling_pref->IsManaged()) {
     dict->SetString("controlledBy", "policy");
   } else if (controlling_pref->IsExtensionControlled() &&
              CanSetExtensionControlledPrefValue(controlling_pref)) {
     Profile* profile = Profile::FromWebUI(web_ui());
     ExtensionPrefValueMap* extension_pref_value_map =
         ExtensionPrefValueMapFactory::GetForBrowserContext(profile);
     std::string extension_id =
         extension_pref_value_map->GetExtensionControllingPref(
             controlling_pref->name());
 
     const extensions::Extension* extension =
         extensions::ExtensionRegistry::Get(profile)->GetExtensionById(
             extension_id, extensions::ExtensionRegistry::EVERYTHING);
     if (extension) {
       dict->SetString("controlledBy", "extension");
-      dict->Set("extension",
-                extensions::util::GetExtensionInfo(extension).release());
+      dict->Set("extension", extensions::util::GetExtensionInfo(extension));
     }
   } else if (controlling_pref->IsRecommended()) {
     dict->SetString("controlledBy", "recommended");
   }
 
   const base::Value* recommended_value =
       controlling_pref->GetRecommendedValue();
   if (recommended_value)
-    dict->Set("recommendedValue", recommended_value->DeepCopy());
+    dict->Set("recommendedValue",
+              base::MakeUnique<base::Value>(*recommended_value));
   dict->SetBoolean("disabled", !controlling_pref->IsUserModifiable());
-  return dict;
+  return std::move(dict);
 }
 
 PrefService* CoreOptionsHandler::FindServiceForPref(
     const std::string& pref_name) {
   // Proxy is a peculiar case: on ChromeOS, settings exist in both user
   // prefs and local state, but chrome://settings should affect only user prefs.
   // Elsewhere the proxy settings are stored in local state.
   // See http://crbug.com/157147
   PrefService* user_prefs = Profile::FromWebUI(web_ui())->GetPrefs();
   if (pref_name == proxy_config::prefs::kProxy)
@@ skipping 231 matching lines @@
       plugin_status_pref_setter_.IsPepperFlashSettingsEnabled());
   web_ui()->CallJavascriptFunctionUnsafe(
       "options.OptionsPage.setPepperFlashSettingsEnabled", enabled);
 }
 
 bool CoreOptionsHandler::IsUserUnsupervised(const base::Value* to_value) {
   return !Profile::FromWebUI(web_ui())->IsSupervised();
 }
 
 }  // namespace options