[Extensions] Un-refcount PermissionSet

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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 774 matching lines @@
       "}";
     gpu::GPUInfo gpu_info;
     content::GpuDataManager::GetInstance()->InitializeForTesting(
         json_blacklist, gpu_info);
   }
 
   // Grants all optional permissions stated in manifest to active permission
   // set for extension |id|.
   void GrantAllOptionalPermissions(const std::string& id) {
     const Extension* extension = service()->GetInstalledExtension(id);
-    scoped_refptr<const PermissionSet> all_optional_permissions =
+    const PermissionSet* all_optional_permissions =
         extensions::PermissionsParser::GetOptionalPermissions(extension);
     extensions::PermissionsUpdater perms_updater(profile());
-    perms_updater.AddPermissions(extension, all_optional_permissions.get());
+    perms_updater.AddPermissions(extension, all_optional_permissions);
   }
 
   // Helper method to set up a WindowedNotificationObserver to wait for a
   // specific CrxInstaller to finish if we don't know the value of the
   // |installer| yet.
   static bool IsCrxInstallerDone(extensions::CrxInstaller** installer,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
     return content::Source<extensions::CrxInstaller>(source).ptr() ==
            *installer;
@@ skipping 1035 matching lines @@
   ASSERT_TRUE(base::PathExists(pem_path));
   ASSERT_TRUE(base::PathExists(path));
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
-  scoped_refptr<const PermissionSet> known_perms(
-      prefs->GetGrantedPermissions(permissions_crx));
-  EXPECT_FALSE(known_perms.get());
+  EXPECT_FALSE(prefs->GetGrantedPermissions(permissions_crx).get());
 
   const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
 
   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);
 
   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/*");
 
-  known_perms = prefs->GetGrantedPermissions(extension->id());
+  scoped_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)
 // This tests that the granted permissions preferences are correctly set for
 // default apps.
 TEST_F(ExtensionServiceTest, DefaultAppsGrantedPermissions) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("permissions");
 
   base::FilePath pem_path = path.AppendASCII("unknown.pem");
   path = path.AppendASCII("unknown");
 
   ASSERT_TRUE(base::PathExists(pem_path));
   ASSERT_TRUE(base::PathExists(path));
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
-  scoped_refptr<const PermissionSet> known_perms(
-      prefs->GetGrantedPermissions(permissions_crx));
-  EXPECT_FALSE(known_perms.get());
+  EXPECT_FALSE(prefs->GetGrantedPermissions(permissions_crx).get());
 
   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);
 
-  known_perms = prefs->GetGrantedPermissions(extension->id());
+  scoped_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_refptr<const PermissionSet> permissions(
-      prefs->GetGrantedPermissions(extension->id()));
+  scoped_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 41 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_refptr<const PermissionSet> current_perms(
-      prefs->GetGrantedPermissions(extension_id));
+  scoped_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
   // permissions).
@@ skipping 873 matching lines @@
       ->Load(extension_with_plugin_path);
   base::RunLoop().RunUntilIdle();
   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_refptr<const PermissionSet> permissions(
-      ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1));
+  scoped_ptr<const PermissionSet> permissions =
+      ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1);
   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();
   auto_confirm.reset(new extensions::ScopedTestDialogAutoConfirm(
       extensions::ScopedTestDialogAutoConfirm::CANCEL));
@@ skipping 1367 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_refptr<const PermissionSet> active_permissions(
-      ExtensionPrefs::Get(profile())->GetActivePermissions(ext1));
+  scoped_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");
   }
 
   base::RunLoop().RunUntilIdle();
@@ skipping 2312 matching lines @@
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     syncer::SyncChangeList list(1, sync_change);
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     ASSERT_TRUE(service()->pending_extension_manager()->IsIdPending(good_crx));
     UpdateExtension(good_crx, path, test_case.sync_enabled ? ENABLED
                                                            : DISABLED);
     EXPECT_EQ(test_case.expect_disable_reasons,
               prefs->GetDisableReasons(good_crx));
-    scoped_refptr<const PermissionSet> permissions(
-        prefs->GetGrantedPermissions(good_crx));
+    scoped_ptr<const PermissionSet> permissions =
+        prefs->GetGrantedPermissions(good_crx);
     EXPECT_EQ(test_case.expect_permissions_granted, !permissions->IsEmpty());
     ASSERT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
 
     // Remove the extension again, so we can install it again for the next case.
     UninstallExtension(good_crx, false,
                        test_case.sync_enabled ? Extension::ENABLED
                                               : Extension::DISABLED);
   }
 }
 
@@ skipping 323 matching lines @@
     // during updating).
     {
       const Extension* extension = InstallCRX(crx_path_v1, INSTALL_NEW);
       // The extension should now be installed and enabled.
       ASSERT_TRUE(extension);
       ASSERT_EQ(v1, extension->VersionString());
       id = extension->id();
     }
     ASSERT_TRUE(registry()->enabled_extensions().Contains(id));
 
-    scoped_refptr<const PermissionSet> granted_permissions_v1(
-        prefs->GetGrantedPermissions(id));
+    scoped_ptr<const PermissionSet> granted_permissions_v1 =
+        prefs->GetGrantedPermissions(id);
 
     // Update to a new version with increased permissions.
     UpdateExtension(id, crx_path_v2, DISABLED);
 
     // Now the extension should be disabled due to a permissions increase.
     {
       const Extension* extension =
           registry()->disabled_extensions().GetByID(id);
       ASSERT_TRUE(extension);
       ASSERT_EQ(v2, extension->VersionString());
     }
     ASSERT_TRUE(prefs->HasDisableReason(
         id, Extension::DISABLE_PERMISSIONS_INCREASE));
 
     // No new permissions should have been granted.
-    scoped_refptr<const PermissionSet> granted_permissions_v2(
-        prefs->GetGrantedPermissions(id));
+    scoped_ptr<const PermissionSet> granted_permissions_v2 =
+        prefs->GetGrantedPermissions(id);
     ASSERT_EQ(*granted_permissions_v1, *granted_permissions_v2);
 
     // Now a sync update comes in.
     sync_pb::EntitySpecifics specifics;
     sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
     ext_specifics->set_id(id);
     ext_specifics->set_enabled(true);
     ext_specifics->set_version(test_case.sync_version);
     if (test_case.sync_disable_reasons != -1)
       ext_specifics->set_disable_reasons(test_case.sync_disable_reasons);
 
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     syncer::SyncChangeList list(1, sync_change);
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     // Check expectations.
     EXPECT_TRUE(registry()->GetExtensionById(id, ExtensionRegistry::ENABLED));
-    scoped_refptr<const PermissionSet> granted_permissions(
-        prefs->GetGrantedPermissions(id));
+    scoped_ptr<const PermissionSet> granted_permissions =
+        prefs->GetGrantedPermissions(id);
     if (test_case.expect_permissions_granted) {
-      scoped_refptr<const PermissionSet> active_permissions(
-          prefs->GetActivePermissions(id));
+      scoped_ptr<const PermissionSet> active_permissions =
+          prefs->GetActivePermissions(id);
       EXPECT_EQ(*granted_permissions, *active_permissions);
     } else {
       EXPECT_EQ(*granted_permissions, *granted_permissions_v1);
     }
     EXPECT_EQ(Extension::DISABLE_NONE, prefs->GetDisableReasons(id));
 
     // Remove the extension again, so we can install it again for the next case.
     UninstallExtension(id, false);
   }
 }
@@ skipping 1154 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());
 }