[Extensions] Un-refcount PermissionSet

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 "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 138 matching lines @@
 
  private:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
     received_notification_ = true;
     UpdatedExtensionPermissionsInfo* info =
         content::Details<UpdatedExtensionPermissionsInfo>(details).ptr();
 
     extension_ = info->extension;
-    permissions_ = info->permissions;
+    permissions_ = info->permissions.Clone();
     reason_ = info->reason;
 
     if (waiting_) {
       waiting_ = false;
       base::MessageLoopForUI::current()->Quit();
     }
   }
 
   bool received_notification_;
   bool waiting_;
   content::NotificationRegistrar registrar_;
   scoped_refptr<const Extension> extension_;
-  scoped_refptr<const PermissionSet> permissions_;
+  scoped_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 20 matching lines @@
   // Load the test extension.
   scoped_refptr<Extension> extension = LoadOurManifest();
   ASSERT_TRUE(extension.get());
 
   APIPermissionSet default_apis;
   default_apis.insert(APIPermission::kManagement);
   ManifestPermissionSet empty_manifest_permissions;
 
   URLPatternSet default_hosts;
   AddPattern(&default_hosts, "http://a.com/*");
-  scoped_refptr<const PermissionSet> default_permissions = new PermissionSet(
-      default_apis, empty_manifest_permissions, default_hosts, URLPatternSet());
+  PermissionSet default_permissions(default_apis, empty_manifest_permissions,
+                                    default_hosts, URLPatternSet());
 
   // Make sure it loaded properly.
-  scoped_refptr<const PermissionSet> permissions =
-      extension->permissions_data()->active_permissions();
-  ASSERT_EQ(*default_permissions.get(),
-            *extension->permissions_data()->active_permissions().get());
+  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;
 
   // Add a few permissions.
   APIPermissionSet apis;
   apis.insert(APIPermission::kNotifications);
   URLPatternSet hosts;
   AddPattern(&hosts, "http://*.c.com/*");
 
-  scoped_refptr<const PermissionSet> delta = new PermissionSet(
-      apis, empty_manifest_permissions, hosts, URLPatternSet());
+  {
+    PermissionSet delta(apis, empty_manifest_permissions, hosts,
+                        URLPatternSet());
 
   PermissionsUpdaterListener listener;
-  PermissionsUpdater updater(profile_.get());
-  updater.AddPermissions(extension.get(), delta.get());
+  PermissionsUpdater(profile_.get()).AddPermissions(extension.get(), &delta);
 
   listener.Wait();
 
   // Verify that the permission notification was sent correctly.
   ASSERT_TRUE(listener.received_notification());
   ASSERT_EQ(extension.get(), listener.extension());
   ASSERT_EQ(UpdatedExtensionPermissionsInfo::ADDED, listener.reason());
-  ASSERT_EQ(*delta.get(), *listener.permissions());
+  ASSERT_EQ(delta, *listener.permissions());
 
   // Make sure the extension's active permissions reflect the change.
-  scoped_refptr<const PermissionSet> active_permissions =
-      PermissionSet::CreateUnion(*default_permissions, *delta);
+  active_permissions = PermissionSet::CreateUnion(default_permissions, delta);
   ASSERT_EQ(*active_permissions.get(),
-            *extension->permissions_data()->active_permissions().get());
+            *extension->permissions_data()->active_permissions());
 
   // Verify that the new granted and active permissions were also stored
   // in the extension preferences. In this case, the granted permissions should
   // be equal to the active permissions.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
-  scoped_refptr<const PermissionSet> granted_permissions = active_permissions;
+  ASSERT_EQ(*active_permissions.get(),
+            *prefs->GetActivePermissions(extension->id()));
+  granted_permissions = active_permissions->Clone();
+  ASSERT_EQ(*granted_permissions,
+            *prefs->GetGrantedPermissions(extension->id()));
+  }
 
-  scoped_refptr<const PermissionSet> from_prefs =
-      prefs->GetActivePermissions(extension->id());
-  ASSERT_EQ(*active_permissions.get(), *from_prefs.get());
-
-  from_prefs = prefs->GetGrantedPermissions(extension->id());
-  ASSERT_EQ(*active_permissions.get(), *from_prefs.get());
-
+  {
   // In the second part of the test, we'll remove the permissions that we
   // just added except for 'notifications'.
   apis.erase(APIPermission::kNotifications);
-  delta = new PermissionSet(apis, empty_manifest_permissions,
-                            hosts, URLPatternSet());
+  PermissionSet delta(apis, empty_manifest_permissions, hosts, URLPatternSet());
 
-  listener.Reset();
-  updater.RemovePermissions(extension.get(), delta.get(),
-                            PermissionsUpdater::REMOVE_SOFT);
+  PermissionsUpdaterListener listener;
+  PermissionsUpdater(profile_.get())
+      .RemovePermissions(extension.get(), &delta,
+                         PermissionsUpdater::REMOVE_SOFT);
   listener.Wait();
 
   // Verify that the notification was correct.
   ASSERT_TRUE(listener.received_notification());
   ASSERT_EQ(extension.get(), listener.extension());
   ASSERT_EQ(UpdatedExtensionPermissionsInfo::REMOVED, listener.reason());
-  ASSERT_EQ(*delta.get(), *listener.permissions());
+  ASSERT_EQ(delta, *listener.permissions());
 
   // Make sure the extension's active permissions reflect the change.
   active_permissions =
-      PermissionSet::CreateDifference(*active_permissions, *delta);
+      PermissionSet::CreateDifference(*active_permissions, delta);
   ASSERT_EQ(*active_permissions.get(),
-            *extension->permissions_data()->active_permissions().get());
+            *extension->permissions_data()->active_permissions());
 
   // Verify that the extension prefs hold the new active permissions and the
   // same granted permissions.
-  from_prefs = prefs->GetActivePermissions(extension->id());
-  ASSERT_EQ(*active_permissions.get(), *from_prefs.get());
+  ASSERT_EQ(*active_permissions, *prefs->GetActivePermissions(extension->id()));
 
-  from_prefs = prefs->GetGrantedPermissions(extension->id());
-  ASSERT_EQ(*granted_permissions.get(), *from_prefs.get());
+  ASSERT_EQ(*granted_permissions,
+            *prefs->GetGrantedPermissions(extension->id()));
+  }
 }
 
 TEST_F(PermissionsUpdaterTest, WithholdAllHosts) {
   InitializeEmptyExtensionService();
 
   // Permissions are only withheld with the appropriate switch turned on.
   scoped_ptr<FeatureSwitch::ScopedOverride> switch_override(
       new FeatureSwitch::ScopedOverride(FeatureSwitch::scripts_require_action(),
                                         FeatureSwitch::OVERRIDE_ENABLED));
 
@@ skipping 186 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_refptr(new PermissionSet(
-        apis, ManifestPermissionSet(), URLPatternSet(), URLPatternSet()));
+    return make_scoped_ptr(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_refptr(new PermissionSet(
+    return make_scoped_ptr(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).get());
     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_refptr<const PermissionSet> granted_permissions =
+    scoped_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).get());
     EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kTab));
     granted_permissions = prefs->GetGrantedPermissions(extension->id());
@@ skipping 71 matching lines @@
                      ->active_permissions()
                      ->HasExplicitAccessToOrigin(kOrigin));
     EXPECT_TRUE(extension->permissions_data()
                     ->withheld_permissions()
                     ->HasExplicitAccessToOrigin(kOrigin));
     EXPECT_TRUE(updater.GetRevokablePermissions(extension.get())->IsEmpty());
   }
 }
 
 }  // namespace extensions