Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

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"
@@ skipping 86 matching lines @@
     return false;
 
   return assigned;
 }
 
 // Merge |suggested_key_prefs| into the saved preferences for the extension. We
 // merge rather than overwrite to preserve existing was_assigned preferences.
 void MergeSuggestedKeyPrefs(
     const std::string& extension_id,
     ExtensionPrefs* extension_prefs,
-    scoped_ptr<base::DictionaryValue> suggested_key_prefs) {
+    std::unique_ptr<base::DictionaryValue> suggested_key_prefs) {
   const base::DictionaryValue* current_prefs;
   if (extension_prefs->ReadPrefAsDictionary(extension_id,
                                             kCommands,
                                             &current_prefs)) {
-    scoped_ptr<base::DictionaryValue> new_prefs(current_prefs->DeepCopy());
+    std::unique_ptr<base::DictionaryValue> new_prefs(current_prefs->DeepCopy());
     new_prefs->MergeDictionary(suggested_key_prefs.get());
     suggested_key_prefs.reset(new_prefs.release());
   }
 
   extension_prefs->UpdateExtensionPref(extension_id,
                                        kCommands,
                                        suggested_key_prefs.release());
 }
 
 }  // namespace
@@ skipping 154 matching lines @@
 
   // Set the keybinding pref.
   base::DictionaryValue* keybinding = new base::DictionaryValue();
   keybinding->SetString(kExtension, extension_id);
   keybinding->SetString(kCommandName, command_name);
   keybinding->SetBoolean(kGlobal, global);
 
   bindings->Set(key, keybinding);
 
   // Set the was_assigned pref for the suggested key.
-  scoped_ptr<base::DictionaryValue> command_keys(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> command_keys(
+      new base::DictionaryValue);
   command_keys->SetBoolean(kSuggestedKeyWasAssigned, true);
-  scoped_ptr<base::DictionaryValue> suggested_key_prefs(
+  std::unique_ptr<base::DictionaryValue> suggested_key_prefs(
       new base::DictionaryValue);
   suggested_key_prefs->Set(command_name, command_keys.release());
   MergeSuggestedKeyPrefs(extension_id, ExtensionPrefs::Get(profile_),
                          std::move(suggested_key_prefs));
 
   // Fetch the newly-updated command, and notify the observers.
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       OnExtensionCommandAdded(extension_id,
@@ skipping 325 matching lines @@
       DCHECK(chrome::IsChromeAccelerator(command.accelerator(), profile_));
       return true;
     }
 
     return !chrome::IsChromeAccelerator(command.accelerator(), profile_);
   }
 }
 
 void CommandService::UpdateExtensionSuggestedCommandPrefs(
     const Extension* extension) {
-  scoped_ptr<base::DictionaryValue> suggested_key_prefs(
+  std::unique_ptr<base::DictionaryValue> suggested_key_prefs(
       new base::DictionaryValue);
 
   const CommandMap* commands = CommandsInfo::GetNamedCommands(extension);
   if (commands) {
     for (CommandMap::const_iterator iter = commands->begin();
          iter != commands->end(); ++iter) {
       const Command command = iter->second;
-      scoped_ptr<base::DictionaryValue> command_keys(new base::DictionaryValue);
+      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());
     }
   }
 
   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) {
-    scoped_ptr<base::DictionaryValue> command_keys(new base::DictionaryValue);
+    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());
   }
 
   const Command* page_action_command =
       CommandsInfo::GetPageActionCommand(extension);
   if (page_action_command) {
-    scoped_ptr<base::DictionaryValue> command_keys(new base::DictionaryValue);
+    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());
   }
 
   // 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_);
   const base::DictionaryValue* current_prefs = NULL;
   extension_prefs->ReadPrefAsDictionary(extension->id(),
                                         kCommands,
                                         &current_prefs);
 
   if (current_prefs) {
-    scoped_ptr<base::DictionaryValue> suggested_key_prefs(
+    std::unique_ptr<base::DictionaryValue> suggested_key_prefs(
         current_prefs->DeepCopy());
     const CommandMap* named_commands =
         CommandsInfo::GetNamedCommands(extension);
     const Command* browser_action_command =
         CommandsInfo::GetBrowserActionCommand(extension);
     for (base::DictionaryValue::Iterator it(*current_prefs);
          !it.IsAtEnd(); it.Advance()) {
       if (it.key() == manifest_values::kBrowserActionCommandEvent) {
         // The browser action command may be defaulted to an unassigned
         // accelerator if a browser action is specified by the extension but a
@@ skipping 205 matching lines @@
   return true;
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<CommandService>::DeclareFactoryDependencies() {
   DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
 }
 
 }  // namespace extensions