Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/commands/command_service.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/extensions/api/commands/command_service.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/api/commands/commands.h"
 #include "chrome/browser/extensions/extension_commands_global_registry.h"
 #include "chrome/browser/extensions/extension_keybinding_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/accelerator_utils.h"
 #include "chrome/common/extensions/api/commands/commands_handler.h"
 #include "chrome/common/extensions/manifest_handlers/ui_overrides_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
@@ skipping 245 matching lines @@
     item->GetString(kCommandName, &old_command_name);
     RemoveKeybindingPrefs(old_extension_id, old_command_name);
   }
 
   // If the command that is taking a new shortcut already has a shortcut, remove
   // it before assigning the new one.
   if (existing_command.accelerator().key_code() != ui::VKEY_UNKNOWN)
     RemoveKeybindingPrefs(extension_id, command_name);
 
   // Set the keybinding pref.
-  base::DictionaryValue* keybinding = new base::DictionaryValue();
+  auto keybinding = base::MakeUnique<base::DictionaryValue>();
   keybinding->SetString(kExtension, extension_id);
   keybinding->SetString(kCommandName, command_name);
   keybinding->SetBoolean(kGlobal, global);
 
-  bindings->Set(key, keybinding);
+  bindings->Set(key, std::move(keybinding));
 
   // Set the was_assigned pref for the suggested key.
   std::unique_ptr<base::DictionaryValue> command_keys(
       new base::DictionaryValue);
   command_keys->SetBoolean(kSuggestedKeyWasAssigned, true);
   std::unique_ptr<base::DictionaryValue> suggested_key_prefs(
       new base::DictionaryValue);
-  suggested_key_prefs->Set(command_name, command_keys.release());
+  suggested_key_prefs->Set(command_name, std::move(command_keys));
   MergeSuggestedKeyPrefs(extension_id, ExtensionPrefs::Get(profile_),
                          std::move(suggested_key_prefs));
 
   // Fetch the newly-updated command, and notify the observers.
   for (auto& observer : observers_) {
     observer.OnExtensionCommandAdded(
         extension_id, FindCommandByName(extension_id, command_name));
   }
 
   // TODO(devlin): Deprecate this notification in favor of the observers.
@@ skipping 335 matching lines @@
   const CommandMap* commands = CommandsInfo::GetNamedCommands(extension);
   if (commands) {
     for (CommandMap::const_iterator iter = commands->begin();
          iter != commands->end(); ++iter) {
       const Command command = iter->second;
       std::unique_ptr<base::DictionaryValue> command_keys(
           new base::DictionaryValue);
       command_keys->SetString(
           kSuggestedKey,
           Command::AcceleratorToString(command.accelerator()));
-      suggested_key_prefs->Set(command.command_name(), command_keys.release());
+      suggested_key_prefs->Set(command.command_name(), std::move(command_keys));
     }
   }
 
   const Command* browser_action_command =
       CommandsInfo::GetBrowserActionCommand(extension);
   // The browser action command may be defaulted to an unassigned accelerator if
   // a browser action is specified by the extension but a keybinding is not
   // declared. See CommandsHandler::MaybeSetBrowserActionDefault.
   if (browser_action_command &&
       browser_action_command->accelerator().key_code() != ui::VKEY_UNKNOWN) {
     std::unique_ptr<base::DictionaryValue> command_keys(
         new base::DictionaryValue);
     command_keys->SetString(
         kSuggestedKey,
         Command::AcceleratorToString(browser_action_command->accelerator()));
     suggested_key_prefs->Set(browser_action_command->command_name(),
-                             command_keys.release());
+                             std::move(command_keys));
   }
 
   const Command* page_action_command =
       CommandsInfo::GetPageActionCommand(extension);
   if (page_action_command) {
     std::unique_ptr<base::DictionaryValue> command_keys(
         new base::DictionaryValue);
     command_keys->SetString(
         kSuggestedKey,
         Command::AcceleratorToString(page_action_command->accelerator()));
     suggested_key_prefs->Set(page_action_command->command_name(),
-               command_keys.release());
+                             std::move(command_keys));
   }
 
   // Merge into current prefs, if present.
   MergeSuggestedKeyPrefs(extension->id(), ExtensionPrefs::Get(profile_),
                          std::move(suggested_key_prefs));
 }
 
 void CommandService::RemoveDefunctExtensionSuggestedCommandPrefs(
     const Extension* extension) {
   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
@@ skipping 219 matching lines @@
   return true;
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions