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

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 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/extension_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/version.h"
@@ skipping 237 matching lines @@
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // ExternalProvider implementation:
   void VisitRegisteredExtension() override {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
-      scoped_ptr<Version> version(new Version(i->second.first));
+      std::unique_ptr<Version> version(new Version(i->second.first));
 
-      scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+      std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
           i->first, std::move(version), i->second.second, location_,
           Extension::NO_FLAGS, false, false));
       visitor_->OnExternalExtensionFileFound(*info);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
   bool HasExtension(const std::string& id) const override {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   bool GetExtensionDetails(const std::string& id,
                            Manifest::Location* location,
-                           scoped_ptr<Version>* version) const override {
+                           std::unique_ptr<Version>* version) const override {
     DataMap::const_iterator it = extension_map_.find(id);
     if (it == extension_map_.end())
       return false;
 
     if (version)
       version->reset(new Version(it->second.first));
 
     if (location)
       *location = location_;
 
@@ skipping 87 matching lines @@
 
     EXPECT_TRUE(info.path.IsAbsolute());
     if (!fake_base_path_.empty())
       EXPECT_TRUE(fake_base_path_.IsParent(info.path));
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(info.extension_id));
 
       // Ask provider if the extension we got back is registered.
       Manifest::Location location = Manifest::INVALID_LOCATION;
-      scoped_ptr<Version> v1;
+      std::unique_ptr<Version> v1;
       base::FilePath crx_path;
 
       EXPECT_TRUE(provider_->GetExtensionDetails(info.extension_id, NULL, &v1));
       EXPECT_STREQ(info.version->GetString().c_str(), v1->GetString().c_str());
 
-      scoped_ptr<Version> v2;
+      std::unique_ptr<Version> v2;
       EXPECT_TRUE(
           provider_->GetExtensionDetails(info.extension_id, &location, &v2));
       EXPECT_STREQ(info.version->GetString().c_str(), v1->GetString().c_str());
       EXPECT_STREQ(info.version->GetString().c_str(), v2->GetString().c_str());
       EXPECT_EQ(crx_location_, location);
 
       // Remove it so we won't count it ever again.
       prefs_->Remove(info.extension_id, NULL);
     }
     return true;
   }
 
   bool OnExternalExtensionUpdateUrlFound(
       const ExternalInstallInfoUpdateUrl& info,
       bool is_initial_load) override {
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(info.extension_id, &pref))
         << L"Got back ID (" << info.extension_id.c_str()
         << ") we weren't expecting";
     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, info.download_location);
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(info.extension_id));
 
       // External extensions with update URLs do not have versions.
-      scoped_ptr<Version> v1;
+      std::unique_ptr<Version> v1;
       Manifest::Location location1 = Manifest::INVALID_LOCATION;
       EXPECT_TRUE(
           provider_->GetExtensionDetails(info.extension_id, &location1, &v1));
       EXPECT_FALSE(v1.get());
       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 
       std::string parsed_install_parameter;
       pref->GetString("install_parameter", &parsed_install_parameter);
       EXPECT_EQ(parsed_install_parameter, info.install_parameter);
 
@@ skipping 14 matching lines @@
 
   void OnExternalProviderReady(
       const extensions::ExternalProviderInterface* provider) override {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
   }
 
   Profile* profile() { return profile_.get(); }
 
  protected:
-  scoped_ptr<extensions::ExternalProviderImpl> provider_;
+  std::unique_ptr<extensions::ExternalProviderImpl> provider_;
 
-  scoped_ptr<base::DictionaryValue> GetDictionaryFromJSON(
+  std::unique_ptr<base::DictionaryValue> GetDictionaryFromJSON(
       const std::string& json_data) {
     // We also parse the file into a dictionary to compare what we get back
     // from the provider.
     JSONStringValueDeserializer deserializer(json_data);
-    scoped_ptr<base::Value> json_value = deserializer.Deserialize(NULL, NULL);
+    std::unique_ptr<base::Value> json_value =
+        deserializer.Deserialize(NULL, NULL);
 
     if (!json_value || !json_value->IsType(base::Value::TYPE_DICTIONARY)) {
       ADD_FAILURE() << "Unable to deserialize json data";
-      return scoped_ptr<base::DictionaryValue>();
+      return std::unique_ptr<base::DictionaryValue>();
     } else {
       return base::DictionaryValue::From(std::move(json_value));
     }
   }
 
  private:
   int ids_found_;
   base::FilePath fake_base_path_;
   int expected_creation_flags_;
   Manifest::Location crx_location_;
-  scoped_ptr<base::DictionaryValue> prefs_;
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<base::DictionaryValue> prefs_;
+  std::unique_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 // Mock provider that can simulate incremental update like
 // ExternalRegistryLoader.
 class MockUpdateProviderVisitor : public MockProviderVisitor {
  public:
   // The provider will return |fake_base_path| from
   // GetBaseCrxFilePath().  User can test the behavior with
   // and without an empty path using this parameter.
   explicit MockUpdateProviderVisitor(base::FilePath fake_base_path)
       : MockProviderVisitor(fake_base_path) {}
 
   void VisitDueToUpdate(const std::string& json_data) {
     update_url_extension_ids_.clear();
     file_extension_ids_.clear();
     removed_extension_ids_.clear();
 
-    scoped_ptr<base::DictionaryValue> new_prefs =
+    std::unique_ptr<base::DictionaryValue> new_prefs =
         GetDictionaryFromJSON(json_data);
     if (!new_prefs)
       return;
     provider_->UpdatePrefs(new_prefs.release());
   }
 
   void OnExternalProviderUpdateComplete(
       const ExternalProviderInterface* provider,
       const ScopedVector<ExternalInstallInfoUpdateUrl>& update_url_extensions,
       const ScopedVector<ExternalInstallInfoFile>& file_extensions,
@@ skipping 92 matching lines @@
   // set for extension |id|.
   void GrantAllOptionalPermissions(const std::string& id) {
     const Extension* extension = service()->GetInstalledExtension(id);
     const PermissionSet& all_optional_permissions =
         extensions::PermissionsParser::GetOptionalPermissions(extension);
     extensions::PermissionsUpdater perms_updater(profile());
     perms_updater.AddPermissions(extension, all_optional_permissions);
   }
 
   testing::AssertionResult IsBlocked(const std::string& id) {
-    scoped_ptr<extensions::ExtensionSet> all_unblocked_extensions =
+    std::unique_ptr<extensions::ExtensionSet> all_unblocked_extensions =
         registry()->GenerateInstalledExtensionsSet(
             ExtensionRegistry::EVERYTHING & ~ExtensionRegistry::BLOCKED);
     if (all_unblocked_extensions.get()->Contains(id))
       return testing::AssertionFailure() << id << " is still unblocked!";
     if (!registry()->blocked_extensions().Contains(id))
       return testing::AssertionFailure() << id << " is not blocked!";
     return testing::AssertionSuccess();
   }
 
   // Helper method to test that an extension moves through being blocked and
@@ skipping 492 matching lines @@
 // extension object.
 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
   const char kPrefFromBookmark[] = "from_bookmark";
 
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Register and install an external extension.
-  scoped_ptr<Version> version(new Version("1.0.0.0"));
+  std::unique_ptr<Version> version(new Version("1.0.0.0"));
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
       good_crx, std::move(version), path, Manifest::EXTERNAL_PREF,
       Extension::FROM_BOOKMARK, false /* mark_acknowledged */,
       false /* install_immediately */));
   if (service()->OnExternalExtensionFileFound(*info))
     observer.Wait();
 
   const Extension* extension = service()->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
   ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
@@ skipping 11 matching lines @@
 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Install an external extension.
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  scoped_ptr<Version> version(new Version("1.0.0.0"));
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+  std::unique_ptr<Version> version(new Version("1.0.0.0"));
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
       good_crx, std::move(version), path, Manifest::EXTERNAL_PREF,
       Extension::NO_FLAGS, false, false));
   if (service()->OnExternalExtensionFileFound(*info))
     observer.Wait();
 
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 
   // Uninstall it and check that its killbit gets set.
   UninstallExtension(good_crx, false);
   ValidateIntegerPref(good_crx, "state",
@@ skipping 56 matching lines @@
   MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
   service()->OnExternalProviderReady(&provider);
 }
 
 // Test that external extensions with incorrect IDs are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongId) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
-  scoped_ptr<Version> version(new Version("1.0.0.0"));
+  std::unique_ptr<Version> version(new Version("1.0.0.0"));
 
   const std::string wrong_id = all_zero;
   const std::string correct_id = good_crx;
   ASSERT_NE(correct_id, wrong_id);
 
   // Install an external extension with an ID from the external
   // source that is not equal to the ID in the extension manifest.
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
       wrong_id, std::move(version), path, Manifest::EXTERNAL_PREF,
       Extension::NO_FLAGS, false, false));
   service()->OnExternalExtensionFileFound(*info);
 
   observer.Wait();
   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
 
   // Try again with the right ID. Expect success.
   content::WindowedNotificationObserver observer2(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   info->extension_id = correct_id;
   if (service()->OnExternalExtensionFileFound(*info))
     observer2.Wait();
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 }
 
 // Test that external extensions with incorrect versions are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Install an external extension with a version from the external
   // source that is not equal to the version in the extension manifest.
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  scoped_ptr<Version> wrong_version(new Version("1.2.3.4"));
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+  std::unique_ptr<Version> wrong_version(new Version("1.2.3.4"));
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
       good_crx, std::move(wrong_version), path, Manifest::EXTERNAL_PREF,
       Extension::NO_FLAGS, false, false));
   service()->OnExternalExtensionFileFound(*info);
 
   observer.Wait();
   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
 
   // Try again with the right version. Expect success.
   service()->pending_extension_manager()->Remove(good_crx);
-  scoped_ptr<Version> correct_version(new Version("1.0.0.0"));
+  std::unique_ptr<Version> correct_version(new Version("1.0.0.0"));
   info->version = std::move(correct_version);
   content::WindowedNotificationObserver observer2(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(*info))
     observer2.Wait();
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 }
 
 // Install a user script (they get converted automatically to an extension)
@@ skipping 73 matching lines @@
   EXPECT_EQ(permissions_crx, extension->id());
 
   // Verify that the valid API permissions have been recognized.
   expected_api_perms.insert(APIPermission::kTab);
 
   AddPattern(&expected_host_perms, "http://*.google.com/*");
   AddPattern(&expected_host_perms, "https://*.google.com/*");
   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
   AddPattern(&expected_host_perms, "http://www.example.com/*");
 
-  scoped_ptr<const PermissionSet> known_perms =
+  std::unique_ptr<const PermissionSet> known_perms =
       prefs->GetGrantedPermissions(extension->id());
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
   EXPECT_EQ(expected_host_perms, known_perms->effective_hosts());
 }
 
 
 #if !defined(OS_CHROMEOS)
@@ skipping 21 matching lines @@
   const Extension* extension = PackAndInstallCRX(
       path, pem_path, INSTALL_NEW, Extension::WAS_INSTALLED_BY_DEFAULT);
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, registry()->enabled_extensions().size());
   EXPECT_EQ(permissions_crx, extension->id());
 
   // Verify that the valid API permissions have been recognized.
   expected_api_perms.insert(APIPermission::kTab);
 
-  scoped_ptr<const PermissionSet> known_perms =
+  std::unique_ptr<const PermissionSet> known_perms =
       prefs->GetGrantedPermissions(extension->id());
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
 }
 #endif
 
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
 // Tests that the granted permissions full_access bit gets set correctly when
 // an extension contains an NPAPI plugin.
 // Only run this on platforms that support NPAPI plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitPluginService();
 
   InitializeEmptyExtensionService();
 
   ASSERT_TRUE(base::PathExists(good1_path()));
   const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
-  scoped_ptr<const PermissionSet> permissions =
+  std::unique_ptr<const PermissionSet> permissions =
       prefs->GetGrantedPermissions(extension->id());
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // Full access implies full host access too...
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 }
 #endif
@@ skipping 42 matching lines @@
   ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
   ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
 
   // Now grant and re-enable the extension, making sure the prefs are updated.
   service()->GrantPermissionsAndEnableExtension(extension);
 
   ASSERT_FALSE(prefs->IsExtensionDisabled(extension_id));
   ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  scoped_ptr<const PermissionSet> current_perms =
+  std::unique_ptr<const PermissionSet> current_perms =
       prefs->GetGrantedPermissions(extension_id);
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
   ASSERT_EQ(expected_api_permissions, current_perms->apis());
   ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
 
   // Tests that the extension is disabled when a host permission is missing from
   // the extension's granted host permissions preference. (This simulates
   // updating the browser to a version which recognizes additional host
@@ skipping 46 matching lines @@
           .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
           .AppendASCII("1.0.0.0");
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath output_directory = temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
-  scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
+  std::unique_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
       privkey_path, ExtensionCreator::kNoRunFlags));
   ASSERT_TRUE(base::PathExists(crx_path));
   ASSERT_TRUE(base::PathExists(privkey_path));
 
   // Repeat the run with the pem file gone, and no special flags
   // Should refuse to overwrite the existing crx.
   base::DeleteFile(privkey_path, false);
   ASSERT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
       privkey_path, ExtensionCreator::kNoRunFlags));
@@ skipping 126 matching lines @@
                           /*recursive=*/true));
 
   base::ScopedTempDir output_temp_dir;
   ASSERT_TRUE(output_temp_dir.CreateUniqueTempDir());
   base::FilePath output_directory = output_temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
   // Pack the extension once to get a private key.
-  scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
+  std::unique_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
       privkey_path, ExtensionCreator::kNoRunFlags))
       << creator->error_message();
   ASSERT_TRUE(base::PathExists(crx_path));
   ASSERT_TRUE(base::PathExists(privkey_path));
 
   base::DeleteFile(crx_path, false);
   // Move the pem file into the extension.
   base::Move(privkey_path,
                   input_directory.AppendASCII("privkey.pem"));
@@ skipping 23 matching lines @@
   base::FilePath privkey_path(
       data_dir().AppendASCII("openssl_privkey_asn1.pem"));
   ASSERT_TRUE(base::PathExists(privkey_path));
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath output_directory = temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
 
-  scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
+  std::unique_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
       base::FilePath(), ExtensionCreator::kOverwriteCRX));
 
   InstallCRX(crx_path, INSTALL_NEW);
 }
 
 #if defined(THREAD_SANITIZER)
 // Flaky under Tsan. http://crbug.com/377702
 #define MAYBE_InstallTheme DISABLED_InstallTheme
 #else
@@ skipping 578 matching lines @@
 // Only run this on platforms that support NPAPI plugins.
 TEST_F(ExtensionServiceTest, LoadExtensionsWithPlugins) {
   base::FilePath extension_with_plugin_path = good1_path();
   base::FilePath extension_no_plugin_path = good2_path();
 
   InitPluginService();
   InitializeEmptyExtensionService();
   service()->set_show_extensions_prompts(true);
 
   // Start by canceling any install prompts.
-  scoped_ptr<extensions::ScopedTestDialogAutoConfirm> auto_confirm(
+  std::unique_ptr<extensions::ScopedTestDialogAutoConfirm> auto_confirm(
       new extensions::ScopedTestDialogAutoConfirm(
           extensions::ScopedTestDialogAutoConfirm::CANCEL));
 
   // The extension that has a plugin should not install.
   extensions::UnpackedInstaller::Create(service())
       ->Load(extension_with_plugin_path);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(0u, loaded_.size());
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
@@ skipping 20 matching lines @@
       ->Load(extension_with_plugin_path);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(2u, loaded_.size());
   EXPECT_EQ(2u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_TRUE(registry()->enabled_extensions().Contains(good1));
   EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
 
   // Make sure the granted permissions have been setup.
-  scoped_ptr<const PermissionSet> permissions =
+  std::unique_ptr<const PermissionSet> permissions =
       ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1);
   ASSERT_TRUE(permissions);
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // We should be able to reload the extension without getting another prompt.
   loaded_.clear();
   auto_confirm.reset();
@@ skipping 1369 matching lines @@
   // Verify all three extensions are installed and enabled.
   ASSERT_TRUE(registry->enabled_extensions().GetByID(ext1));
   ASSERT_TRUE(registry->enabled_extensions().GetByID(ext2));
   ASSERT_TRUE(registry->enabled_extensions().GetByID(ext2_forced));
 
   // Grant all optional permissions to each extension.
   GrantAllOptionalPermissions(ext1);
   GrantAllOptionalPermissions(ext2);
   GrantAllOptionalPermissions(ext2_forced);
 
-  scoped_ptr<const PermissionSet> active_permissions =
+  std::unique_ptr<const PermissionSet> active_permissions =
       ExtensionPrefs::Get(profile())->GetActivePermissions(ext1);
   EXPECT_TRUE(active_permissions->HasAPIPermission(
       extensions::APIPermission::kDownloads));
 
   // Set policy to block 'downloads' permission.
   {
     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
     pref.AddBlockedPermission("*", "downloads");
   }
 
@@ skipping 1452 matching lines @@
 
 TEST_F(ExtensionServiceTestSimple, Enabledness) {
   // Make sure the PluginService singleton is destroyed at the end of the test.
   base::ShadowingAtExitManager at_exit_manager;
 #if defined(ENABLE_PLUGINS)
   content::PluginService::GetInstance()->Init();
 #endif
 
   ExtensionErrorReporter::Init(false);  // no noisy errors
   ExtensionsReadyRecorder recorder;
-  scoped_ptr<TestingProfile> profile(new TestingProfile());
+  std::unique_ptr<TestingProfile> profile(new TestingProfile());
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService device_settings_service;
   chromeos::ScopedTestCrosSettings cros_settings;
-  scoped_ptr<chromeos::ScopedTestUserManager> user_manager(
+  std::unique_ptr<chromeos::ScopedTestUserManager> user_manager(
       new chromeos::ScopedTestUserManager);
 #endif
-  scoped_ptr<base::CommandLine> command_line;
+  std::unique_ptr<base::CommandLine> command_line;
   base::FilePath install_dir = profile->GetPath()
       .AppendASCII(extensions::kInstallDirectoryName);
 
   // By default, we are enabled.
   command_line.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
   ExtensionService* service = static_cast<extensions::TestExtensionSystem*>(
       ExtensionSystem::Get(profile.get()))->
       CreateExtensionService(
           command_line.get(),
           install_dir,
@@ skipping 138 matching lines @@
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Skip install when the location is the same.
-  scoped_ptr<GURL> good_update_url(new GURL(kGoodUpdateURL));
-  scoped_ptr<ExternalInstallInfoUpdateUrl> info(
+  std::unique_ptr<GURL> good_update_url(new GURL(kGoodUpdateURL));
+  std::unique_ptr<ExternalInstallInfoUpdateUrl> info(
       new ExternalInstallInfoUpdateUrl(
           kGoodId, std::string(), std::move(good_update_url),
           Manifest::INTERNAL, Extension::NO_FLAGS, false));
   EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(*info, true));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Install when the location has higher priority.
   info->download_location = Manifest::EXTERNAL_POLICY_DOWNLOAD;
   EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(*info, true));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
@@ skipping 41 matching lines @@
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
                                                  Manifest::INTERNAL));
   ASSERT_EQ(Manifest::EXTERNAL_PREF,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_PREF,
                                                  Manifest::INTERNAL));
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
-  scoped_ptr<Version> older_version_ptr(new Version(older_version));
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+  std::unique_ptr<Version> older_version_ptr(new Version(older_version));
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
       kGoodId, std::move(older_version_ptr), kInvalidPathToCrx,
       Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged,
       kDontInstallImmediately));
   {
     // Simulate an external source adding the extension as INTERNAL.
     content::WindowedNotificationObserver observer(
         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources());
     EXPECT_TRUE(service()->OnExternalExtensionFileFound(*info));
     EXPECT_TRUE(pending->IsIdPending(kGoodId));
@@ skipping 114 matching lines @@
   const bool kDontMarkAcknowledged = false;
   const bool kDontInstallImmediately = false;
 
   InitializeEmptyExtensionService();
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // An external provider starts installing from a local crx.
-  scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
-      kGoodId, make_scoped_ptr(new Version(kVersion123)), kInvalidPathToCrx,
+  std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+      kGoodId, base::WrapUnique(new Version(kVersion123)), kInvalidPathToCrx,
       Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged,
       kDontInstallImmediately));
   EXPECT_TRUE(service()->OnExternalExtensionFileFound(*info));
 
   const extensions::PendingExtensionInfo* pending_info;
   EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
   EXPECT_TRUE(pending_info->version().IsValid());
   EXPECT_EQ(pending_info->version(), kVersion123);
 
   // Adding a newer version overrides the currently pending version.
@@ skipping 13 matching lines @@
   // Adding an older version fails even when coming from a higher-priority
   // location.
   info->crx_location = Manifest::EXTERNAL_REGISTRY;
   EXPECT_FALSE(service()->OnExternalExtensionFileFound(*info));
   EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
   EXPECT_TRUE(pending_info->version().IsValid());
   EXPECT_EQ(pending_info->version(), kVersion124);
 
   // Adding the latest version from the webstore overrides a specific version.
   GURL kUpdateUrl("http://example.com/update");
-  scoped_ptr<ExternalInstallInfoUpdateUrl> update_info(
+  std::unique_ptr<ExternalInstallInfoUpdateUrl> update_info(
       new ExternalInstallInfoUpdateUrl(
-          kGoodId, std::string(), make_scoped_ptr(new GURL(kUpdateUrl)),
+          kGoodId, std::string(), base::WrapUnique(new GURL(kUpdateUrl)),
           Manifest::EXTERNAL_POLICY_DOWNLOAD, Extension::NO_FLAGS, false));
   EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(*update_info, true));
   EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
   EXPECT_FALSE(pending_info->version().IsValid());
 }
 
 // This makes sure we can package and install CRX files that use whitelisted
 // permissions.
 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
@@ skipping 34 matching lines @@
         crx_id_,
         std::string(),
         GURL(),
         Manifest::EXTERNAL_PREF_DOWNLOAD,
         Extension::NO_FLAGS,
         false);
   }
 
   // Fake an external file from external_extensions.json.
   bool AddPendingExternalPrefFileInstall() {
-    scoped_ptr<Version> version(new Version("1.0.0.0"));
-    scoped_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
+    std::unique_ptr<Version> version(new Version("1.0.0.0"));
+    std::unique_ptr<ExternalInstallInfoFile> info(new ExternalInstallInfoFile(
         crx_id_, std::move(version), crx_path_, Manifest::EXTERNAL_PREF,
         Extension::NO_FLAGS, false, false));
     return service()->OnExternalExtensionFileFound(*info);
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service()->pending_extension_manager()->AddFromSync(
         crx_id_,
         GURL(kGoodUpdateURL),
         base::Version(),
         &IsExtension,
         kGoodRemoteInstall,
         kGoodInstalledByCustodian);
   }
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
-    scoped_ptr<GURL> empty_url(new GURL());
-    scoped_ptr<ExternalInstallInfoUpdateUrl> info(
+    std::unique_ptr<GURL> empty_url(new GURL());
+    std::unique_ptr<ExternalInstallInfoUpdateUrl> info(
         new ExternalInstallInfoUpdateUrl(
             crx_id_, std::string(), std::move(empty_url),
             Manifest::EXTERNAL_POLICY_DOWNLOAD, Extension::NO_FLAGS, false));
     return service()->OnExternalExtensionUpdateUrlFound(*info, true);
   }
 
   // Get the install source of a pending extension.
   Manifest::Location GetPendingLocation() {
     const extensions::PendingExtensionInfo* info;
     EXPECT_TRUE(
@@ skipping 732 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }