chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/password_store_win.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_win.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/os_crypt/ie7_password_win.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/password_manager/core/browser/webdata/password_web_data_service_win.h"
 #include "content/public/browser/browser_thread.h"
 
 using autofill::PasswordForm;
 using content::BrowserThread;
@@ skipping 122 matching lines @@
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 PasswordStoreWin::DBHandler::OnWebDataServiceRequestDone"));
 
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
 
   PendingRequestMap::iterator i = pending_requests_.find(handle);
   DCHECK(i != pending_requests_.end());
 
-  scoped_ptr<PasswordForm> form(i->second.form);
+  std::unique_ptr<PasswordForm> form(i->second.form);
   ResultCallback result_callback(i->second.result_callback);
   pending_requests_.erase(i);
 
   if (!result) {
     // The WDS returns NULL if it is shutting down. Run callback with empty
     // result.
     result_callback.Run(ScopedVector<autofill::PasswordForm>());
     return;
   }
 
   DCHECK_EQ(PASSWORD_IE7_RESULT, result->GetType());
   result_callback.Run(GetIE7Results(result, *form));
 }
 
 PasswordStoreWin::PasswordStoreWin(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
-    scoped_ptr<password_manager::LoginDatabase> login_db,
+    std::unique_ptr<password_manager::LoginDatabase> login_db,
     const scoped_refptr<PasswordWebDataService>& web_data_service)
     : PasswordStoreDefault(main_thread_runner,
                            db_thread_runner,
                            std::move(login_db)) {
   db_handler_.reset(new DBHandler(web_data_service, this));
 }
 
 PasswordStoreWin::~PasswordStoreWin() {
 }
 
 void PasswordStoreWin::ShutdownOnDBThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   db_handler_.reset();
 }
 
 void PasswordStoreWin::ShutdownOnUIThread() {
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&PasswordStoreWin::ShutdownOnDBThread, this));
   PasswordStoreDefault::ShutdownOnUIThread();
 }
 
-void PasswordStoreWin::GetLoginsImpl(const PasswordForm& form,
-                                     scoped_ptr<GetLoginsRequest> request) {
+void PasswordStoreWin::GetLoginsImpl(
+    const PasswordForm& form,
+    std::unique_ptr<GetLoginsRequest> request) {
   // When importing from IE7, the credentials are first stored into a temporary
   // Web SQL database. Then, after each GetLogins() request that does not yield
   // any matches from the LoginDatabase, the matching credentials in the Web SQL
   // database, if any, are returned as results instead, and simultaneously get
   // moved to the LoginDatabase, so next time they will be found immediately.
   // TODO(engedy): Make the IE7-specific code synchronous, so FillMatchingLogins
   // can be overridden instead. See: https://crbug.com/78830.
   // TODO(engedy): Credentials should be imported into the LoginDatabase in the
   // first place. See: https://crbug.com/456119.
   ScopedVector<autofill::PasswordForm> matched_forms(FillMatchingLogins(form));
   if (matched_forms.empty() && db_handler_) {
     db_handler_->GetIE7Login(
         form, base::Bind(&GetLoginsRequest::NotifyConsumerWithResults,
                          base::Owned(request.release())));
   } else {
     request->NotifyConsumerWithResults(std::move(matched_forms));
   }
 }