Convert chrome/common to std::unique_ptr

chrome/common/pepper_permission_util_unittest.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/common/pepper_permission_util.h"
 
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "components/crx_file/id_util.h"
 #include "components/version_info/version_info.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using chrome::IsExtensionOrSharedModuleWhitelisted;
 
 namespace extensions {
 
 namespace {
 
 // Return an extension with |id| which imports a module with the given
 // |import_id|.
 scoped_refptr<Extension> CreateExtensionImportingModule(
     const std::string& import_id,
     const std::string& id) {
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "Has Dependent Modules")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("import",
                ListBuilder()
                    .Append(DictionaryBuilder().Set("id", import_id).Build())
                    .Build())
           .Build();
 
   return ExtensionBuilder()
       .SetManifest(std::move(manifest))
       .AddFlags(Extension::FROM_WEBSTORE)
       .SetID(id)
       .Build();
 }
 
 }  // namespace
 
 TEST(PepperPermissionUtilTest, ExtensionWhitelisting) {
   ScopedCurrentChannel current_channel(version_info::Channel::UNKNOWN);
   ExtensionSet extensions;
   std::string whitelisted_id =
       crx_file::id_util::GenerateId("whitelisted_extension");
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "Whitelisted Extension")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Build();
   scoped_refptr<Extension> ext = ExtensionBuilder()
                                      .SetManifest(std::move(manifest))
                                      .SetID(whitelisted_id)
                                      .Build();
   extensions.Insert(ext);
@@ skipping 16 matching lines @@
   EXPECT_FALSE(IsExtensionOrSharedModuleWhitelisted(
       GURL(bad_host_url), &extensions, whitelist));
 }
 
 TEST(PepperPermissionUtilTest, SharedModuleWhitelisting) {
   ScopedCurrentChannel current_channel(version_info::Channel::UNKNOWN);
   ExtensionSet extensions;
   std::string whitelisted_id = crx_file::id_util::GenerateId("extension_id");
   std::string bad_id = crx_file::id_util::GenerateId("bad_id");
 
-  scoped_ptr<base::DictionaryValue> shared_module_manifest =
+  std::unique_ptr<base::DictionaryValue> shared_module_manifest =
       DictionaryBuilder()
           .Set("name", "Whitelisted Shared Module")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                DictionaryBuilder()
                    .Set("resources", ListBuilder().Append("*").Build())
                    // Add the extension to the whitelist.  This
                    // restricts import to |whitelisted_id| only.
                    .Set("whitelist",
@@ skipping 34 matching lines @@
       GURL(not_in_sm_whitelist_url), &extensions, whitelist));
 
   // Note that the whitelist should be empty after this call, so tests checking
   // for failure to import will fail because of this.
   whitelist.erase(shared_module->id());
   EXPECT_FALSE(IsExtensionOrSharedModuleWhitelisted(
       GURL(extension_url), &extensions, whitelist));
 }
 
 }  // namespace extensions