Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/permissions/permissions_api.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 "chrome/browser/extensions/api/permissions/permissions_api.h"
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api_helpers.h"
 #include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/permissions.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/permissions_parser.h"
@@ skipping 28 matching lines @@
   DO_NOT_SKIP = 0,
   PROCEED,
   ABORT
 };
 AutoConfirmForTest auto_confirm_for_tests = DO_NOT_SKIP;
 bool ignore_user_gesture_for_tests = false;
 
 }  // namespace
 
 bool PermissionsContainsFunction::RunSync() {
-  scoped_ptr<Contains::Params> params(Contains::Params::Create(*args_));
+  std::unique_ptr<Contains::Params> params(Contains::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  scoped_ptr<const PermissionSet> permissions = helpers::UnpackPermissionSet(
-      params->permissions,
-      ExtensionPrefs::Get(GetProfile())->AllowFileAccess(extension_->id()),
-      &error_);
+  std::unique_ptr<const PermissionSet> permissions =
+      helpers::UnpackPermissionSet(
+          params->permissions,
+          ExtensionPrefs::Get(GetProfile())->AllowFileAccess(extension_->id()),
+          &error_);
   if (!permissions.get())
     return false;
 
   results_ = Contains::Results::Create(
       extension()->permissions_data()->active_permissions().Contains(
           *permissions));
   return true;
 }
 
 bool PermissionsGetAllFunction::RunSync() {
-  scoped_ptr<Permissions> permissions = helpers::PackPermissionSet(
+  std::unique_ptr<Permissions> permissions = helpers::PackPermissionSet(
       extension()->permissions_data()->active_permissions());
   results_ = GetAll::Results::Create(*permissions);
   return true;
 }
 
 bool PermissionsRemoveFunction::RunSync() {
-  scoped_ptr<Remove::Params> params(Remove::Params::Create(*args_));
+  std::unique_ptr<Remove::Params> params(Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  scoped_ptr<const PermissionSet> permissions = helpers::UnpackPermissionSet(
-      params->permissions,
-      ExtensionPrefs::Get(GetProfile())->AllowFileAccess(extension_->id()),
-      &error_);
+  std::unique_ptr<const PermissionSet> permissions =
+      helpers::UnpackPermissionSet(
+          params->permissions,
+          ExtensionPrefs::Get(GetProfile())->AllowFileAccess(extension_->id()),
+          &error_);
   if (!permissions.get())
     return false;
 
   // Make sure they're only trying to remove permissions supported by this API.
   APIPermissionSet apis = permissions->apis();
   for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     if (!i->info()->supports_optional()) {
       error_ = ErrorUtils::FormatErrorMessage(
           kNotWhitelistedError, i->name());
       return false;
     }
   }
 
   // Make sure we only remove optional permissions, and not required
   // permissions. Sadly, for some reason we support having a permission be both
   // optional and required (and should assume its required), so we need both of
   // these checks.
   // TODO(devlin): *Why* do we support that? Should be a load error.
   const PermissionSet& optional =
       PermissionsParser::GetOptionalPermissions(extension());
   const PermissionSet& required =
       PermissionsParser::GetRequiredPermissions(extension());
   if (!optional.Contains(*permissions) ||
-      !scoped_ptr<const PermissionSet>(
+      !std::unique_ptr<const PermissionSet>(
            PermissionSet::CreateIntersection(*permissions, required))
            ->IsEmpty()) {
     error_ = kCantRemoveRequiredPermissionsError;
     return false;
   }
 
   // Only try and remove those permissions that are active on the extension.
   // For backwards compatability with behavior before this check was added, just
   // silently remove any that aren't present.
   permissions = PermissionSet::CreateIntersection(
@@ skipping 24 matching lines @@
 bool PermissionsRequestFunction::RunAsync() {
   results_ = Request::Results::Create(false);
 
   if (!user_gesture() &&
       !ignore_user_gesture_for_tests &&
       extension_->location() != Manifest::COMPONENT) {
     error_ = kUserGestureRequiredError;
     return false;
   }
 
-  scoped_ptr<Request::Params> params(Request::Params::Create(*args_));
+  std::unique_ptr<Request::Params> params(Request::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   requested_permissions_ = helpers::UnpackPermissionSet(
       params->permissions,
       ExtensionPrefs::Get(GetProfile())->AllowFileAccess(extension_->id()),
       &error_);
   if (!requested_permissions_.get())
     return false;
 
   // Make sure they're only requesting permissions supported by this API.
@@ skipping 17 matching lines @@
   // Automatically declines api permissions requests, which are blocked by
   // enterprise policy.
   if (!ExtensionManagementFactory::GetForBrowserContext(GetProfile())
            ->IsPermissionSetAllowed(extension(), *requested_permissions_)) {
     error_ = kBlockedByEnterprisePolicy;
     return false;
   }
 
   // We don't need to prompt the user if the requested permissions are a subset
   // of the granted permissions set.
-  scoped_ptr<const PermissionSet> granted =
+  std::unique_ptr<const PermissionSet> granted =
       ExtensionPrefs::Get(GetProfile())
           ->GetGrantedPermissions(extension()->id());
   if (granted.get() && granted->Contains(*requested_permissions_)) {
     PermissionsUpdater perms_updater(GetProfile());
     perms_updater.AddPermissions(extension(), *requested_permissions_);
     results_ = Request::Results::Create(true);
     SendResponse(true);
     return true;
   }
 
@@ skipping 23 matching lines @@
     OnInstallPromptDone(ExtensionInstallPrompt::Result::ACCEPTED);
   } else if (auto_confirm_for_tests == ABORT) {
     // Pretend the user clicked cancel.
     OnInstallPromptDone(ExtensionInstallPrompt::Result::USER_CANCELED);
   } else {
     CHECK_EQ(DO_NOT_SKIP, auto_confirm_for_tests);
     install_ui_.reset(new ExtensionInstallPrompt(GetAssociatedWebContents()));
     install_ui_->ShowDialog(
         base::Bind(&PermissionsRequestFunction::OnInstallPromptDone, this),
         extension(), nullptr,
-        make_scoped_ptr(new ExtensionInstallPrompt::Prompt(
+        base::WrapUnique(new ExtensionInstallPrompt::Prompt(
             ExtensionInstallPrompt::PERMISSIONS_PROMPT)),
         requested_permissions_->Clone(),
         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
 
   return true;
 }
 
 void PermissionsRequestFunction::OnInstallPromptDone(
     ExtensionInstallPrompt::Result result) {
   if (result == ExtensionInstallPrompt::Result::ACCEPTED) {
     PermissionsUpdater perms_updater(GetProfile());
     perms_updater.AddPermissions(extension(), *requested_permissions_);
 
     results_ = Request::Results::Create(true);
   }
 
   SendResponse(true);
   Release();  // Balanced in RunAsync().
 }
 
 }  // namespace extensions