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

chrome/browser/extensions/extension_prefs_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/extension_prefs_unittest.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 149 matching lines @@
 class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
  public:
   void Initialize() override {
     const APIPermissionInfo* permission_info =
       PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     api_perm_set1_.insert(APIPermission::kTab);
     api_perm_set1_.insert(APIPermission::kBookmark);
-    scoped_ptr<APIPermission> permission(
+    std::unique_ptr<APIPermission> permission(
         permission_info->CreateAPIPermission());
     {
-      scoped_ptr<base::ListValue> value(new base::ListValue());
+      std::unique_ptr<base::ListValue> value(new base::ListValue());
       value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
       value->Append(new base::StringValue("udp-bind::8080"));
       value->Append(new base::StringValue("udp-send-to::8888"));
       ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
     }
     api_perm_set1_.insert(permission.release());
 
     api_perm_set2_.insert(APIPermission::kHistory);
 
     AddPattern(&ehost_perm_set1_, "http://*.google.com/*");
@@ skipping 26 matching lines @@
 
     // Make sure both granted api and host permissions start empty.
     EXPECT_TRUE(prefs()->GetGrantedPermissions(extension_id_)->IsEmpty());
 
     {
       // Add part of the api permissions.
       prefs()->AddGrantedPermissions(
           extension_id_,
           PermissionSet(api_perm_set1_, empty_manifest_permissions,
                         empty_extent, empty_extent));
-      scoped_ptr<const PermissionSet> granted_permissions =
+      std::unique_ptr<const PermissionSet> granted_permissions =
           prefs()->GetGrantedPermissions(extension_id_);
       EXPECT_TRUE(granted_permissions.get());
       EXPECT_FALSE(granted_permissions->IsEmpty());
       EXPECT_EQ(expected_apis, granted_permissions->apis());
       EXPECT_TRUE(granted_permissions->effective_hosts().is_empty());
       EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     }
 
     {
       // Add part of the explicit host permissions.
       prefs()->AddGrantedPermissions(
           extension_id_, PermissionSet(empty_set, empty_manifest_permissions,
                                        ehost_perm_set1_, empty_extent));
-      scoped_ptr<const PermissionSet> granted_permissions =
+      std::unique_ptr<const PermissionSet> granted_permissions =
           prefs()->GetGrantedPermissions(extension_id_);
       EXPECT_FALSE(granted_permissions->IsEmpty());
       EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
       EXPECT_EQ(expected_apis, granted_permissions->apis());
       EXPECT_EQ(ehost_perm_set1_, granted_permissions->explicit_hosts());
       EXPECT_EQ(ehost_perm_set1_, granted_permissions->effective_hosts());
     }
 
     {
       // Add part of the scriptable host permissions.
       prefs()->AddGrantedPermissions(
           extension_id_, PermissionSet(empty_set, empty_manifest_permissions,
                                        empty_extent, shost_perm_set1_));
-      scoped_ptr<const PermissionSet> granted_permissions =
+      std::unique_ptr<const PermissionSet> granted_permissions =
           prefs()->GetGrantedPermissions(extension_id_);
       EXPECT_FALSE(granted_permissions->IsEmpty());
       EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
       EXPECT_EQ(expected_apis, granted_permissions->apis());
       EXPECT_EQ(ehost_perm_set1_, granted_permissions->explicit_hosts());
       EXPECT_EQ(shost_perm_set1_, granted_permissions->scriptable_hosts());
 
       effective_permissions_ =
           URLPatternSet::CreateUnion(ehost_perm_set1_, shost_perm_set1_);
       EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
     }
 
     {
       // Add the rest of the permissions.
       APIPermissionSet::Union(expected_apis, api_perm_set2_, &api_permissions_);
       prefs()->AddGrantedPermissions(
           extension_id_,
           PermissionSet(api_perm_set2_, empty_manifest_permissions,
                         ehost_perm_set2_, shost_perm_set2_));
 
-      scoped_ptr<const PermissionSet> granted_permissions =
+      std::unique_ptr<const PermissionSet> granted_permissions =
           prefs()->GetGrantedPermissions(extension_id_);
       EXPECT_TRUE(granted_permissions.get());
       EXPECT_FALSE(granted_permissions->IsEmpty());
       EXPECT_EQ(api_permissions_, granted_permissions->apis());
       EXPECT_EQ(ehost_permissions_, granted_permissions->explicit_hosts());
       EXPECT_EQ(shost_permissions_, granted_permissions->scriptable_hosts());
       effective_permissions_ =
           URLPatternSet::CreateUnion(ehost_permissions_, shost_permissions_);
       EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
     }
   }
 
   void Verify() override {
-    scoped_ptr<const PermissionSet> permissions =
+    std::unique_ptr<const PermissionSet> permissions =
         prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(permissions.get());
     EXPECT_FALSE(permissions->HasEffectiveFullAccess());
     EXPECT_EQ(api_permissions_, permissions->apis());
     EXPECT_EQ(ehost_permissions_,
               permissions->explicit_hosts());
     EXPECT_EQ(shost_permissions_,
               permissions->scriptable_hosts());
   }
 
@@ skipping 32 matching lines @@
     AddPattern(&ehosts, "chrome://favicon/*");
 
     URLPatternSet shosts;
     AddPattern(&shosts, "https://*.google.com/*");
     AddPattern(&shosts, "http://reddit.com/r/test/*");
 
     active_perms_.reset(new PermissionSet(api_perms, empty_manifest_permissions,
                                           ehosts, shosts));
 
     // Make sure the active permissions start empty.
-    scoped_ptr<const PermissionSet> active =
+    std::unique_ptr<const PermissionSet> active =
         prefs()->GetActivePermissions(extension_id_);
     EXPECT_TRUE(active->IsEmpty());
 
     // Set the active permissions.
     prefs()->SetActivePermissions(extension_id_, *active_perms_);
     active = prefs()->GetActivePermissions(extension_id_);
     EXPECT_EQ(active_perms_->apis(), active->apis());
     EXPECT_EQ(active_perms_->explicit_hosts(), active->explicit_hosts());
     EXPECT_EQ(active_perms_->scriptable_hosts(), active->scriptable_hosts());
     EXPECT_EQ(*active_perms_, *active);
   }
 
   void Verify() override {
-    scoped_ptr<const PermissionSet> permissions =
+    std::unique_ptr<const PermissionSet> permissions =
         prefs()->GetActivePermissions(extension_id_);
     EXPECT_EQ(*active_perms_, *permissions);
   }
 
  private:
   std::string extension_id_;
-  scoped_ptr<const PermissionSet> active_perms_;
+  std::unique_ptr<const PermissionSet> active_perms_;
 };
 TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
 
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
   void Initialize() override {
     extension = prefs_.AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
     prefs()->OnExtensionUninstalled(extension->id(),
@@ skipping 91 matching lines @@
                                    Extension::ENABLED,
                                    kInstallFlagNone,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal(),
                                    std::string());
   }
 
   // Verifies that we get back expected idle install information previously
   // set by SetIdleInfo.
   void VerifyIdleInfo(const std::string& id, int num) {
-    scoped_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
+    std::unique_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
     ASSERT_TRUE(info);
     std::string version;
     ASSERT_TRUE(info->extension_manifest->GetString("version", &version));
     ASSERT_EQ("1." + base::IntToString(num), version);
     ASSERT_EQ(base::IntToString(num),
               info->extension_path.BaseName().MaybeAsASCII());
   }
 
   bool HasInfoForId(ExtensionPrefs::ExtensionsInfo* info,
                     const std::string& id) {
@@ skipping 10 matching lines @@
     id1_ = prefs_.AddExtensionAndReturnId("1");
     id2_ = prefs_.AddExtensionAndReturnId("2");
     id3_ = prefs_.AddExtensionAndReturnId("3");
     id4_ = prefs_.AddExtensionAndReturnId("4");
 
     // Set info for two extensions, then remove it.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
-    scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
+    std::unique_ptr<ExtensionPrefs::ExtensionsInfo> info(
         prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(2u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     prefs()->RemoveDelayedInstallInfo(id1_);
     prefs()->RemoveDelayedInstallInfo(id2_);
     info = prefs()->GetAllDelayedInstallInfo();
     EXPECT_TRUE(info->empty());
 
     // Try getting/removing info for an id that used to have info set.
@@ skipping 11 matching lines @@
     SetIdleInfo(id4_, 4);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id3_, 3);
     VerifyIdleInfo(id4_, 4);
     prefs()->RemoveDelayedInstallInfo(id3_);
   }
 
   void Verify() override {
     // Make sure the info for the 3 extensions we expect is present.
-    scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
+    std::unique_ptr<ExtensionPrefs::ExtensionsInfo> info(
         prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(3u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     EXPECT_TRUE(HasInfoForId(info.get(), id4_));
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id4_, 4);
 
     // Make sure there isn't info the for the one extension id we removed.
@@ skipping 20 matching lines @@
     dictionary.SetString(manifest_keys::kBackgroundPage, "background.html");
     scoped_refptr<Extension> extension =
         prefs_.AddExtensionWithManifest(dictionary, Manifest::INTERNAL);
     id_ = extension->id();
 
 
     // Set idle info
     base::DictionaryValue manifest;
     manifest.SetString(manifest_keys::kName, "test");
     manifest.SetString(manifest_keys::kVersion, "0.2");
-    scoped_ptr<base::ListValue> scripts(new base::ListValue);
+    std::unique_ptr<base::ListValue> scripts(new base::ListValue);
     scripts->AppendString("test.js");
     manifest.Set(manifest_keys::kBackgroundScripts, scripts.release());
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII("test_0.2");
     std::string errors;
     scoped_refptr<Extension> new_extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id_, &errors);
     ASSERT_TRUE(new_extension.get()) << errors;
     ASSERT_EQ(id_, new_extension->id());
     prefs()->SetDelayedInstallInfo(new_extension.get(),
@@ skipping 372 matching lines @@
     active_perms_.reset(new PermissionSet(api_perms, empty_manifest_permissions,
                                           ehosts, shosts));
     // Set the active permissions.
     prefs()->SetActivePermissions(component_extension_->id(), *active_perms_);
     prefs()->SetActivePermissions(no_component_extension_->id(),
                                   *active_perms_);
   }
 
   void Verify() override {
     // Component extension can access chrome://print/*.
-    scoped_ptr<const PermissionSet> component_permissions =
+    std::unique_ptr<const PermissionSet> component_permissions =
         prefs()->GetActivePermissions(component_extension_->id());
     EXPECT_EQ(1u, component_permissions->scriptable_hosts().size());
 
     // Non Component extension can not access chrome://print/*.
-    scoped_ptr<const PermissionSet> no_component_permissions =
+    std::unique_ptr<const PermissionSet> no_component_permissions =
         prefs()->GetActivePermissions(no_component_extension_->id());
     EXPECT_EQ(0u, no_component_permissions->scriptable_hosts().size());
 
     // |URLPattern::SCHEME_CHROMEUI| scheme will be added in valid_schemes for
     // component extensions.
     URLPatternSet scriptable_hosts;
     std::string pref_key = "active_permissions.scriptable_host";
     int valid_schemes = URLPattern::SCHEME_ALL & ~URLPattern::SCHEME_CHROMEUI;
 
     EXPECT_TRUE(prefs()->ReadPrefAsURLPatternSet(component_extension_->id(),
                                                  pref_key, &scriptable_hosts,
                                                  valid_schemes));
 
     EXPECT_FALSE(prefs()->ReadPrefAsURLPatternSet(no_component_extension_->id(),
                                                   pref_key, &scriptable_hosts,
                                                   valid_schemes));
   }
 
  private:
-  scoped_ptr<const PermissionSet> active_perms_;
+  std::unique_ptr<const PermissionSet> active_perms_;
   scoped_refptr<Extension> component_extension_;
   scoped_refptr<Extension> no_component_extension_;
 };
 TEST_F(ExtensionPrefsComponentExtension, ExtensionPrefsComponentExtension) {
 }
 
 }  // namespace extensions