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

chrome/browser/extensions/api/developer_private/developer_private_api.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/developer_private/developer_private_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 119 matching lines @@
     *error = kCannotModifyPolicyExtensionError;
     return false;
   }
 
   return true;
 }
 
 // Runs the install verifier for all extensions that are enabled, disabled, or
 // terminated.
 void PerformVerificationCheck(content::BrowserContext* context) {
-  scoped_ptr<ExtensionSet> extensions =
+  std::unique_ptr<ExtensionSet> extensions =
       ExtensionRegistry::Get(context)->GenerateInstalledExtensionsSet(
-          ExtensionRegistry::ENABLED |
-          ExtensionRegistry::DISABLED |
+          ExtensionRegistry::ENABLED | ExtensionRegistry::DISABLED |
           ExtensionRegistry::TERMINATED);
   ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
   bool should_do_verification_check = false;
   for (const scoped_refptr<const Extension>& extension : *extensions) {
     if (ui_util::ShouldDisplayInExtensionSettings(extension.get(), context) &&
         ((prefs->GetDisableReasons(extension->id()) &
              Extension::DISABLE_NOT_VERIFIED) != 0)) {
       should_do_verification_check = true;
       break;
     }
   }
 
   UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
                         should_do_verification_check);
   if (should_do_verification_check)
     InstallVerifier::Get(context)->VerifyAllExtensions();
 }
 
-scoped_ptr<developer::ProfileInfo> CreateProfileInfo(Profile* profile) {
-  scoped_ptr<developer::ProfileInfo> info(new developer::ProfileInfo());
+std::unique_ptr<developer::ProfileInfo> CreateProfileInfo(Profile* profile) {
+  std::unique_ptr<developer::ProfileInfo> info(new developer::ProfileInfo());
   info->is_supervised = profile->IsSupervised();
   PrefService* prefs = profile->GetPrefs();
   info->is_incognito_available =
       IncognitoModePrefs::GetAvailability(prefs) !=
           IncognitoModePrefs::DISABLED;
   info->in_developer_mode =
       !info->is_supervised &&
       prefs->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   info->app_info_dialog_enabled = CanShowAppInfoDialog();
   info->can_load_unpacked =
@@ skipping 167 matching lines @@
     bool is_now_visible) {
   BroadcastItemStateChanged(developer::EVENT_TYPE_PREFS_CHANGED, extension_id);
 }
 
 void DeveloperPrivateEventRouter::OnExtensionDisableReasonsChanged(
     const std::string& extension_id, int disable_reasons) {
   BroadcastItemStateChanged(developer::EVENT_TYPE_PREFS_CHANGED, extension_id);
 }
 
 void DeveloperPrivateEventRouter::OnExtensionManagementSettingsChanged() {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(CreateProfileInfo(profile_)->ToValue());
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::DEVELOPER_PRIVATE_ON_PROFILE_STATE_CHANGED,
                 developer::OnProfileStateChanged::kEventName, std::move(args)));
   event_router_->BroadcastEvent(std::move(event));
 }
 
 void DeveloperPrivateEventRouter::ExtensionWarningsChanged(
     const ExtensionIdSet& affected_extensions) {
   for (const ExtensionId& id : affected_extensions)
     BroadcastItemStateChanged(developer::EVENT_TYPE_WARNINGS_CHANGED, id);
 }
 
 void DeveloperPrivateEventRouter::OnProfilePrefChanged() {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(CreateProfileInfo(profile_)->ToValue());
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::DEVELOPER_PRIVATE_ON_PROFILE_STATE_CHANGED,
                 developer::OnProfileStateChanged::kEventName, std::move(args)));
   event_router_->BroadcastEvent(std::move(event));
 }
 
 void DeveloperPrivateEventRouter::BroadcastItemStateChanged(
     developer::EventType event_type,
     const std::string& extension_id) {
-  scoped_ptr<ExtensionInfoGenerator> info_generator(
+  std::unique_ptr<ExtensionInfoGenerator> info_generator(
       new ExtensionInfoGenerator(profile_));
   ExtensionInfoGenerator* info_generator_weak = info_generator.get();
   info_generator_weak->CreateExtensionInfo(
       extension_id,
       base::Bind(&DeveloperPrivateEventRouter::BroadcastItemStateChangedHelper,
                  weak_factory_.GetWeakPtr(), event_type, extension_id,
                  base::Passed(std::move(info_generator))));
 }
 
 void DeveloperPrivateEventRouter::BroadcastItemStateChangedHelper(
     developer::EventType event_type,
     const std::string& extension_id,
-    scoped_ptr<ExtensionInfoGenerator> info_generator,
+    std::unique_ptr<ExtensionInfoGenerator> info_generator,
     ExtensionInfoGenerator::ExtensionInfoList infos) {
   DCHECK_LE(infos.size(), 1u);
 
   developer::EventData event_data;
   event_data.event_type = event_type;
   event_data.item_id = extension_id;
   if (!infos.empty()) {
     event_data.extension_info.reset(
         new developer::ExtensionInfo(std::move(infos[0])));
   }
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(event_data.ToValue());
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::DEVELOPER_PRIVATE_ON_ITEM_STATE_CHANGED,
                 developer::OnItemStateChanged::kEventName, std::move(args)));
   event_router_->BroadcastEvent(std::move(event));
 }
 
 void DeveloperPrivateAPI::SetLastUnpackedDirectory(const base::FilePath& path) {
   last_unpacked_directory_ = path;
 }
 
 void DeveloperPrivateAPI::RegisterNotifications() {
@@ skipping 58 matching lines @@
 DeveloperPrivateGetExtensionsInfoFunction::
 DeveloperPrivateGetExtensionsInfoFunction() {
 }
 
 DeveloperPrivateGetExtensionsInfoFunction::
 ~DeveloperPrivateGetExtensionsInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetExtensionsInfoFunction::Run() {
-  scoped_ptr<developer::GetExtensionsInfo::Params> params(
+  std::unique_ptr<developer::GetExtensionsInfo::Params> params(
       developer::GetExtensionsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   bool include_disabled = true;
   bool include_terminated = true;
   if (params->options) {
     if (params->options->include_disabled)
       include_disabled = *params->options->include_disabled;
     if (params->options->include_terminated)
       include_terminated = *params->options->include_terminated;
@@ skipping 17 matching lines @@
 DeveloperPrivateGetExtensionInfoFunction::
 DeveloperPrivateGetExtensionInfoFunction() {
 }
 
 DeveloperPrivateGetExtensionInfoFunction::
 ~DeveloperPrivateGetExtensionInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetExtensionInfoFunction::Run() {
-  scoped_ptr<developer::GetExtensionInfo::Params> params(
+  std::unique_ptr<developer::GetExtensionInfo::Params> params(
       developer::GetExtensionInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   info_generator_.reset(new ExtensionInfoGenerator(browser_context()));
   info_generator_->CreateExtensionInfo(
       params->id,
       base::Bind(&DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated,
                  this /* refcounted */));
 
   return RespondLater();
 }
 
 void DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated(
     ExtensionInfoGenerator::ExtensionInfoList list) {
   DCHECK_LE(1u, list.size());
   Respond(list.empty() ? Error(kNoSuchExtensionError)
                        : OneArgument(list[0].ToValue()));
 }
 
 DeveloperPrivateGetItemsInfoFunction::DeveloperPrivateGetItemsInfoFunction() {}
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateGetItemsInfoFunction::Run() {
-  scoped_ptr<developer::GetItemsInfo::Params> params(
+  std::unique_ptr<developer::GetItemsInfo::Params> params(
       developer::GetItemsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   info_generator_.reset(new ExtensionInfoGenerator(browser_context()));
   info_generator_->CreateExtensionsInfo(
       params->include_disabled,
       params->include_terminated,
       base::Bind(&DeveloperPrivateGetItemsInfoFunction::OnInfosGenerated,
                  this /* refcounted */));
 
   return RespondLater();
 }
 
 void DeveloperPrivateGetItemsInfoFunction::OnInfosGenerated(
     ExtensionInfoGenerator::ExtensionInfoList list) {
   std::vector<developer::ItemInfo> item_list;
   for (const developer::ExtensionInfo& info : list)
     item_list.push_back(developer_private_mangle::MangleExtensionInfo(info));
 
   Respond(ArgumentList(developer::GetItemsInfo::Results::Create(item_list)));
 }
 
 DeveloperPrivateGetProfileConfigurationFunction::
 ~DeveloperPrivateGetProfileConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetProfileConfigurationFunction::Run() {
-  scoped_ptr<developer::ProfileInfo> info = CreateProfileInfo(GetProfile());
+  std::unique_ptr<developer::ProfileInfo> info =
+      CreateProfileInfo(GetProfile());
 
   // If this is called from the chrome://extensions page, we use this as a
   // heuristic that it's a good time to verify installs. We do this on startup,
   // but there's a chance that it failed erroneously, so it's good to double-
   // check.
   if (source_context_type() == Feature::WEBUI_CONTEXT)
     PerformVerificationCheck(browser_context());
 
   return RespondNow(OneArgument(info->ToValue()));
 }
 
 DeveloperPrivateUpdateProfileConfigurationFunction::
 ~DeveloperPrivateUpdateProfileConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateUpdateProfileConfigurationFunction::Run() {
-  scoped_ptr<developer::UpdateProfileConfiguration::Params> params(
+  std::unique_ptr<developer::UpdateProfileConfiguration::Params> params(
       developer::UpdateProfileConfiguration::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const developer::ProfileConfigurationUpdate& update = params->update;
   PrefService* prefs = GetProfile()->GetPrefs();
   if (update.in_developer_mode) {
     if (GetProfile()->IsSupervised())
       return RespondNow(Error(kCannotUpdateSupervisedProfileSettingsError));
     prefs->SetBoolean(prefs::kExtensionsUIDeveloperMode,
                       *update.in_developer_mode);
   }
 
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateUpdateExtensionConfigurationFunction::
 ~DeveloperPrivateUpdateExtensionConfigurationFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateUpdateExtensionConfigurationFunction::Run() {
-  scoped_ptr<developer::UpdateExtensionConfiguration::Params> params(
+  std::unique_ptr<developer::UpdateExtensionConfiguration::Params> params(
       developer::UpdateExtensionConfiguration::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const developer::ExtensionConfigurationUpdate& update = params->update;
 
   const Extension* extension = GetExtensionById(update.extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
   if (!user_gesture())
     return RespondNow(Error(kRequiresUserGestureError));
@@ skipping 25 matching lines @@
         extension->id(),
         *update.show_action_button);
   }
 
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateReloadFunction::~DeveloperPrivateReloadFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
-  scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
+  std::unique_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = GetExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   bool fail_quietly = params->options &&
                       params->options->fail_quietly &&
                       *params->options->fail_quietly;
 
   ExtensionService* service = GetExtensionService(browser_context());
   if (fail_quietly)
     service->ReloadExtensionWithQuietFailure(params->extension_id);
   else
     service->ReloadExtension(params->extension_id);
 
   // TODO(devlin): We shouldn't return until the extension has finished trying
   // to reload (and then we could also return the error).
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateShowPermissionsDialogFunction::
 DeveloperPrivateShowPermissionsDialogFunction() {}
 
 DeveloperPrivateShowPermissionsDialogFunction::
 ~DeveloperPrivateShowPermissionsDialogFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateShowPermissionsDialogFunction::Run() {
-  scoped_ptr<developer::ShowPermissionsDialog::Params> params(
+  std::unique_ptr<developer::ShowPermissionsDialog::Params> params(
       developer::ShowPermissionsDialog::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const Extension* target_extension = GetExtensionById(params->extension_id);
   if (!target_extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents)
     return RespondNow(Error(kCouldNotFindWebContentsError));
 
   ShowPermissionsDialogHelper::Show(
       browser_context(),
       web_contents,
       target_extension,
       source_context_type() == Feature::WEBUI_CONTEXT,
       base::Bind(&DeveloperPrivateShowPermissionsDialogFunction::Finish, this));
   return RespondLater();
 }
 
 void DeveloperPrivateShowPermissionsDialogFunction::Finish() {
   Respond(NoArguments());
 }
 
 DeveloperPrivateLoadUnpackedFunction::DeveloperPrivateLoadUnpackedFunction()
     : fail_quietly_(false) {
 }
 
 ExtensionFunction::ResponseAction DeveloperPrivateLoadUnpackedFunction::Run() {
-  scoped_ptr<developer::LoadUnpacked::Params> params(
+  std::unique_ptr<developer::LoadUnpacked::Params> params(
       developer::LoadUnpacked::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (!ShowPicker(
            ui::SelectFileDialog::SELECT_FOLDER,
            l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY),
            ui::SelectFileDialog::FileTypeInfo(),
            0 /* file_type_index */)) {
     return RespondNow(Error(kCouldNotShowSelectFileDialogError));
   }
@@ skipping 82 matching lines @@
     response.override_flags = ExtensionCreator::kOverwriteCRX;
     response.status = developer::PACK_STATUS_WARNING;
   } else {
     response.status = developer::PACK_STATUS_ERROR;
   }
   Respond(OneArgument(response.ToValue()));
   Release();  // Balanced in Run().
 }
 
 ExtensionFunction::ResponseAction DeveloperPrivatePackDirectoryFunction::Run() {
-  scoped_ptr<PackDirectory::Params> params(
+  std::unique_ptr<PackDirectory::Params> params(
       PackDirectory::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   int flags = params->flags ? *params->flags : 0;
   item_path_str_ = params->path;
   if (params->private_key_path)
     key_path_str_ = *params->private_key_path;
 
   base::FilePath root_directory =
       base::FilePath::FromUTF8Unsafe(item_path_str_);
@@ skipping 259 matching lines @@
   }
 }
 
 DeveloperPrivateLoadDirectoryFunction::DeveloperPrivateLoadDirectoryFunction()
     : pending_copy_operations_count_(0), success_(true) {}
 
 DeveloperPrivateLoadDirectoryFunction::~DeveloperPrivateLoadDirectoryFunction()
     {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateChoosePathFunction::Run() {
-  scoped_ptr<developer::ChoosePath::Params> params(
+  std::unique_ptr<developer::ChoosePath::Params> params(
       developer::ChoosePath::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   ui::SelectFileDialog::Type type = ui::SelectFileDialog::SELECT_FOLDER;
   ui::SelectFileDialog::FileTypeInfo info;
 
   if (params->select_type == developer::SELECT_TYPE_FILE)
     type = ui::SelectFileDialog::SELECT_OPEN_FILE;
   base::string16 select_title;
 
@@ skipping 98 matching lines @@
 
   developer::RequestFileSourceResponse response;
   base::FilePath path_suffix =
       base::FilePath::FromUTF8Unsafe(properties.path_suffix);
   base::FilePath path = extension->path().Append(path_suffix);
   response.title = base::StringPrintf("%s: %s",
                                       extension->name().c_str(),
                                       path.BaseName().AsUTF8Unsafe().c_str());
   response.message = properties.message;
 
-  scoped_ptr<FileHighlighter> highlighter;
+  std::unique_ptr<FileHighlighter> highlighter;
   if (properties.path_suffix == kManifestFile) {
     highlighter.reset(new ManifestHighlighter(
         file_contents,
         *properties.manifest_key,
         properties.manifest_specific ?
             *properties.manifest_specific : std::string()));
   } else {
     highlighter.reset(new SourceHighlighter(
         file_contents,
         properties.line_number ? *properties.line_number : 0));
   }
 
   response.before_highlight = highlighter->GetBeforeFeature();
   response.highlight = highlighter->GetFeature();
   response.after_highlight = highlighter->GetAfterFeature();
 
   Respond(OneArgument(response.ToValue()));
 }
 
 DeveloperPrivateOpenDevToolsFunction::DeveloperPrivateOpenDevToolsFunction() {}
 DeveloperPrivateOpenDevToolsFunction::~DeveloperPrivateOpenDevToolsFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateOpenDevToolsFunction::Run() {
-  scoped_ptr<developer::OpenDevTools::Params> params(
+  std::unique_ptr<developer::OpenDevTools::Params> params(
       developer::OpenDevTools::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::OpenDevToolsProperties& properties = params->properties;
 
   if (properties.render_process_id == -1) {
     // This is a lazy background page.
     const Extension* extension = properties.extension_id ?
         GetEnabledExtensionById(*properties.extension_id) : nullptr;
     if (!extension)
       return RespondNow(Error(kNoSuchExtensionError));
@@ skipping 48 matching lines @@
   tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(web_contents),
                            false);  // Not through direct user gesture.
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateDeleteExtensionErrorsFunction::
 ~DeveloperPrivateDeleteExtensionErrorsFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateDeleteExtensionErrorsFunction::Run() {
-  scoped_ptr<developer::DeleteExtensionErrors::Params> params(
+  std::unique_ptr<developer::DeleteExtensionErrors::Params> params(
       developer::DeleteExtensionErrors::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::DeleteExtensionErrorsProperties& properties =
       params->properties;
 
   ErrorConsole* error_console = ErrorConsole::Get(GetProfile());
   int type = -1;
   if (properties.type != developer::ERROR_TYPE_NONE) {
     type = properties.type == developer::ERROR_TYPE_MANIFEST ?
         ExtensionError::MANIFEST_ERROR : ExtensionError::RUNTIME_ERROR;
   }
   std::set<int> error_ids;
   if (properties.error_ids) {
     error_ids.insert(properties.error_ids->begin(),
                      properties.error_ids->end());
   }
   error_console->RemoveErrors(ErrorMap::Filter(
       properties.extension_id, type, error_ids, false));
 
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateRepairExtensionFunction::
 ~DeveloperPrivateRepairExtensionFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateRepairExtensionFunction::Run() {
-  scoped_ptr<developer::RepairExtension::Params> params(
+  std::unique_ptr<developer::RepairExtension::Params> params(
       developer::RepairExtension::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const Extension* extension = GetExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents)
     return RespondNow(Error(kCouldNotFindWebContentsError));
 
@@ skipping 10 matching lines @@
 void DeveloperPrivateRepairExtensionFunction::OnReinstallComplete(
     bool success,
     const std::string& error,
     webstore_install::Result result) {
   Respond(success ? NoArguments() : Error(error));
 }
 
 DeveloperPrivateShowOptionsFunction::~DeveloperPrivateShowOptionsFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateShowOptionsFunction::Run() {
-  scoped_ptr<developer::ShowOptions::Params> params(
+  std::unique_ptr<developer::ShowOptions::Params> params(
       developer::ShowOptions::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const Extension* extension = GetEnabledExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   if (OptionsPageInfo::GetOptionsPage(extension).is_empty())
     return RespondNow(Error(kNoOptionsPageForExtensionError));
 
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents)
     return RespondNow(Error(kCouldNotFindWebContentsError));
 
   ExtensionTabUtil::OpenOptionsPage(
       extension,
       chrome::FindBrowserWithWebContents(web_contents));
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateShowPathFunction::~DeveloperPrivateShowPathFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateShowPathFunction::Run() {
-  scoped_ptr<developer::ShowPath::Params> params(
+  std::unique_ptr<developer::ShowPath::Params> params(
       developer::ShowPath::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const Extension* extension = GetExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   // We explicitly show manifest.json in order to work around an issue in OSX
   // where opening the directory doesn't focus the Finder.
   platform_util::ShowItemInFolder(GetProfile(),
                                   extension->path().Append(kManifestFilename));
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateSetShortcutHandlingSuspendedFunction::
 ~DeveloperPrivateSetShortcutHandlingSuspendedFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateSetShortcutHandlingSuspendedFunction::Run() {
-  scoped_ptr<developer::SetShortcutHandlingSuspended::Params> params(
+  std::unique_ptr<developer::SetShortcutHandlingSuspended::Params> params(
       developer::SetShortcutHandlingSuspended::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   ExtensionCommandsGlobalRegistry::Get(GetProfile())->
       SetShortcutHandlingSuspended(params->is_suspended);
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateUpdateExtensionCommandFunction::
 ~DeveloperPrivateUpdateExtensionCommandFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateUpdateExtensionCommandFunction::Run() {
-  scoped_ptr<developer::UpdateExtensionCommand::Params> params(
+  std::unique_ptr<developer::UpdateExtensionCommand::Params> params(
       developer::UpdateExtensionCommand::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::ExtensionCommandUpdate& update = params->update;
 
   CommandService* command_service = CommandService::Get(GetProfile());
 
   if (update.scope != developer::COMMAND_SCOPE_NONE) {
     command_service->SetScope(update.extension_id, update.command_name,
                               update.scope == developer::COMMAND_SCOPE_GLOBAL);
   }
 
   if (update.keybinding) {
     command_service->UpdateKeybindingPrefs(
         update.extension_id, update.command_name, *update.keybinding);
   }
 
   return RespondNow(NoArguments());
 }
 
 
 }  // namespace api
 
 }  // namespace extensions