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

chrome/browser/extensions/crx_installer_browsertest.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/crx_installer.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/extensions/browser_action_test_util.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_prompt_show_params.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
@@ skipping 66 matching lines @@
   const std::string& extension_id() { return extension_id_; }
   bool confirmation_requested() const { return confirmation_requested_; }
   const base::string16& error() const { return error_; }
 
   void set_extension_id(const std::string& id) { extension_id_ = id; }
   void set_confirmation_requested(bool requested) {
     confirmation_requested_ = requested;
   }
   void set_error(const base::string16& error) { error_ = error; }
 
-  scoped_ptr<ExtensionInstallPrompt> CreatePrompt();
+  std::unique_ptr<ExtensionInstallPrompt> CreatePrompt();
 
  private:
 
   // Data used to create a prompt.
   content::WebContents* web_contents_;
 
   // Data reported back to us by the prompt we created.
   bool confirmation_requested_;
   std::string extension_id_;
   base::string16 error_;
 
-  scoped_ptr<ScopedTestDialogAutoConfirm> auto_confirm;
+  std::unique_ptr<ScopedTestDialogAutoConfirm> auto_confirm;
 
   DISALLOW_COPY_AND_ASSIGN(MockPromptProxy);
 };
 
 SkBitmap CreateSquareBitmap(int size) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(size, size);
   bitmap.eraseColor(SK_ColorRED);
   return bitmap;
 }
@@ skipping 47 matching lines @@
 
 MockPromptProxy::MockPromptProxy(content::WebContents* web_contents)
     : web_contents_(web_contents),
       confirmation_requested_(false),
       auto_confirm(new ScopedTestDialogAutoConfirm(
           ScopedTestDialogAutoConfirm::ACCEPT)) {
 }
 
 MockPromptProxy::~MockPromptProxy() {}
 
-scoped_ptr<ExtensionInstallPrompt> MockPromptProxy::CreatePrompt() {
-  return scoped_ptr<MockInstallPrompt>(
+std::unique_ptr<ExtensionInstallPrompt> MockPromptProxy::CreatePrompt() {
+  return std::unique_ptr<MockInstallPrompt>(
       new MockInstallPrompt(web_contents_, this));
 }
 
-
-scoped_ptr<MockPromptProxy> CreateMockPromptProxyForBrowser(
+std::unique_ptr<MockPromptProxy> CreateMockPromptProxyForBrowser(
     Browser* browser) {
-  return make_scoped_ptr(new MockPromptProxy(
-      browser->tab_strip_model()->GetActiveWebContents()));
+  return base::WrapUnique(
+      new MockPromptProxy(browser->tab_strip_model()->GetActiveWebContents()));
 }
 
 class ManagementPolicyMock : public extensions::ManagementPolicy::Provider {
  public:
   ManagementPolicyMock() {}
 
   std::string GetDebugPolicyProviderName() const override {
     return "ManagementPolicyMock";
   }
 
   bool UserMayLoad(const Extension* extension,
                    base::string16* error) const override {
     *error = base::UTF8ToUTF16("Dummy error message");
     return false;
   }
 };
 
 }  // namespace
 
 class ExtensionCrxInstallerTest : public ExtensionBrowserTest {
  protected:
-  scoped_ptr<WebstoreInstaller::Approval> GetApproval(
+  std::unique_ptr<WebstoreInstaller::Approval> GetApproval(
       const char* manifest_dir,
       const std::string& id,
       bool strict_manifest_checks) {
-    scoped_ptr<WebstoreInstaller::Approval> result;
+    std::unique_ptr<WebstoreInstaller::Approval> result;
 
     base::FilePath ext_path = test_data_dir_.AppendASCII(manifest_dir);
     std::string error;
-    scoped_ptr<base::DictionaryValue> parsed_manifest(
+    std::unique_ptr<base::DictionaryValue> parsed_manifest(
         file_util::LoadManifest(ext_path, &error));
     if (!parsed_manifest.get() || !error.empty())
       return result;
 
     return WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
         browser()->profile(), id, std::move(parsed_manifest),
         strict_manifest_checks);
   }
 
   void RunCrxInstaller(const WebstoreInstaller::Approval* approval,
-                       scoped_ptr<ExtensionInstallPrompt> prompt,
+                       std::unique_ptr<ExtensionInstallPrompt> prompt,
                        const base::FilePath& crx_path) {
     ExtensionService* service = extensions::ExtensionSystem::Get(
         browser()->profile())->extension_service();
     scoped_refptr<CrxInstaller> installer(
         CrxInstaller::Create(service, std::move(prompt), approval));
     installer->set_allow_silent_install(true);
     installer->set_is_gallery_install(true);
     installer->InstallCrx(crx_path);
     content::RunMessageLoop();
   }
 
   // Installs a crx from |crx_relpath| (a path relative to the extension test
   // data dir) with expected id |id|.
   void InstallWithPrompt(const char* ext_relpath,
                          const std::string& id,
                          MockPromptProxy* mock_install_prompt) {
     base::FilePath ext_path = test_data_dir_.AppendASCII(ext_relpath);
 
-    scoped_ptr<WebstoreInstaller::Approval> approval;
+    std::unique_ptr<WebstoreInstaller::Approval> approval;
     if (!id.empty())
       approval = GetApproval(ext_relpath, id, true);
 
     base::FilePath crx_path = PackExtension(ext_path);
     EXPECT_FALSE(crx_path.empty());
     RunCrxInstaller(approval.get(), mock_install_prompt->CreatePrompt(),
                     crx_path);
 
     EXPECT_TRUE(mock_install_prompt->did_succeed());
   }
 
   // Installs an extension and checks that it has scopes granted IFF
   // |record_oauth2_grant| is true.
   void CheckHasEmptyScopesAfterInstall(const std::string& ext_relpath,
                                        bool record_oauth2_grant) {
-    scoped_ptr<MockPromptProxy> mock_prompt =
+    std::unique_ptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
     InstallWithPrompt("browsertest/scopes", std::string(), mock_prompt.get());
 
-    scoped_ptr<const PermissionSet> permissions =
+    std::unique_ptr<const PermissionSet> permissions =
         ExtensionPrefs::Get(browser()->profile())
             ->GetGrantedPermissions(mock_prompt->extension_id());
     ASSERT_TRUE(permissions.get());
   }
 
   void InstallWebAppAndVerifyNoErrors() {
     ExtensionService* service =
         extensions::ExtensionSystem::Get(browser()->profile())
             ->extension_service();
     scoped_refptr<CrxInstaller> crx_installer(
@@ skipping 70 matching lines @@
 
   const int kNumDownloadsExpected = 1;
 
   LOG(ERROR) << "PackAndInstallExtension: Packing extension";
   base::FilePath crx_path = PackExtension(
       test_data_dir_.AppendASCII("common/background_page"));
   ASSERT_FALSE(crx_path.empty());
   std::string crx_path_string(crx_path.value().begin(), crx_path.value().end());
   GURL url = GURL(std::string("file:///").append(crx_path_string));
 
-  scoped_ptr<MockPromptProxy> mock_prompt =
+  std::unique_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
   download_crx_util::SetMockInstallPromptForTesting(
       mock_prompt->CreatePrompt());
 
   LOG(ERROR) << "PackAndInstallExtension: Getting download manager";
   content::DownloadManager* download_manager =
       content::BrowserContext::GetDownloadManager(browser()->profile());
 
   LOG(ERROR) << "PackAndInstallExtension: Setting observer";
-  scoped_ptr<content::DownloadTestObserver> observer(
+  std::unique_ptr<content::DownloadTestObserver> observer(
       new content::DownloadTestObserverTerminal(
           download_manager, kNumDownloadsExpected,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   LOG(ERROR) << "PackAndInstallExtension: Navigating to URL";
   ui_test_utils::NavigateToURLWithDisposition(browser(), url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
 
   EXPECT_TRUE(WaitForCrxInstallerDone());
   LOG(ERROR) << "PackAndInstallExtension: Extension install";
   EXPECT_TRUE(mock_prompt->confirmation_requested());
@@ skipping 18 matching lines @@
   EXPECT_NO_FATAL_FAILURE(CheckHasEmptyScopesAfterInstall("browsertest/scopes",
                                                           false));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, AllowOffStore) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
   const bool kTestData[] = {false, true};
 
   for (size_t i = 0; i < arraysize(kTestData); ++i) {
-    scoped_ptr<MockPromptProxy> mock_prompt =
+    std::unique_ptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
     scoped_refptr<CrxInstaller> crx_installer(
         CrxInstaller::Create(service, mock_prompt->CreatePrompt()));
     crx_installer->set_install_cause(
         extension_misc::INSTALL_CAUSE_USER_DOWNLOAD);
 
     if (kTestData[i]) {
       crx_installer->set_off_store_install_allow_reason(
           CrxInstaller::OffStoreInstallAllowedInTest);
@@ skipping 103 matching lines @@
 
   blacklist_db->SetUnsafe("gllekhaobjnhgeagipipnkpmmmpchacm");
 
   base::FilePath crx_path = test_data_dir_.AppendASCII("theme_hidpi_crx")
                                           .AppendASCII("theme_hidpi.crx");
   EXPECT_FALSE(InstallExtension(crx_path, 0));
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, NonStrictManifestCheck) {
-  scoped_ptr<MockPromptProxy> mock_prompt =
+  std::unique_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
 
   // We want to simulate the case where the webstore sends a more recent
   // version of the manifest, but the downloaded .crx file is old since
   // the newly published version hasn't fully propagated to all the download
   // servers yet. So load the v2 manifest, but then install the v1 crx file.
   std::string id = "lhnaeclnpobnlbjbgogdanmhadigfnjp";
-  scoped_ptr<WebstoreInstaller::Approval> approval =
+  std::unique_ptr<WebstoreInstaller::Approval> approval =
       GetApproval("crx_installer/v2_no_permission_change/", id, false);
 
   RunCrxInstaller(approval.get(), mock_prompt->CreatePrompt(),
                   test_data_dir_.AppendASCII("crx_installer/v1.crx"));
 
   EXPECT_TRUE(mock_prompt->did_succeed());
 }
 
 #if defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, KioskOnlyTest) {
@@ skipping 137 matching lines @@
     EXPECT_TRUE(WaitForCrxInstallerDone());
     const Extension* extension = installer->extension();
     ASSERT_TRUE(extension);
     ASSERT_EQ(extension_id, extension->id());
     EXPECT_TRUE(ExtensionPrefs::Get(profile())->AllowFileAccess(extension_id));
     EXPECT_TRUE(extension->creation_flags() & Extension::ALLOW_FILE_ACCESS);
   }
 }
 
 }  // namespace extensions