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

chrome/browser/extensions/webstore_inline_installer_browsertest.cc

 // Copyright 2013 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/webstore_inline_installer.h"
+
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.h"
-#include "chrome/browser/extensions/webstore_inline_installer.h"
 #include "chrome/browser/extensions/webstore_inline_installer_factory.h"
 #include "chrome/browser/extensions/webstore_installer_test.h"
 #include "chrome/browser/extensions/webstore_standalone_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 42 matching lines @@
   explicit ProgrammableInstallPrompt(WebContents* contents)
       : ExtensionInstallPrompt(contents)
   {}
 
   ~ProgrammableInstallPrompt() override { g_done_callback = nullptr; }
 
   void ShowDialog(
       const ExtensionInstallPrompt::DoneCallback& done_callback,
       const Extension* extension,
       const SkBitmap* icon,
-      scoped_ptr<ExtensionInstallPrompt::Prompt> prompt,
-      scoped_ptr<const extensions::PermissionSet> custom_permissions,
+      std::unique_ptr<ExtensionInstallPrompt::Prompt> prompt,
+      std::unique_ptr<const extensions::PermissionSet> custom_permissions,
       const ShowDialogCallback& show_dialog_callback) override {
     done_callback_ = done_callback;
     g_done_callback = &done_callback_;
   }
 
   static bool Ready() { return g_done_callback != nullptr; }
 
   static void Accept() {
     g_done_callback->Run(ExtensionInstallPrompt::Result::ACCEPTED);
   }
@@ skipping 25 matching lines @@
       : WebstoreInlineInstaller(
             contents,
             host,
             kTestExtensionId,
             requestor_url,
             base::Bind(&WebstoreInlineInstallerForTest::InstallCallback,
                        base::Unretained(this))),
         install_result_target_(nullptr),
         programmable_prompt_(nullptr) {}
 
-  scoped_ptr<ExtensionInstallPrompt> CreateInstallUI() override {
+  std::unique_ptr<ExtensionInstallPrompt> CreateInstallUI() override {
     programmable_prompt_ = new ProgrammableInstallPrompt(web_contents());
-    return make_scoped_ptr(programmable_prompt_);
+    return base::WrapUnique(programmable_prompt_);
   }
 
   // Added here to make it public so that test cases can call it below.
   bool CheckRequestorAlive() const override {
     return WebstoreInlineInstaller::CheckRequestorAlive();
   }
 
   // Tests that care about the actual arguments to the install callback can use
   // this to receive a copy in |install_result_target|.
   void set_install_result_target(
-      scoped_ptr<InstallResult>* install_result_target) {
+      std::unique_ptr<InstallResult>* install_result_target) {
     install_result_target_ = install_result_target;
   }
 
  private:
   ~WebstoreInlineInstallerForTest() override {}
 
   friend class base::RefCountedThreadSafe<WebstoreStandaloneInstaller>;
 
   void InstallCallback(bool success,
                        const std::string& error,
                        webstore_install::Result result) {
     if (install_result_target_) {
       install_result_target_->reset(new InstallResult);
       (*install_result_target_)->success = success;
       (*install_result_target_)->error = error;
       (*install_result_target_)->result = result;
     }
   }
 
   // This can be set by tests that want to get the actual install callback
   // arguments.
-  scoped_ptr<InstallResult>* install_result_target_;
+  std::unique_ptr<InstallResult>* install_result_target_;
 
   ProgrammableInstallPrompt* programmable_prompt_;
 };
 
 class WebstoreInlineInstallerForTestFactory :
     public WebstoreInlineInstallerFactory {
  public:
   WebstoreInlineInstallerForTestFactory() : last_installer_(nullptr) {}
   ~WebstoreInlineInstallerForTestFactory() override {}
 
@@ skipping 51 matching lines @@
   ASSERT_NE(factory->last_installer(), nullptr);
   EXPECT_NE(factory->last_installer()->web_contents(), nullptr);
   EXPECT_FALSE(factory->last_installer()->CheckRequestorAlive());
 
   // Right now the way we handle navigations away from the frame that began the
   // inline install is to just declare the requestor to be dead, but not to
   // kill the prompt (that would be a better UX, but more complicated to
   // implement). If we ever do change things to kill the prompt in this case,
   // the following code can be removed (it verifies that clicking ok on the
   // dialog does not result in an install).
-  scoped_ptr<InstallResult> install_result;
+  std::unique_ptr<InstallResult> install_result;
   factory->last_installer()->set_install_result_target(&install_result);
   ASSERT_TRUE(ProgrammableInstallPrompt::Ready());
   ProgrammableInstallPrompt::Accept();
   ASSERT_NE(install_result.get(), nullptr);
   EXPECT_EQ(install_result->success, false);
   EXPECT_EQ(install_result->result, webstore_install::ABORTED);
 }
 
 // Flaky: https://crbug.com/537526.
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerTest,
@@ skipping 90 matching lines @@
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerListenerTest,
                        DownloadProgressListenerTest) {
   RunTest("download_progress_listener.html");
 }
 
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerListenerTest, BothListenersTest) {
   RunTest("both_listeners.html");
 }
 
 }  // namespace extensions