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

chrome/browser/ui/webui/options/chromeos/core_chromeos_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/chromeos/core_chromeos_options_handler.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 71 matching lines @@
 
   const bool is_owner =
       user_manager::UserManager::Get()->GetOwnerAccountId().GetUserEmail() ==
       username;
   user_dict->SetBoolean("owner", is_owner);
   return user_dict;
 }
 
 // This function decorates the bare list of emails with some more information
 // needed by the UI to properly display the Accounts page.
-base::Value* CreateUsersWhitelist(const base::Value *pref_value) {
+std::unique_ptr<base::Value> CreateUsersWhitelist(
+    const base::Value* pref_value) {
   const base::ListValue* list_value =
       static_cast<const base::ListValue*>(pref_value);
-  base::ListValue* user_list = new base::ListValue();
+  auto user_list = base::MakeUnique<base::ListValue>();
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   for (base::ListValue::const_iterator i = list_value->begin();
        i != list_value->end(); ++i) {
     std::string email;
     if (i->GetAsString(&email)) {
       // Translate email to the display email.
       const std::string display_email =
           user_manager->GetUserDisplayEmail(AccountId::FromUserEmail(email));
       // TODO(ivankr): fetch display name for existing users.
@@ skipping 58 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&CoreChromeOSOptionsHandler::NotifyOwnershipChanged,
                             base::Unretained(this)));
 }
 
 void CoreChromeOSOptionsHandler::NotifyOwnershipChanged() {
   for (auto it : pref_subscription_map_)
     NotifySettingsChanged(it.first);
 }
 
-base::Value* CoreChromeOSOptionsHandler::FetchPref(
+std::unique_ptr<base::Value> CoreChromeOSOptionsHandler::FetchPref(
     const std::string& pref_name) {
   if (proxy_cros_settings_parser::IsProxyPref(pref_name)) {
-    base::Value* value = nullptr;
+    std::unique_ptr<base::Value> value;
     proxy_cros_settings_parser::GetProxyPrefValue(
         network_guid_, pref_name, GetUiProxyConfigService(), &value);
-    return value ? value : new base::Value();
+    return value;
   }
 
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!CrosSettings::IsCrosSettings(pref_name)) {
     std::string controlling_pref =
         pref_name == proxy_config::prefs::kUseSharedProxies
             ? proxy_config::prefs::kProxy
             : std::string();
-    base::Value* value = CreateValueForPref(pref_name, controlling_pref);
+    std::unique_ptr<base::Value> value =
+        CreateValueForPref(pref_name, controlling_pref);
     if (!IsSettingShared(pref_name) || !IsSecondaryUser(profile))
       return value;
     base::DictionaryValue* dict;
     if (!value->GetAsDictionary(&dict) || dict->HasKey("controlledBy"))
       return value;
     Profile* primary_profile = ProfileHelper::Get()->GetProfileByUser(
         user_manager::UserManager::Get()->GetPrimaryUser());
     if (!primary_profile)
       return value;
     dict->SetString("controlledBy", "shared");
     dict->SetBoolean("disabled", true);
     dict->SetBoolean("value", primary_profile->GetPrefs()->GetBoolean(
         pref_name));
-    return dict;
+    return value;
   }
 
   const base::Value* pref_value = CrosSettings::Get()->GetPref(pref_name);
   if (!pref_value)
-    return new base::Value();
+    return base::MakeUnique<base::Value>();
 
   // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
   // TODO(estade): seems that this should replicate CreateValueForPref less.
-  base::DictionaryValue* dict = new base::DictionaryValue;
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   if (pref_name == kAccountsPrefUsers)
     dict->Set("value", CreateUsersWhitelist(pref_value));
   else
-    dict->Set("value", pref_value->DeepCopy());
+    dict->Set("value", base::MakeUnique<base::Value>(*pref_value));
 
   std::string controlled_by;
   if (IsSettingPrivileged(pref_name)) {
     policy::BrowserPolicyConnectorChromeOS* connector =
         g_browser_process->platform_part()->browser_policy_connector_chromeos();
     if (connector->IsEnterpriseManaged())
       controlled_by = "policy";
     else if (!ProfileHelper::IsOwnerProfile(profile))
       controlled_by = "owner";
   }
@@ skipping 47 matching lines @@
 void CoreChromeOSOptionsHandler::StopObservingPref(const std::string& path) {
   if (proxy_cros_settings_parser::IsProxyPref(path))
     return;  // We unregister those in the destructor.
   // Unregister this instance from observing prefs of chrome os settings.
   if (CrosSettings::IsCrosSettings(path))
     pref_subscription_map_.erase(path);
   else  // Call base class to handle regular preferences.
     ::options::CoreOptionsHandler::StopObservingPref(path);
 }
 
-base::Value* CoreChromeOSOptionsHandler::CreateValueForPref(
+std::unique_ptr<base::Value> CoreChromeOSOptionsHandler::CreateValueForPref(
     const std::string& pref_name,
     const std::string& controlling_pref_name) {
   // The screen lock setting is shared if multiple users are logged in and at
   // least one has chosen to require passwords.
   if (pref_name == prefs::kEnableAutoScreenLock &&
       user_manager::UserManager::Get()->GetLoggedInUsers().size() > 1 &&
       controlling_pref_name.empty()) {
     PrefService* user_prefs = Profile::FromWebUI(web_ui())->GetPrefs();
     const PrefService::Preference* pref =
         user_prefs->FindPreference(prefs::kEnableAutoScreenLock);
 
     if (pref && pref->IsUserModifiable() &&
         SessionControllerClient::ShouldLockScreenAutomatically()) {
       bool screen_lock = false;
       bool success = pref->GetValue()->GetAsBoolean(&screen_lock);
       DCHECK(success);
       if (!screen_lock) {
         // Screen lock is enabled for the session, but not in the user's
         // preferences. Show the user's value in the checkbox, but indicate
         // that the password requirement is enabled by some other user.
-        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()));
         dict->SetString("controlledBy", "shared");
         return dict;
       }
     }
   }
 
   return CoreOptionsHandler::CreateValueForPref(pref_name,
                                                 controlling_pref_name);
 }
 
@@ skipping 87 matching lines @@
   DCHECK(CrosSettings::Get()->IsCrosSettings(setting_name));
   std::unique_ptr<base::Value> value(FetchPref(setting_name));
   if (!value.get())
     NOTREACHED();
   DispatchPrefChangeNotification(setting_name, std::move(value));
 }
 
 void CoreChromeOSOptionsHandler::NotifyProxyPrefsChanged() {
   GetUiProxyConfigService()->UpdateFromPrefs(network_guid_);
   for (size_t i = 0; i < proxy_cros_settings_parser::kProxySettingsCount; ++i) {
-    base::Value* value = NULL;
+    std::unique_ptr<base::Value> value;
     proxy_cros_settings_parser::GetProxyPrefValue(
         network_guid_, proxy_cros_settings_parser::kProxySettings[i],
         GetUiProxyConfigService(), &value);
     DCHECK(value);
-    std::unique_ptr<base::Value> ptr(value);
     DispatchPrefChangeNotification(
-        proxy_cros_settings_parser::kProxySettings[i], std::move(ptr));
+        proxy_cros_settings_parser::kProxySettings[i], std::move(value));
   }
 }
 
 }  // namespace options
 }  // namespace chromeos