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

chrome/browser/extensions/api/webstore_private/webstore_private_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/webstore_private/webstore_private_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
 namespace SetStoreLogin = api::webstore_private::SetStoreLogin;
 
 namespace {
 
 // Holds the Approvals between the time we prompt and start the installs.
 class PendingApprovals {
  public:
   PendingApprovals();
   ~PendingApprovals();
 
-  void PushApproval(scoped_ptr<WebstoreInstaller::Approval> approval);
-  scoped_ptr<WebstoreInstaller::Approval> PopApproval(
-      Profile* profile, const std::string& id);
+  void PushApproval(std::unique_ptr<WebstoreInstaller::Approval> approval);
+  std::unique_ptr<WebstoreInstaller::Approval> PopApproval(
+      Profile* profile,
+      const std::string& id);
+
  private:
   typedef ScopedVector<WebstoreInstaller::Approval> ApprovalList;
 
   ApprovalList approvals_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingApprovals);
 };
 
 PendingApprovals::PendingApprovals() {}
 PendingApprovals::~PendingApprovals() {}
 
 void PendingApprovals::PushApproval(
-    scoped_ptr<WebstoreInstaller::Approval> approval) {
+    std::unique_ptr<WebstoreInstaller::Approval> approval) {
   approvals_.push_back(approval.release());
 }
 
-scoped_ptr<WebstoreInstaller::Approval> PendingApprovals::PopApproval(
-    Profile* profile, const std::string& id) {
+std::unique_ptr<WebstoreInstaller::Approval> PendingApprovals::PopApproval(
+    Profile* profile,
+    const std::string& id) {
   for (size_t i = 0; i < approvals_.size(); ++i) {
     WebstoreInstaller::Approval* approval = approvals_[i];
     if (approval->extension_id == id &&
         profile->IsSameProfile(approval->profile)) {
       approvals_.weak_erase(approvals_.begin() + i);
-      return scoped_ptr<WebstoreInstaller::Approval>(approval);
+      return std::unique_ptr<WebstoreInstaller::Approval>(approval);
     }
   }
-  return scoped_ptr<WebstoreInstaller::Approval>();
+  return std::unique_ptr<WebstoreInstaller::Approval>();
 }
 
 api::webstore_private::Result WebstoreInstallHelperResultToApiResult(
     WebstoreInstallHelper::Delegate::InstallHelperResultCode result) {
   switch (result) {
     case WebstoreInstallHelper::Delegate::UNKNOWN_ERROR:
       return api::webstore_private::RESULT_UNKNOWN_ERROR;
     case WebstoreInstallHelper::Delegate::ICON_ERROR:
       return api::webstore_private::RESULT_ICON_ERROR;
     case WebstoreInstallHelper::Delegate::MANIFEST_ERROR:
@@ skipping 47 matching lines @@
 
 }  // namespace
 
 // static
 void WebstorePrivateApi::SetWebstoreInstallerDelegateForTesting(
     WebstoreInstaller::Delegate* delegate) {
   test_webstore_installer_delegate = delegate;
 }
 
 // static
-scoped_ptr<WebstoreInstaller::Approval>
-WebstorePrivateApi::PopApprovalForTesting(
-    Profile* profile, const std::string& extension_id) {
+std::unique_ptr<WebstoreInstaller::Approval>
+WebstorePrivateApi::PopApprovalForTesting(Profile* profile,
+                                          const std::string& extension_id) {
   return g_pending_approvals.Get().PopApproval(profile, extension_id);
 }
 
 WebstorePrivateBeginInstallWithManifest3Function::
     WebstorePrivateBeginInstallWithManifest3Function() : chrome_details_(this) {
 }
 
 WebstorePrivateBeginInstallWithManifest3Function::
     ~WebstorePrivateBeginInstallWithManifest3Function() {
 }
@@ skipping 131 matching lines @@
   }
 
   // Matches the AddRef in Run().
   Release();
 }
 
 void WebstorePrivateBeginInstallWithManifest3Function::HandleInstallProceed() {
   // This gets cleared in CrxInstaller::ConfirmInstall(). TODO(asargent) - in
   // the future we may also want to add time-based expiration, where a whitelist
   // entry is only valid for some number of minutes.
-  scoped_ptr<WebstoreInstaller::Approval> approval(
+  std::unique_ptr<WebstoreInstaller::Approval> approval(
       WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
           chrome_details_.GetProfile(), details().id,
           std::move(parsed_manifest_), false));
   approval->use_app_installed_bubble = !!details().app_install_bubble;
   approval->enable_launcher = !!details().enable_launcher;
   // If we are enabling the launcher, we should not show the app list in order
   // to train the user to open it themselves at least once.
   approval->skip_post_install_ui = !!details().enable_launcher;
   approval->dummy_extension = dummy_extension_.get();
   approval->installing_icon = gfx::ImageSkia::CreateFrom1xBitmap(icon_);
@@ skipping 36 matching lines @@
     api::webstore_private::Result result, const std::string& error) {
   if (result != api::webstore_private::RESULT_SUCCESS)
     return ErrorWithArguments(CreateResults(result), error);
 
   // The web store expects an empty string on success, so don't use
   // RESULT_SUCCESS here.
   return ArgumentList(
       CreateResults(api::webstore_private::RESULT_EMPTY_STRING));
 }
 
-scoped_ptr<base::ListValue>
+std::unique_ptr<base::ListValue>
 WebstorePrivateBeginInstallWithManifest3Function::CreateResults(
     api::webstore_private::Result result) const {
   return BeginInstallWithManifest3::Results::Create(result);
 }
 
 WebstorePrivateCompleteInstallFunction::
     WebstorePrivateCompleteInstallFunction() : chrome_details_(this) {}
 
 WebstorePrivateCompleteInstallFunction::
     ~WebstorePrivateCompleteInstallFunction() {}
 
 ExtensionFunction::ResponseAction
 WebstorePrivateCompleteInstallFunction::Run() {
-  scoped_ptr<CompleteInstall::Params> params(
+  std::unique_ptr<CompleteInstall::Params> params(
       CompleteInstall::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   if (chrome_details_.GetProfile()->IsGuestSession() ||
       chrome_details_.GetProfile()->IsOffTheRecord()) {
     return RespondNow(Error(kIncognitoError));
   }
 
   if (!crx_file::id_util::IdIsValid(params->expected_id))
     return RespondNow(Error(kInvalidIdError));
 
@@ skipping 214 matching lines @@
       GetWebstoreLogin(chrome_details_.GetProfile()))));
 }
 
 WebstorePrivateSetStoreLoginFunction::
     WebstorePrivateSetStoreLoginFunction() : chrome_details_(this) {}
 
 WebstorePrivateSetStoreLoginFunction::
     ~WebstorePrivateSetStoreLoginFunction() {}
 
 ExtensionFunction::ResponseAction WebstorePrivateSetStoreLoginFunction::Run() {
-  scoped_ptr<SetStoreLogin::Params> params(
+  std::unique_ptr<SetStoreLogin::Params> params(
       SetStoreLogin::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   SetWebstoreLogin(chrome_details_.GetProfile(), params->login);
   return RespondNow(NoArguments());
 }
 
 WebstorePrivateGetWebGLStatusFunction::WebstorePrivateGetWebGLStatusFunction()
   : feature_checker_(new GPUFeatureChecker(
         gpu::GPU_FEATURE_TYPE_WEBGL,
         base::Bind(&WebstorePrivateGetWebGLStatusFunction::OnFeatureCheck,
@@ skipping 58 matching lines @@
 WebstorePrivateGetEphemeralAppsEnabledFunction::
     ~WebstorePrivateGetEphemeralAppsEnabledFunction() {}
 
 ExtensionFunction::ResponseAction
 WebstorePrivateGetEphemeralAppsEnabledFunction::Run() {
   return RespondNow(ArgumentList(GetEphemeralAppsEnabled::Results::Create(
       false)));
 }
 
 }  // namespace extensions