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

chrome/browser/extensions/permissions_updater_unittest.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/permissions_updater.h"
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_test_util.h"
@@ skipping 11 matching lines @@
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extension_test_util::LoadManifest;
 
 namespace extensions {
 
 namespace {
 
 scoped_refptr<const Extension> CreateExtensionWithOptionalPermissions(
-    scoped_ptr<base::Value> optional_permissions,
-    scoped_ptr<base::Value> permissions,
+    std::unique_ptr<base::Value> optional_permissions,
+    std::unique_ptr<base::Value> permissions,
     const std::string& name) {
   return ExtensionBuilder()
       .SetLocation(Manifest::INTERNAL)
       .SetManifest(
           DictionaryBuilder()
               .Set("name", name)
               .Set("description", "foo")
               .Set("manifest_version", 2)
               .Set("version", "0.1.2.3")
               .Set("permissions", std::move(permissions))
@@ skipping 49 matching lines @@
     if (waiting_) {
       waiting_ = false;
       base::MessageLoopForUI::current()->QuitWhenIdle();
     }
   }
 
   bool received_notification_;
   bool waiting_;
   content::NotificationRegistrar registrar_;
   scoped_refptr<const Extension> extension_;
-  scoped_ptr<const PermissionSet> permissions_;
+  std::unique_ptr<const PermissionSet> permissions_;
   UpdatedExtensionPermissionsInfo::Reason reason_;
 };
 
 class PermissionsUpdaterTest : public ExtensionServiceTestBase {
 };
 
 scoped_refptr<Extension> LoadOurManifest() {
   base::FilePath path;
   path = path.AppendASCII("api_test")
       .AppendASCII("permissions")
@@ skipping 28 matching lines @@
   URLPatternSet default_hosts;
   AddPattern(&default_hosts, "http://a.com/*");
   PermissionSet default_permissions(default_apis, empty_manifest_permissions,
                                     default_hosts, URLPatternSet());
 
   // Make sure it loaded properly.
   ASSERT_EQ(default_permissions,
             extension->permissions_data()->active_permissions());
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
-  scoped_ptr<const PermissionSet> active_permissions;
-  scoped_ptr<const PermissionSet> granted_permissions;
+  std::unique_ptr<const PermissionSet> active_permissions;
+  std::unique_ptr<const PermissionSet> granted_permissions;
 
   // Add a few permissions.
   APIPermissionSet apis;
   apis.insert(APIPermission::kNotifications);
   URLPatternSet hosts;
   AddPattern(&hosts, "http://*.c.com/*");
 
   {
     PermissionSet delta(apis, empty_manifest_permissions, hosts,
                         URLPatternSet());
@@ skipping 58 matching lines @@
 }
 
 TEST_F(PermissionsUpdaterTest, RevokingPermissions) {
   InitializeEmptyExtensionService();
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   auto api_permission_set = [](APIPermission::ID id) {
     APIPermissionSet apis;
     apis.insert(id);
-    return make_scoped_ptr(new PermissionSet(apis, ManifestPermissionSet(),
-                                             URLPatternSet(), URLPatternSet()));
+    return base::WrapUnique(new PermissionSet(
+        apis, ManifestPermissionSet(), URLPatternSet(), URLPatternSet()));
   };
 
   auto url_permission_set = [](const GURL& url) {
     URLPatternSet set;
     URLPattern pattern(URLPattern::SCHEME_ALL, url.spec());
     set.AddPattern(pattern);
-    return make_scoped_ptr(new PermissionSet(
+    return base::WrapUnique(new PermissionSet(
         APIPermissionSet(), ManifestPermissionSet(), set, URLPatternSet()));
   };
 
   {
     // Test revoking optional permissions.
     ListBuilder optional_permissions;
     optional_permissions.Append("tabs").Append("cookies").Append("management");
     ListBuilder required_permissions;
     required_permissions.Append("topSites");
     scoped_refptr<const Extension> extension =
         CreateExtensionWithOptionalPermissions(optional_permissions.Build(),
                                                required_permissions.Build(),
                                                "My Extension");
 
     PermissionsUpdater updater(profile());
     EXPECT_TRUE(updater.GetRevokablePermissions(extension.get())->IsEmpty());
 
     // Add the optional "cookies" permission.
     updater.AddPermissions(extension.get(),
                            *api_permission_set(APIPermission::kCookie));
     const PermissionsData* permissions = extension->permissions_data();
     // The extension should have the permission in its active permissions and
     // its granted permissions (stored in prefs). And, the permission should
     // be revokable.
     EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kCookie));
-    scoped_ptr<const PermissionSet> granted_permissions =
+    std::unique_ptr<const PermissionSet> granted_permissions =
         prefs->GetGrantedPermissions(extension->id());
     EXPECT_TRUE(granted_permissions->HasAPIPermission(APIPermission::kCookie));
     EXPECT_TRUE(updater.GetRevokablePermissions(extension.get())
                     ->HasAPIPermission(APIPermission::kCookie));
 
     // Repeat with "tabs".
     updater.AddPermissions(extension.get(),
                            *api_permission_set(APIPermission::kTab));
     EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kTab));
     granted_permissions = prefs->GetGrantedPermissions(extension->id());
@@ skipping 70 matching lines @@
                      ->active_permissions()
                      .HasExplicitAccessToOrigin(kOrigin));
     EXPECT_TRUE(extension->permissions_data()
                     ->withheld_permissions()
                     .HasExplicitAccessToOrigin(kOrigin));
     EXPECT_TRUE(updater.GetRevokablePermissions(extension.get())->IsEmpty());
   }
 }
 
 }  // namespace extensions