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

chrome/browser/extensions/api/management/chrome_management_api_delegate.cc

 // Copyright 2014 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/management/chrome_management_api_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/bookmark_app_helper.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
 #include "chrome/browser/extensions/chrome_requirements_checker.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_dialogs.h"
@@ skipping 34 matching lines @@
         callback_(callback),
         weak_factory_(this) {
     ExtensionInstallPrompt::PromptType type =
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             browser_context, extension);
     install_prompt_->ShowDialog(
         base::Bind(&ManagementSetEnabledFunctionInstallPromptDelegate::
                        OnInstallPromptDone,
                    weak_factory_.GetWeakPtr()),
         extension, nullptr,
-        make_scoped_ptr(new ExtensionInstallPrompt::Prompt(type)),
+        base::WrapUnique(new ExtensionInstallPrompt::Prompt(type)),
         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
   ~ManagementSetEnabledFunctionInstallPromptDelegate() override {}
 
  private:
   void OnInstallPromptDone(ExtensionInstallPrompt::Result result) {
     base::ResetAndReturn(&callback_).Run(
         result == ExtensionInstallPrompt::Result::ACCEPTED);
   }
 
   // Used for prompting to re-enable items with permissions escalation updates.
-  scoped_ptr<ExtensionInstallPrompt> install_prompt_;
+  std::unique_ptr<ExtensionInstallPrompt> install_prompt_;
 
   base::Callback<void(bool)> callback_;
 
   base::WeakPtrFactory<ManagementSetEnabledFunctionInstallPromptDelegate>
       weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ManagementSetEnabledFunctionInstallPromptDelegate);
 };
 
 class ManagementUninstallFunctionUninstallDialogDelegate
@@ skipping 26 matching lines @@
   ~ManagementUninstallFunctionUninstallDialogDelegate() override {}
 
   // ExtensionUninstallDialog::Delegate implementation.
   void OnExtensionUninstallDialogClosed(bool did_start_uninstall,
                                         const base::string16& error) override {
     function_->OnExtensionUninstallDialogClosed(did_start_uninstall, error);
   }
 
  private:
   extensions::ManagementUninstallFunctionBase* function_;
-  scoped_ptr<extensions::ExtensionUninstallDialog> extension_uninstall_dialog_;
+  std::unique_ptr<extensions::ExtensionUninstallDialog>
+      extension_uninstall_dialog_;
 
   DISALLOW_COPY_AND_ASSIGN(ManagementUninstallFunctionUninstallDialogDelegate);
 };
 
 class ChromeAppForLinkDelegate : public extensions::AppForLinkDelegate {
  public:
   ChromeAppForLinkDelegate() {}
   ~ChromeAppForLinkDelegate() override {}
 
   void OnFaviconForApp(
@@ skipping 15 matching lines @@
     }
 
     bookmark_app_helper_.reset(new extensions::BookmarkAppHelper(
         Profile::FromBrowserContext(context), web_app, NULL));
     bookmark_app_helper_->Create(
         base::Bind(&extensions::ManagementGenerateAppForLinkFunction::
                        FinishCreateBookmarkApp,
                    function));
   }
 
-  scoped_ptr<extensions::BookmarkAppHelper> bookmark_app_helper_;
+  std::unique_ptr<extensions::BookmarkAppHelper> bookmark_app_helper_;
 
   // Used for favicon loading tasks.
   base::CancelableTaskTracker cancelable_task_tracker_;
 };
 
 }  // namespace
 
 ChromeManagementAPIDelegate::ChromeManagementAPIDelegate() {
 }
 
@@ skipping 37 matching lines @@
       base::Bind(
           &extensions::ManagementGetPermissionWarningsByManifestFunction::
               OnParseSuccess,
           function),
       base::Bind(
           &extensions::ManagementGetPermissionWarningsByManifestFunction::
               OnParseFailure,
           function));
 }
 
-scoped_ptr<extensions::InstallPromptDelegate>
+std::unique_ptr<extensions::InstallPromptDelegate>
 ChromeManagementAPIDelegate::SetEnabledFunctionDelegate(
     content::WebContents* web_contents,
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     const base::Callback<void(bool)>& callback) const {
-  return scoped_ptr<ManagementSetEnabledFunctionInstallPromptDelegate>(
+  return std::unique_ptr<ManagementSetEnabledFunctionInstallPromptDelegate>(
       new ManagementSetEnabledFunctionInstallPromptDelegate(
           web_contents, browser_context, extension, callback));
 }
 
-scoped_ptr<extensions::RequirementsChecker>
+std::unique_ptr<extensions::RequirementsChecker>
 ChromeManagementAPIDelegate::CreateRequirementsChecker() const {
-  return make_scoped_ptr(new extensions::ChromeRequirementsChecker());
+  return base::WrapUnique(new extensions::ChromeRequirementsChecker());
 }
 
-scoped_ptr<extensions::UninstallDialogDelegate>
+std::unique_ptr<extensions::UninstallDialogDelegate>
 ChromeManagementAPIDelegate::UninstallFunctionDelegate(
     extensions::ManagementUninstallFunctionBase* function,
     const extensions::Extension* target_extension,
     bool show_programmatic_uninstall_ui) const {
-  return scoped_ptr<extensions::UninstallDialogDelegate>(
+  return std::unique_ptr<extensions::UninstallDialogDelegate>(
       new ManagementUninstallFunctionUninstallDialogDelegate(
           function, target_extension, show_programmatic_uninstall_ui));
 }
 
 bool ChromeManagementAPIDelegate::CreateAppShortcutFunctionDelegate(
     extensions::ManagementCreateAppShortcutFunction* function,
     const extensions::Extension* extension) const {
   Browser* browser = chrome::FindBrowserWithProfile(
       Profile::FromBrowserContext(function->browser_context()));
   if (!browser) {
     // Shouldn't happen if we have user gesture.
     function->SetError(
         extension_management_api_constants::kNoBrowserToCreateShortcut);
     return false;
   }
 
   chrome::ShowCreateChromeAppShortcutsDialog(
       browser->window()->GetNativeWindow(), browser->profile(), extension,
       base::Bind(&extensions::ManagementCreateAppShortcutFunction::
                      OnCloseShortcutPrompt,
                  function));
 
   return true;
 }
 
-scoped_ptr<extensions::AppForLinkDelegate>
+std::unique_ptr<extensions::AppForLinkDelegate>
 ChromeManagementAPIDelegate::GenerateAppForLinkFunctionDelegate(
     extensions::ManagementGenerateAppForLinkFunction* function,
     content::BrowserContext* context,
     const std::string& title,
     const GURL& launch_url) const {
   favicon::FaviconService* favicon_service =
       FaviconServiceFactory::GetForProfile(Profile::FromBrowserContext(context),
                                            ServiceAccessType::EXPLICIT_ACCESS);
   DCHECK(favicon_service);
 
   ChromeAppForLinkDelegate* delegate = new ChromeAppForLinkDelegate;
 
   favicon_service->GetFaviconImageForPageURL(
       launch_url,
       base::Bind(&ChromeAppForLinkDelegate::OnFaviconForApp,
                  base::Unretained(delegate), base::RetainedRef(function),
                  context, title, launch_url),
       &delegate->cancelable_task_tracker_);
 
-  return scoped_ptr<extensions::AppForLinkDelegate>(delegate);
+  return std::unique_ptr<extensions::AppForLinkDelegate>(delegate);
 }
 
 bool ChromeManagementAPIDelegate::CanHostedAppsOpenInWindows() const {
   return extensions::util::CanHostedAppsOpenInWindows();
 }
 
 bool ChromeManagementAPIDelegate::IsNewBookmarkAppsEnabled() const {
   return extensions::util::IsNewBookmarkAppsEnabled();
 }
 
@@ skipping 35 matching lines @@
 
 GURL ChromeManagementAPIDelegate::GetIconURL(
     const extensions::Extension* extension,
     int icon_size,
     ExtensionIconSet::MatchType match,
     bool grayscale,
     bool* exists) const {
   return extensions::ExtensionIconSource::GetIconURL(extension, icon_size,
                                                      match, grayscale, exists);
 }