[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 25 matching lines @@
     const URLPatternSet& scriptable_hosts)
     : apis_(apis),
       manifest_permissions_(manifest_permissions),
       scriptable_hosts_(scriptable_hosts),
       should_warn_all_hosts_(UNINITIALIZED) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitImplicitPermissions();
   InitEffectiveHosts();
 }
 
+PermissionSet::~PermissionSet() {}
+
 // 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(*this));
+}
+
 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 78 matching lines @@
 
 bool PermissionSet::HasEffectiveFullAccess() const {
   for (APIPermissionSet::const_iterator i = apis().begin();
        i != apis().end(); ++i) {
     if (i->info()->implies_full_access())
       return true;
   }
   return false;
 }
 
-PermissionSet::~PermissionSet() {}
+PermissionSet::PermissionSet(const PermissionSet& permissions)
+    : apis_(permissions.apis_),
+      manifest_permissions_(permissions.manifest_permissions_),
+      explicit_hosts_(permissions.explicit_hosts_),
+      scriptable_hosts_(permissions.scriptable_hosts_),
+      effective_hosts_(permissions.effective_hosts_),
+      should_warn_all_hosts_(permissions.should_warn_all_hosts_) {}
 
 void PermissionSet::InitImplicitPermissions() {
   // The downloads permission implies the internal version as well.
   if (apis_.find(APIPermission::kDownloads) != apis_.end())
     apis_.insert(APIPermission::kDownloadsInternal);
 
   // The fileBrowserHandler permission implies the internal version as well.
   if (apis_.find(APIPermission::kFileBrowserHandler) != apis_.end())
     apis_.insert(APIPermission::kFileBrowserHandlerInternal);
 }
@@ skipping 15 matching lines @@
     if (iter->ImpliesAllHosts()) {
       should_warn_all_hosts_ = WARN_ALL_HOSTS;
       return;
     }
   }
 
   should_warn_all_hosts_ = DONT_WARN_ALL_HOSTS;
 }
 
 }  // namespace extensions