[Extensions] Un-refcount PermissionSet

extensions/common/permissions/permission_set.cc

 // Copyright 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 "extensions/common/permissions/permission_set.h"
 
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
 #include "url/gurl.h"
 
@@ skipping 26 matching lines @@
     : apis_(apis),
       manifest_permissions_(manifest_permissions),
       scriptable_hosts_(scriptable_hosts),
       should_warn_all_hosts_(UNINITIALIZED) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitImplicitPermissions();
   InitEffectiveHosts();
 }
 
 // static
-scoped_refptr<const PermissionSet> PermissionSet::CreateDifference(
+scoped_ptr<const PermissionSet> PermissionSet::CreateDifference(
     const PermissionSet& set1,
     const PermissionSet& set2) {
   APIPermissionSet apis;
   APIPermissionSet::Difference(set1.apis(), set2.apis(), &apis);
 
   ManifestPermissionSet manifest_permissions;
   ManifestPermissionSet::Difference(set1.manifest_permissions(),
                                     set2.manifest_permissions(),
                                     &manifest_permissions);
 
   URLPatternSet explicit_hosts = URLPatternSet::CreateDifference(
       set1.explicit_hosts(), set2.explicit_hosts());
 
   URLPatternSet scriptable_hosts = URLPatternSet::CreateDifference(
       set1.scriptable_hosts(), set2.scriptable_hosts());
 
-  return make_scoped_refptr(new PermissionSet(
-      apis, manifest_permissions, explicit_hosts, scriptable_hosts));
+  return make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
+                                           explicit_hosts, scriptable_hosts));
 }
 
 // static
-scoped_refptr<const PermissionSet> PermissionSet::CreateIntersection(
+scoped_ptr<const PermissionSet> PermissionSet::CreateIntersection(
     const PermissionSet& set1,
     const PermissionSet& set2) {
   APIPermissionSet apis;
   APIPermissionSet::Intersection(set1.apis(), set2.apis(), &apis);
 
   ManifestPermissionSet manifest_permissions;
   ManifestPermissionSet::Intersection(set1.manifest_permissions(),
                                       set2.manifest_permissions(),
                                       &manifest_permissions);
 
   URLPatternSet explicit_hosts = URLPatternSet::CreateSemanticIntersection(
       set1.explicit_hosts(), set2.explicit_hosts());
   URLPatternSet scriptable_hosts = URLPatternSet::CreateSemanticIntersection(
       set1.scriptable_hosts(), set2.scriptable_hosts());
 
-  return new PermissionSet(apis, manifest_permissions,
-                           explicit_hosts, scriptable_hosts);
+  return make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
+                                           explicit_hosts, scriptable_hosts));
 }
 
 // static
-scoped_refptr<const PermissionSet> PermissionSet::CreateUnion(
+scoped_ptr<const PermissionSet> PermissionSet::CreateUnion(
     const PermissionSet& set1,
     const PermissionSet& set2) {
   APIPermissionSet apis;
   APIPermissionSet::Union(set1.apis(), set2.apis(), &apis);
 
   ManifestPermissionSet manifest_permissions;
   ManifestPermissionSet::Union(set1.manifest_permissions(),
                                set2.manifest_permissions(),
                                &manifest_permissions);
 
   URLPatternSet explicit_hosts =
       URLPatternSet::CreateUnion(set1.explicit_hosts(), set2.explicit_hosts());
 
   URLPatternSet scriptable_hosts = URLPatternSet::CreateUnion(
       set1.scriptable_hosts(), set2.scriptable_hosts());
 
-  return new PermissionSet(apis, manifest_permissions,
-                           explicit_hosts, scriptable_hosts);
+  return make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
+                                           explicit_hosts, scriptable_hosts));
 }
 
 bool PermissionSet::operator==(
     const PermissionSet& rhs) const {
   return apis_ == rhs.apis_ &&
       manifest_permissions_ == rhs.manifest_permissions_ &&
       scriptable_hosts_ == rhs.scriptable_hosts_ &&
       explicit_hosts_ == rhs.explicit_hosts_;
 }
 
 bool PermissionSet::operator!=(const PermissionSet& rhs) const {
   return !(*this == rhs);
 }
 
+scoped_ptr<const PermissionSet> PermissionSet::Clone() const {
+  return make_scoped_ptr(new PermissionSet(apis_, manifest_permissions_,
+                                           explicit_hosts_, scriptable_hosts_));

[not at google - send to devlin, 2015/09/22 21:51:26]

It would be good to copy the should_warn_all_hosts_ flag as well. With respect
to the other Clone() comment, how about adding a private copy constructor, and
then making this method simply "return make_scoped_ptr(new
PermissionSet(this))"?

[Devlin, 2015/09/23 17:08:59]

I like it.  Done.

+}
+
 bool PermissionSet::Contains(const PermissionSet& set) const {
   return apis_.Contains(set.apis()) &&
          manifest_permissions_.Contains(set.manifest_permissions()) &&
          explicit_hosts().Contains(set.explicit_hosts()) &&
          scriptable_hosts().Contains(set.scriptable_hosts());
 }
 
 std::set<std::string> PermissionSet::GetAPIsAsStrings() const {
   std::set<std::string> apis_str;
   for (APIPermissionSet::const_iterator i = apis_.begin();
@@ skipping 114 matching lines @@
     if (iter->ImpliesAllHosts()) {
       should_warn_all_hosts_ = WARN_ALL_HOSTS;
       return;
     }
   }
 
   should_warn_all_hosts_ = DONT_WARN_ALL_HOSTS;
 }
 
 }  // namespace extensions