Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

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 <memory>
+
+#include "base/memory/ptr_util.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 void AddPatternsAndRemovePaths(const URLPatternSet& set, URLPatternSet* out) {
   DCHECK(out);
@@ skipping 22 matching lines @@
       scriptable_hosts_(scriptable_hosts),
       should_warn_all_hosts_(UNINITIALIZED) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitImplicitPermissions();
   InitEffectiveHosts();
 }
 
 PermissionSet::~PermissionSet() {}
 
 // static
-scoped_ptr<const PermissionSet> PermissionSet::CreateDifference(
+std::unique_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_ptr(new PermissionSet(apis, manifest_permissions,
-                                           explicit_hosts, scriptable_hosts));
+  return base::WrapUnique(new PermissionSet(apis, manifest_permissions,
+                                            explicit_hosts, scriptable_hosts));
 }
 
 // static
-scoped_ptr<const PermissionSet> PermissionSet::CreateIntersection(
+std::unique_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 make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
-                                           explicit_hosts, scriptable_hosts));
+  return base::WrapUnique(new PermissionSet(apis, manifest_permissions,
+                                            explicit_hosts, scriptable_hosts));
 }
 
 // static
-scoped_ptr<const PermissionSet> PermissionSet::CreateUnion(
+std::unique_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 make_scoped_ptr(new PermissionSet(apis, manifest_permissions,
-                                           explicit_hosts, scriptable_hosts));
+  return base::WrapUnique(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));
+std::unique_ptr<const PermissionSet> PermissionSet::Clone() const {
+  return base::WrapUnique(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 {
@@ skipping 122 matching lines @@
     if (iter->ImpliesAllHosts()) {
       should_warn_all_hosts_ = WARN_ALL_HOSTS;
       return;
     }
   }
 
   should_warn_all_hosts_ = DONT_WARN_ALL_HOSTS;
 }
 
 }  // namespace extensions