chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/password_store_factory.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/password_manager/password_store_factory.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/environment.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/sync_start_util.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/web_data_service_factory.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 121 matching lines @@
 #endif
 
 scoped_refptr<RefcountedKeyedService>
 PasswordStoreFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
 #if defined(OS_WIN)
   password_manager_util_win::DelayReportOsPassword();
 #endif
   Profile* profile = static_cast<Profile*>(context);
 
-  scoped_ptr<password_manager::LoginDatabase> login_db(
+  std::unique_ptr<password_manager::LoginDatabase> login_db(
       password_manager::CreateLoginDatabase(profile->GetPath()));
 
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner(
       base::ThreadTaskRunnerHandle::Get());
   scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner(
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::DB));
 
   scoped_refptr<PasswordStore> ps;
 #if defined(OS_WIN)
   ps = new PasswordStoreWin(main_thread_runner, db_thread_runner,
                             std::move(login_db),
                             WebDataServiceFactory::GetPasswordWebDataForProfile(
                                 profile, ServiceAccessType::EXPLICIT_ACCESS));
 #elif defined(OS_MACOSX)
-  scoped_ptr<crypto::AppleKeychain> keychain(
+  std::unique_ptr<crypto::AppleKeychain> keychain(
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           os_crypt::switches::kUseMockKeychain)
           ? new crypto::MockAppleKeychain()
           : new crypto::AppleKeychain());
   ps = new PasswordStoreProxyMac(main_thread_runner, std::move(keychain),
                                  std::move(login_db), profile->GetPrefs());
 #elif defined(OS_CHROMEOS) || defined(OS_ANDROID)
   // For now, we use PasswordStoreDefault. We might want to make a native
   // backend for PasswordStoreX (see below) in the future though.
   ps = new password_manager::PasswordStoreDefault(
@@ skipping 20 matching lines @@
     // Detect the store to use automatically.
     used_desktop_env = desktop_env;
     const char* name = base::nix::GetDesktopEnvironmentName(desktop_env);
     VLOG(1) << "Password storage detected desktop environment: "
             << (name ? name : "(unknown)");
   }
 
   PrefService* prefs = profile->GetPrefs();
   LocalProfileId id = GetLocalProfileId(prefs);
 
-  scoped_ptr<PasswordStoreX::NativeBackend> backend;
+  std::unique_ptr<PasswordStoreX::NativeBackend> backend;
   if (used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4 ||
       used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
     // KDE3 didn't use DBus, which our KWallet store uses.
     VLOG(1) << "Trying KWallet for password storage.";
     backend.reset(new NativeBackendKWallet(id, used_desktop_env));
     if (backend->Init()) {
       VLOG(1) << "Using KWallet for password storage.";
       used_backend = KWALLET;
     } else {
       backend.reset();
@@ skipping 66 matching lines @@
     content::BrowserContext* context) const {
   return chrome::GetBrowserContextRedirectedInIncognito(context);
 }
 
 bool PasswordStoreFactory::ServiceIsNULLWhileTesting() const {
   return true;
 }
 
 #if defined(USE_X11)
 base::nix::DesktopEnvironment PasswordStoreFactory::GetDesktopEnvironment() {
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   return base::nix::GetDesktopEnvironment(env.get());
 }
 
 void PasswordStoreFactory::RecordBackendStatistics(
     base::nix::DesktopEnvironment desktop_env,
     const std::string& command_line_flag,
     LinuxBackendUsed used_backend) {
   LinuxBackendUsage usage = OTHER_PLAINTEXT;
   if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4 ||
       desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
@@ skipping 44 matching lines @@
         break;
       case LIBSECRET:
         usage = OTHER_LIBSECRET;
         break;
     }
   }
   UMA_HISTOGRAM_ENUMERATION("PasswordManager.LinuxBackendStatistics", usage,
                             MAX_BACKEND_USAGE_VALUE);
 }
 #endif