[Extensions] Un-refcount PermissionSet

chrome/common/extensions/permissions/permission_set_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 "base/command_line.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 170 matching lines @@
   EXPECT_EQ(storage_name, info->GetByID(
       APIPermission::kUnlimitedStorage)->name());
   EXPECT_EQ(APIPermission::kUnlimitedStorage,
             info->GetByName("unlimitedStorage")->id());
   EXPECT_EQ(APIPermission::kUnlimitedStorage,
             info->GetByName("unlimited_storage")->id());
 }
 
 TEST(PermissionsTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
-  scoped_refptr<const PermissionSet> permissions;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
-  permissions = extension->permissions_data()->active_permissions();
+  const PermissionSet* permissions =
+      extension->permissions_data()->active_permissions();
   EXPECT_EQ(0u,
             extension->permissions_data()
                 ->GetEffectiveHostPermissions()
                 .patterns()
                 .size());
   EXPECT_FALSE(
       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "one_host.json");
@@ skipping 64 matching lines @@
 TEST(PermissionsTest, ExplicitAccessToOrigin) {
   APIPermissionSet apis;
   ManifestPermissionSet manifest_permissions;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
 
   AddPattern(&explicit_hosts, "http://*.google.com/*");
   // The explicit host paths should get set to /*.
   AddPattern(&explicit_hosts, "http://www.example.com/a/particular/path/*");
 
-  scoped_refptr<const PermissionSet> perm_set = new PermissionSet(
-      apis, manifest_permissions, explicit_hosts, scriptable_hosts);
-  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
-      GURL("http://www.google.com/")));
-  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
-      GURL("http://test.google.com/")));
-  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
-      GURL("http://www.example.com")));
-  ASSERT_TRUE(perm_set->HasEffectiveAccessToURL(
-      GURL("http://www.example.com")));
-  ASSERT_FALSE(perm_set->HasExplicitAccessToOrigin(
-      GURL("http://test.example.com")));
+  PermissionSet perm_set(apis, manifest_permissions, explicit_hosts,
+                         scriptable_hosts);
+  ASSERT_TRUE(
+      perm_set.HasExplicitAccessToOrigin(GURL("http://www.google.com/")));
+  ASSERT_TRUE(
+      perm_set.HasExplicitAccessToOrigin(GURL("http://test.google.com/")));
+  ASSERT_TRUE(
+      perm_set.HasExplicitAccessToOrigin(GURL("http://www.example.com")));
+  ASSERT_TRUE(perm_set.HasEffectiveAccessToURL(GURL("http://www.example.com")));
+  ASSERT_FALSE(
+      perm_set.HasExplicitAccessToOrigin(GURL("http://test.example.com")));
 }
 
 TEST(PermissionsTest, CreateUnion) {
   APIPermission* permission = NULL;
 
   ManifestPermissionSet manifest_permissions;
   APIPermissionSet apis1;
   APIPermissionSet apis2;
   APIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
   URLPatternSet expected_scriptable_hosts;
 
   URLPatternSet effective_hosts;
 
-  scoped_refptr<const PermissionSet> set1;
-  scoped_refptr<const PermissionSet> set2;
-  scoped_refptr<const PermissionSet> union_set;
+  scoped_ptr<const PermissionSet> set1;
+  scoped_ptr<const PermissionSet> set2;
+  scoped_ptr<const PermissionSet> union_set;
 
   const APIPermissionInfo* permission_info =
     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
   permission = permission_info->CreateAPIPermission();
   {
     scoped_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));
   }
 
   // Union with an empty set.
   apis1.insert(APIPermission::kTab);
   apis1.insert(APIPermission::kBackground);
   apis1.insert(permission->Clone());
   expected_apis.insert(APIPermission::kTab);
   expected_apis.insert(APIPermission::kBackground);
   expected_apis.insert(permission);
 
   AddPattern(&explicit_hosts1, "http://*.google.com/*");
   AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
   AddPattern(&effective_hosts, "http://*.google.com/*");
 
-  set1 = new PermissionSet(apis1, manifest_permissions,
-                           explicit_hosts1, scriptable_hosts1);
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set1.reset(new PermissionSet(apis1, manifest_permissions, explicit_hosts1,
+                               scriptable_hosts1));
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   union_set = PermissionSet::CreateUnion(*set1, *set2);
   EXPECT_TRUE(set1->Contains(*set2.get()));
   EXPECT_TRUE(set1->Contains(*union_set.get()));
   EXPECT_FALSE(set2->Contains(*set1.get()));
   EXPECT_FALSE(set2->Contains(*union_set.get()));
   EXPECT_TRUE(union_set->Contains(*set1.get()));
   EXPECT_TRUE(union_set->Contains(*set2.get()));
 
   EXPECT_FALSE(union_set->HasEffectiveFullAccess());
   EXPECT_EQ(expected_apis, union_set->apis());
@@ skipping 34 matching lines @@
   expected_apis.insert(permission);
 
   AddPattern(&explicit_hosts2, "http://*.example.com/*");
   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
   AddPattern(&expected_explicit_hosts, "http://*.example.com/*");
   AddPattern(&expected_scriptable_hosts, "http://*.google.com/*");
 
   effective_hosts =
       URLPatternSet::CreateUnion(explicit_hosts2, scriptable_hosts2);
 
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   union_set = PermissionSet::CreateUnion(*set1, *set2);
 
   EXPECT_FALSE(set1->Contains(*set2.get()));
   EXPECT_FALSE(set1->Contains(*union_set.get()));
   EXPECT_FALSE(set2->Contains(*set1.get()));
   EXPECT_FALSE(set2->Contains(*union_set.get()));
   EXPECT_TRUE(union_set->Contains(*set1.get()));
   EXPECT_TRUE(union_set->Contains(*set2.get()));
 
   EXPECT_TRUE(union_set->HasEffectiveFullAccess());
@@ skipping 15 matching lines @@
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
   URLPatternSet expected_scriptable_hosts;
 
   URLPatternSet effective_hosts;
 
-  scoped_refptr<const PermissionSet> set1;
-  scoped_refptr<const PermissionSet> set2;
-  scoped_refptr<const PermissionSet> new_set;
+  scoped_ptr<const PermissionSet> set1;
+  scoped_ptr<const PermissionSet> set2;
+  scoped_ptr<const PermissionSet> new_set;
 
   const APIPermissionInfo* permission_info =
     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
   // Intersection with an empty set.
   apis1.insert(APIPermission::kTab);
   apis1.insert(APIPermission::kBackground);
   permission = permission_info->CreateAPIPermission();
   {
     scoped_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));
   }
   apis1.insert(permission);
 
   AddPattern(&explicit_hosts1, "http://*.google.com/*");
   AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
 
-  set1 = new PermissionSet(apis1, manifest_permissions,
-                           explicit_hosts1, scriptable_hosts1);
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set1.reset(new PermissionSet(apis1, manifest_permissions, explicit_hosts1,
+                               scriptable_hosts1));
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   new_set = PermissionSet::CreateIntersection(*set1, *set2);
   EXPECT_TRUE(set1->Contains(*new_set.get()));
   EXPECT_TRUE(set2->Contains(*new_set.get()));
   EXPECT_TRUE(set1->Contains(*set2.get()));
   EXPECT_FALSE(set2->Contains(*set1.get()));
   EXPECT_FALSE(new_set->Contains(*set1.get()));
   EXPECT_TRUE(new_set->Contains(*set2.get()));
 
   EXPECT_TRUE(new_set->IsEmpty());
   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
@@ skipping 28 matching lines @@
   expected_apis.insert(permission);
 
   AddPattern(&explicit_hosts2, "http://*.example.com/*");
   AddPattern(&explicit_hosts2, "http://*.google.com/*");
   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
   AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
 
   effective_hosts.ClearPatterns();
   AddPattern(&effective_hosts, "http://*.google.com/*");
 
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   new_set = PermissionSet::CreateIntersection(*set1, *set2);
 
   EXPECT_TRUE(set1->Contains(*new_set.get()));
   EXPECT_TRUE(set2->Contains(*new_set.get()));
   EXPECT_FALSE(set1->Contains(*set2.get()));
   EXPECT_FALSE(set2->Contains(*set1.get()));
   EXPECT_FALSE(new_set->Contains(*set1.get()));
   EXPECT_FALSE(new_set->Contains(*set2.get()));
 
   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
@@ skipping 15 matching lines @@
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
   URLPatternSet expected_scriptable_hosts;
 
   URLPatternSet effective_hosts;
 
-  scoped_refptr<const PermissionSet> set1;
-  scoped_refptr<const PermissionSet> set2;
-  scoped_refptr<const PermissionSet> new_set;
+  scoped_ptr<const PermissionSet> set1;
+  scoped_ptr<const PermissionSet> set2;
+  scoped_ptr<const PermissionSet> new_set;
 
   const APIPermissionInfo* permission_info =
     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
   // Difference with an empty set.
   apis1.insert(APIPermission::kTab);
   apis1.insert(APIPermission::kBackground);
   permission = permission_info->CreateAPIPermission();
   {
     scoped_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));
   }
   apis1.insert(permission);
 
   AddPattern(&explicit_hosts1, "http://*.google.com/*");
   AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
 
-  set1 = new PermissionSet(apis1, manifest_permissions,
-                           explicit_hosts1, scriptable_hosts1);
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set1.reset(new PermissionSet(apis1, manifest_permissions, explicit_hosts1,
+                               scriptable_hosts1));
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   new_set = PermissionSet::CreateDifference(*set1, *set2);
   EXPECT_EQ(*set1.get(), *new_set.get());
 
   // Now use a real second set.
   apis2.insert(APIPermission::kTab);
   apis2.insert(APIPermission::kProxy);
   apis2.insert(APIPermission::kClipboardWrite);
   apis2.insert(APIPermission::kPlugin);
   permission = permission_info->CreateAPIPermission();
   {
@@ skipping 15 matching lines @@
   expected_apis.insert(permission);
 
   AddPattern(&explicit_hosts2, "http://*.example.com/*");
   AddPattern(&explicit_hosts2, "http://*.google.com/*");
   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
   AddPattern(&expected_scriptable_hosts, "http://www.reddit.com/*");
 
   effective_hosts.ClearPatterns();
   AddPattern(&effective_hosts, "http://www.reddit.com/*");
 
-  set2 = new PermissionSet(apis2, manifest_permissions,
-                           explicit_hosts2, scriptable_hosts2);
+  set2.reset(new PermissionSet(apis2, manifest_permissions, explicit_hosts2,
+                               scriptable_hosts2));
   new_set = PermissionSet::CreateDifference(*set1, *set2);
 
   EXPECT_TRUE(set1->Contains(*new_set.get()));
   EXPECT_FALSE(set2->Contains(*new_set.get()));
 
   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
   EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
   EXPECT_EQ(expected_apis, new_set->apis());
   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
@@ skipping 51 matching lines @@
         LoadManifest("allow_silent_upgrade",
                      std::string(kTests[i].base_name) + "_old.json"));
     scoped_refptr<Extension> new_extension(
         LoadManifest("allow_silent_upgrade",
                      std::string(kTests[i].base_name) + "_new.json"));
 
     EXPECT_TRUE(new_extension.get()) << kTests[i].base_name << "_new.json";
     if (!new_extension.get())
       continue;
 
-    scoped_refptr<const PermissionSet> old_p(
-        old_extension->permissions_data()->active_permissions());
-    scoped_refptr<const PermissionSet> new_p(
-        new_extension->permissions_data()->active_permissions());
+    const PermissionSet* old_p =
+        old_extension->permissions_data()->active_permissions();
+    const PermissionSet* new_p =
+        new_extension->permissions_data()->active_permissions();
     Manifest::Type extension_type = old_extension->GetType();
 
     bool increased = PermissionMessageProvider::Get()->IsPrivilegeIncrease(
-        old_p.get(), new_p.get(), extension_type);
+        old_p, new_p, extension_type);
     EXPECT_EQ(kTests[i].expect_increase, increased) << kTests[i].base_name;
   }
 }
 
 TEST(PermissionsTest, PermissionMessages) {
   // Ensure that all permissions that needs to show install UI actually have
   // strings associated with them.
   APIPermissionSet skip;
 
   // These are considered "nuisance" or "trivial" permissions that don't need
@@ skipping 159 matching lines @@
     bool has_message = !provider->GetPermissionMessages(id).empty();
     bool should_have_message = !skip.count(i->id());
     EXPECT_EQ(should_have_message, has_message) << permission_info->name();
   }
 }
 
 TEST(PermissionsTest, FileSystemPermissionMessages) {
   APIPermissionSet api_permissions;
   api_permissions.insert(APIPermission::kFileSystemWrite);
   api_permissions.insert(APIPermission::kFileSystemDirectory);
-  scoped_refptr<const PermissionSet> permissions(
-      new PermissionSet(api_permissions, ManifestPermissionSet(),
-                        URLPatternSet(), URLPatternSet()));
-  EXPECT_TRUE(PermissionSetProducesMessage(
-      permissions.get(), Manifest::TYPE_PLATFORM_APP,
-      MakePermissionIDSet(api_permissions)));
+  PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                            URLPatternSet(), URLPatternSet());
+  EXPECT_TRUE(
+      PermissionSetProducesMessage(&permissions, Manifest::TYPE_PLATFORM_APP,
+                                   MakePermissionIDSet(api_permissions)));
 }
 
 TEST(PermissionsTest, HiddenFileSystemPermissionMessages) {
   APIPermissionSet api_permissions;
   api_permissions.insert(APIPermission::kFileSystemWrite);
   api_permissions.insert(APIPermission::kFileSystemDirectory);
-  scoped_refptr<const PermissionSet> permissions(
-      new PermissionSet(api_permissions, ManifestPermissionSet(),
-                        URLPatternSet(), URLPatternSet()));
-  EXPECT_TRUE(PermissionSetProducesMessage(
-      permissions.get(), Manifest::TYPE_PLATFORM_APP,
-      MakePermissionIDSet(api_permissions)));
+  PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                            URLPatternSet(), URLPatternSet());
+  EXPECT_TRUE(
+      PermissionSetProducesMessage(&permissions, Manifest::TYPE_PLATFORM_APP,
+                                   MakePermissionIDSet(api_permissions)));
 }
 
 TEST(PermissionsTest, SuppressedPermissionMessages) {
   {
     // Tabs warning suppresses favicon warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
                                 "chrome://favicon/"));
-    scoped_refptr<const PermissionSet> permissions(new PermissionSet(
-        api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(), hosts,
+                              URLPatternSet());
     EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         MakePermissionIDSet(APIPermission::kTab, APIPermission::kFavicon)));
   }
   {
     // History warning suppresses favicon warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kHistory);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
                                 "chrome://favicon/"));
-    scoped_refptr<const PermissionSet> permissions(new PermissionSet(
-        api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(), hosts,
+                              URLPatternSet());
     EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         MakePermissionIDSet(APIPermission::kHistory, APIPermission::kFavicon)));
   }
   {
     // All sites warning suppresses tabs warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    scoped_refptr<const PermissionSet> permissions(new PermissionSet(
-        api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(), hosts,
+                              URLPatternSet());
     EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         MakePermissionIDSet(APIPermission::kHostsAll, APIPermission::kTab)));
   }
   {
     // All sites warning suppresses topSites warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTopSites);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    scoped_refptr<const PermissionSet> permissions(new PermissionSet(
-        api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(), hosts,
+                              URLPatternSet());
     EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         MakePermissionIDSet(APIPermission::kHostsAll,
                             APIPermission::kTopSites)));
   }
   {
     // All sites warning suppresses declarativeWebRequest warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kDeclarativeWebRequest);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    scoped_refptr<const PermissionSet> permissions(new PermissionSet(
-        api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(), hosts,
+                              URLPatternSet());
     EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         MakePermissionIDSet(APIPermission::kHostsAll)));
   }
   {
     // BrowsingHistory warning suppresses all history read/write warnings.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kHistory);
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
-    EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
-        MakePermissionIDSet(api_permissions)));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
+    EXPECT_TRUE(
+        PermissionSetProducesMessage(&permissions, Manifest::TYPE_EXTENSION,
+                                     MakePermissionIDSet(api_permissions)));
   }
   {
     // Tabs warning suppresses all read-only history warnings.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
-    EXPECT_TRUE(PermissionSetProducesMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
-        MakePermissionIDSet(api_permissions)));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
+    EXPECT_TRUE(
+        PermissionSetProducesMessage(&permissions, Manifest::TYPE_EXTENSION,
+                                     MakePermissionIDSet(api_permissions)));
   }
 }
 
 TEST(PermissionsTest, AccessToDevicesMessages) {
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kSerial);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
     VerifyOnePermissionMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
   }
   {
     // Testing that multiple permissions will show the one message.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kSerial);
     api_permissions.insert(APIPermission::kSerial);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
     VerifyOnePermissionMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
   }
   {
     scoped_refptr<Extension> extension =
         LoadManifest("permissions", "access_to_devices_bluetooth.json");
     PermissionSet* set = const_cast<PermissionSet*>(
-        extension->permissions_data()->active_permissions().get());
+        extension->permissions_data()->active_permissions());
     VerifyOnePermissionMessage(
         set, extension->GetType(),
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH));
 
     // Test Bluetooth and Serial
     set->apis_.insert(APIPermission::kSerial);
     VerifyOnePermissionMessage(
         set, extension->GetType(),
         l10n_util::GetStringUTF16(
             IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_SERIAL));
   }
 }
 
 TEST(PermissionsTest, MergedFileSystemPermissionComparison) {
   APIPermissionSet write_api_permissions;
   write_api_permissions.insert(APIPermission::kFileSystemWrite);
-  scoped_refptr<const PermissionSet> write_permissions(
-      new PermissionSet(write_api_permissions, ManifestPermissionSet(),
-                        URLPatternSet(), URLPatternSet()));
+  PermissionSet write_permissions(write_api_permissions,
+                                  ManifestPermissionSet(), URLPatternSet(),
+                                  URLPatternSet());
 
   APIPermissionSet directory_api_permissions;
   directory_api_permissions.insert(APIPermission::kFileSystemDirectory);
-  scoped_refptr<const PermissionSet> directory_permissions(
-      new PermissionSet(directory_api_permissions, ManifestPermissionSet(),
-                        URLPatternSet(), URLPatternSet()));
+  PermissionSet directory_permissions(directory_api_permissions,
+                                      ManifestPermissionSet(), URLPatternSet(),
+                                      URLPatternSet());
 
   APIPermissionSet write_directory_api_permissions;
   write_directory_api_permissions.insert(APIPermission::kFileSystemWrite);
   write_directory_api_permissions.insert(APIPermission::kFileSystemDirectory);
-  scoped_refptr<const PermissionSet> write_directory_permissions(
-      new PermissionSet(write_directory_api_permissions,
-                        ManifestPermissionSet(), URLPatternSet(),
-                        URLPatternSet()));
+  PermissionSet write_directory_permissions(write_directory_api_permissions,
+                                            ManifestPermissionSet(),
+                                            URLPatternSet(), URLPatternSet());
 
   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
-  EXPECT_FALSE(provider->IsPrivilegeIncrease(write_directory_permissions.get(),
-                                             write_permissions.get(),
+  EXPECT_FALSE(provider->IsPrivilegeIncrease(&write_directory_permissions,
+                                             &write_permissions,
                                              Manifest::TYPE_PLATFORM_APP));
-  EXPECT_FALSE(provider->IsPrivilegeIncrease(write_directory_permissions.get(),
-                                             directory_permissions.get(),
+  EXPECT_FALSE(provider->IsPrivilegeIncrease(&write_directory_permissions,
+                                             &directory_permissions,
                                              Manifest::TYPE_PLATFORM_APP));
-  EXPECT_TRUE(provider->IsPrivilegeIncrease(write_permissions.get(),
-                                            directory_permissions.get(),
+  EXPECT_TRUE(provider->IsPrivilegeIncrease(
+      &write_permissions, &directory_permissions, Manifest::TYPE_PLATFORM_APP));
+  EXPECT_TRUE(provider->IsPrivilegeIncrease(&write_permissions,
+                                            &write_directory_permissions,
                                             Manifest::TYPE_PLATFORM_APP));
-  EXPECT_TRUE(provider->IsPrivilegeIncrease(write_permissions.get(),
-                                            write_directory_permissions.get(),
-                                            Manifest::TYPE_PLATFORM_APP));
-  EXPECT_FALSE(provider->IsPrivilegeIncrease(directory_permissions.get(),
-                                             write_permissions.get(),
-                                             Manifest::TYPE_PLATFORM_APP));
-  EXPECT_TRUE(provider->IsPrivilegeIncrease(directory_permissions.get(),
-                                            write_directory_permissions.get(),
+  EXPECT_FALSE(provider->IsPrivilegeIncrease(
+      &directory_permissions, &write_permissions, Manifest::TYPE_PLATFORM_APP));
+  EXPECT_TRUE(provider->IsPrivilegeIncrease(&directory_permissions,
+                                            &write_directory_permissions,
                                             Manifest::TYPE_PLATFORM_APP));
 }
 
 TEST(PermissionsTest, GetWarningMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions", "many-hosts.json");
   EXPECT_TRUE(VerifyOnePermissionMessage(
       extension->permissions_data(),
       "Read and change your data on encrypted.google.com and www.google.com"));
 }
@@ skipping 16 matching lines @@
 TEST(PermissionsTest, GetWarningMessages_AudioVideo) {
   const std::string kAudio("Use your microphone");
   const std::string kVideo("Use your camera");
   const std::string kBoth("Use your microphone and camera");
 
   // Both audio and video present.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "audio-video.json");
   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
   PermissionSet* set = const_cast<PermissionSet*>(
-      extension->permissions_data()->active_permissions().get());
+      extension->permissions_data()->active_permissions());
   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kAudio));
   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kVideo));
   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(), kBoth));
   PermissionMessages warnings = provider->GetPermissionMessages(
       provider->GetAllPermissionIDs(set, extension->GetType()));
   size_t combined_index = IndexOf(warnings, kBoth);
   size_t combined_size = warnings.size();
 
   // Just audio present.
   set->apis_.erase(APIPermission::kVideoCapture);
@@ skipping 18 matching lines @@
 }
 
 TEST(PermissionsTest, GetWarningMessages_CombinedSessions) {
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
     api_permissions.insert(APIPermission::kSessions);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
     EXPECT_TRUE(VerifyOnePermissionMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         l10n_util::GetStringUTF16(
             IDS_EXTENSION_PROMPT_WARNING_HISTORY_READ_AND_SESSIONS)));
   }
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kHistory);
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
     api_permissions.insert(APIPermission::kSessions);
-    scoped_refptr<const PermissionSet> permissions(
-        new PermissionSet(api_permissions, ManifestPermissionSet(),
-                          URLPatternSet(), URLPatternSet()));
+    PermissionSet permissions(api_permissions, ManifestPermissionSet(),
+                              URLPatternSet(), URLPatternSet());
     EXPECT_TRUE(VerifyOnePermissionMessage(
-        permissions.get(), Manifest::TYPE_EXTENSION,
+        &permissions, Manifest::TYPE_EXTENSION,
         l10n_util::GetStringUTF16(
             IDS_EXTENSION_PROMPT_WARNING_HISTORY_WRITE_AND_SESSIONS)));
   }
 }
 
 TEST(PermissionsTest, GetWarningMessages_DeclarativeWebRequest) {
   // Test that if the declarativeWebRequest permission is present
   // in combination with all hosts permission, then only the warning
   // for host permissions is shown, because that covers the use of
   // declarativeWebRequest.
 
   // Until Declarative Web Request is in stable, let's make sure it is enabled
   // on the current channel.
   ScopedCurrentChannel sc(version_info::Channel::CANARY);
 
   // First verify that declarativeWebRequest produces a message when host
   // permissions do not cover all hosts.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "web_request_not_all_host_permissions.json");
   const PermissionSet* set =
-      extension->permissions_data()->active_permissions().get();
+      extension->permissions_data()->active_permissions();
   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(),
                                          "Block parts of web pages"));
   EXPECT_FALSE(VerifyHasPermissionMessage(
       set, extension->GetType(),
       "Read and change all your data on the websites you visit"));
 
   // Now verify that declarativeWebRequest does not produce a message when host
   // permissions do cover all hosts.
   extension =
       LoadManifest("permissions", "web_request_all_host_permissions.json");
-  set = extension->permissions_data()->active_permissions().get();
+  set = extension->permissions_data()->active_permissions();
   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
                                           "Block parts of web pages"));
   EXPECT_TRUE(VerifyHasPermissionMessage(
       set, extension->GetType(),
       "Read and change all your data on the websites you visit"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Serial) {
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "serial.json");
@@ skipping 241 matching lines @@
     expected.clear();
 
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
     scriptable_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://*.example.com/*"));
 
     expected.insert("*.google.com");
     expected.insert("*.example.com");
 
-    scoped_refptr<const PermissionSet> perm_set(
-        new PermissionSet(empty_perms, ManifestPermissionSet(), explicit_hosts,
-                          scriptable_hosts));
-    EXPECT_EQ(expected,
-              permission_message_util::GetDistinctHosts(
-                  perm_set->effective_hosts(), true, true));
+    PermissionSet perm_set(empty_perms, ManifestPermissionSet(), explicit_hosts,
+                           scriptable_hosts);
+    EXPECT_EQ(expected, permission_message_util::GetDistinctHosts(
+                            perm_set.effective_hosts(), true, true));
   }
 
   {
     // We don't display warnings for file URLs because they are off by default.
     SCOPED_TRACE("file urls");
 
     explicit_hosts.ClearPatterns();
     expected.clear();
 
     explicit_hosts.AddPattern(
@@ skipping 88 matching lines @@
 }
 
 TEST(PermissionsTest, IsHostPrivilegeIncrease) {
   Manifest::Type type = Manifest::TYPE_EXTENSION;
   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
   ManifestPermissionSet empty_manifest_permissions;
   URLPatternSet elist1;
   URLPatternSet elist2;
   URLPatternSet slist1;
   URLPatternSet slist2;
-  scoped_refptr<const PermissionSet> set1;
-  scoped_refptr<const PermissionSet> set2;
+  scoped_ptr<const PermissionSet> set1;
+  scoped_ptr<const PermissionSet> set2;
   APIPermissionSet empty_perms;
   elist1.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
   elist1.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
 
   // Test that the host order does not matter.
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
 
-  set1 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist1, slist1);
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set1.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist1,
+                               slist1));
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
 
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 
   // Test that paths are ignored.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/*"));
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 
   // Test that RCDs are ignored.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/*"));
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 
   // Test that subdomain wildcards are handled properly.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com.hk/*"));
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   // TODO(jstritar): Does not match subdomains properly. http://crbug.com/65337
   // EXPECT_FALSE(provider->IsPrivilegeIncrease(set2, set1, type));
 
   // Test that different domains count as different hosts.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.example.org/path"));
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 
   // Test that different subdomains count as different hosts.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://mail.google.com/*"));
-  set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
-                           elist2, slist2);
+  set2.reset(new PermissionSet(empty_perms, empty_manifest_permissions, elist2,
+                               slist2));
   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_TRUE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 
   // Test that platform apps do not have host permissions increases.
   type = Manifest::TYPE_PLATFORM_APP;
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
 }
 
 TEST(PermissionsTest, GetAPIsAsStrings) {
   APIPermissionSet apis;
   URLPatternSet empty_set;
 
   apis.insert(APIPermission::kProxy);
   apis.insert(APIPermission::kBackground);
   apis.insert(APIPermission::kNotifications);
   apis.insert(APIPermission::kTab);
 
-  scoped_refptr<const PermissionSet> perm_set =
-      new PermissionSet(apis, ManifestPermissionSet(), empty_set, empty_set);
-  std::set<std::string> api_names = perm_set->GetAPIsAsStrings();
+  PermissionSet perm_set(apis, ManifestPermissionSet(), empty_set, empty_set);
+  std::set<std::string> api_names = perm_set.GetAPIsAsStrings();
 
   // The result is correct if it has the same number of elements
   // and we can convert it back to the id set.
   EXPECT_EQ(4u, api_names.size());
   EXPECT_EQ(apis,
             PermissionsInfo::GetInstance()->GetAllByName(api_names));
 }
 
 TEST(PermissionsTest, IsEmpty) {
   APIPermissionSet empty_apis;
   URLPatternSet empty_extent;
 
-  scoped_refptr<const PermissionSet> empty = new PermissionSet();
+  scoped_ptr<const PermissionSet> empty(new PermissionSet());
   EXPECT_TRUE(empty->IsEmpty());
-  scoped_refptr<const PermissionSet> perm_set;
+  scoped_ptr<const PermissionSet> perm_set;
 
-  perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
-                               empty_extent, empty_extent);
+  perm_set.reset(new PermissionSet(empty_apis, ManifestPermissionSet(),
+                                   empty_extent, empty_extent));
   EXPECT_TRUE(perm_set->IsEmpty());
 
   APIPermissionSet non_empty_apis;
   non_empty_apis.insert(APIPermission::kBackground);
-  perm_set = new PermissionSet(non_empty_apis, ManifestPermissionSet(),
-                               empty_extent, empty_extent);
+  perm_set.reset(new PermissionSet(non_empty_apis, ManifestPermissionSet(),
+                                   empty_extent, empty_extent));
   EXPECT_FALSE(perm_set->IsEmpty());
 
   // Try non standard host
   URLPatternSet non_empty_extent;
   AddPattern(&non_empty_extent, "http://www.google.com/*");
 
-  perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
-                               non_empty_extent, empty_extent);
+  perm_set.reset(new PermissionSet(empty_apis, ManifestPermissionSet(),
+                                   non_empty_extent, empty_extent));
   EXPECT_FALSE(perm_set->IsEmpty());
 
-  perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
-                               empty_extent, non_empty_extent);
+  perm_set.reset(new PermissionSet(empty_apis, ManifestPermissionSet(),
+                                   empty_extent, non_empty_extent));
   EXPECT_FALSE(perm_set->IsEmpty());
 }
 
 TEST(PermissionsTest, ImpliedPermissions) {
   URLPatternSet empty_extent;
   APIPermissionSet apis;
   apis.insert(APIPermission::kFileBrowserHandler);
   EXPECT_EQ(1U, apis.size());
 
-  scoped_refptr<const PermissionSet> perm_set;
-  perm_set = new PermissionSet(apis, ManifestPermissionSet(),
-                               empty_extent, empty_extent);
-  EXPECT_EQ(2U, perm_set->apis().size());
+  PermissionSet perm_set(apis, ManifestPermissionSet(), empty_extent,
+                         empty_extent);
+  EXPECT_EQ(2U, perm_set.apis().size());
 }
 
 TEST(PermissionsTest, SyncFileSystemPermission) {
   scoped_refptr<Extension> extension = LoadManifest(
       "permissions", "sync_file_system.json");
   APIPermissionSet apis;
   apis.insert(APIPermission::kSyncFileSystem);
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
       APIPermission::kSyncFileSystem));
   EXPECT_TRUE(
       VerifyOnePermissionMessage(extension->permissions_data(),
                                  "Store data in your Google Drive account"));
 }
 
 // Make sure that we don't crash when we're trying to show the permissions
 // even though chrome://thumb (and everything that's not chrome://favicon with
 // a chrome:// scheme) is not a valid permission.
 // More details here: crbug/246314.
 TEST(PermissionsTest, ChromeURLs) {
   URLPatternSet allowed_hosts;
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "http://www.google.com/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://favicon/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://thumb/"));
-  scoped_refptr<const PermissionSet> permissions(
-      new PermissionSet(APIPermissionSet(), ManifestPermissionSet(),
-                        allowed_hosts, URLPatternSet()));
+  PermissionSet permissions(APIPermissionSet(), ManifestPermissionSet(),
+                            allowed_hosts, URLPatternSet());
   PermissionMessageProvider::Get()->GetPermissionMessages(
       PermissionMessageProvider::Get()->GetAllPermissionIDs(
-          permissions.get(), Manifest::TYPE_EXTENSION));
+          &permissions, Manifest::TYPE_EXTENSION));
 }
 
 TEST(PermissionsTest, IsPrivilegeIncrease_DeclarativeWebRequest) {
   scoped_refptr<Extension> extension(
       LoadManifest("permissions", "permissions_all_urls.json"));
-  scoped_refptr<const PermissionSet> permissions(
-      extension->permissions_data()->active_permissions());
+  const PermissionSet* permissions =
+      extension->permissions_data()->active_permissions();
 
   scoped_refptr<Extension> extension_dwr(
       LoadManifest("permissions", "web_request_all_host_permissions.json"));
-  scoped_refptr<const PermissionSet> permissions_dwr(
-      extension_dwr->permissions_data()->active_permissions());
+  const PermissionSet* permissions_dwr =
+      extension_dwr->permissions_data()->active_permissions();
 
-  EXPECT_FALSE(PermissionMessageProvider::Get()->
-                   IsPrivilegeIncrease(permissions.get(),
-                                       permissions_dwr.get(),
-                                       extension->GetType()));
+  EXPECT_FALSE(PermissionMessageProvider::Get()->IsPrivilegeIncrease(
+      permissions, permissions_dwr, extension->GetType()));
 }
 
 }  // namespace extensions