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

chrome/browser/ui/passwords/manage_passwords_state.cc

 // Copyright 2015 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/ui/passwords/manage_passwords_state.h"
 
 #include <utility>
 
 #include "components/password_manager/core/browser/browser_save_password_progress_logger.h"
 #include "components/password_manager/core/browser/log_manager.h"
@@ skipping 22 matching lines @@
 std::vector<const typename Map::mapped_type::element_type*>
 ScopedPtrMapToVector(const Map& map) {
   std::vector<const typename Map::mapped_type::element_type*> ret;
   ret.reserve(map.size());
   for (const auto& form_pair : map)
     ret.push_back(form_pair.second.get());
   return ret;
 }
 
 void AddRawPtrFromOwningVector(
-    const std::vector<scoped_ptr<autofill::PasswordForm>>& owning_vector,
+    const std::vector<std::unique_ptr<autofill::PasswordForm>>& owning_vector,
     std::vector<const autofill::PasswordForm*>* destination) {
   destination->reserve(destination->size() + owning_vector.size());
   for (const auto& owning_ptr : owning_vector) {
     destination->push_back(owning_ptr.get());
   }
 }
 
 ScopedVector<const autofill::PasswordForm> DeepCopyMapToVector(
     const PasswordFormMap& password_form_map) {
   ScopedVector<const autofill::PasswordForm> ret;
@@ skipping 44 matching lines @@
 }  // namespace
 
 ManagePasswordsState::ManagePasswordsState()
     : state_(password_manager::ui::INACTIVE_STATE),
       client_(nullptr) {
 }
 
 ManagePasswordsState::~ManagePasswordsState() {}
 
 void ManagePasswordsState::OnPendingPassword(
-      scoped_ptr<password_manager::PasswordFormManager> form_manager) {
+    std::unique_ptr<password_manager::PasswordFormManager> form_manager) {
   ClearData();
   form_manager_ = std::move(form_manager);
   current_forms_weak_ = ScopedPtrMapToVector(form_manager_->best_matches());
   AddRawPtrFromOwningVector(form_manager_->federated_matches(),
                             &current_forms_weak_);
   origin_ = form_manager_->observed_form().origin;
   SetState(password_manager::ui::PENDING_PASSWORD_STATE);
 }
 
 void ManagePasswordsState::OnUpdatePassword(
-    scoped_ptr<password_manager::PasswordFormManager> form_manager) {
+    std::unique_ptr<password_manager::PasswordFormManager> form_manager) {
   ClearData();
   form_manager_ = std::move(form_manager);
   current_forms_weak_ = ScopedPtrMapToVector(form_manager_->best_matches());
   AddRawPtrFromOwningVector(form_manager_->federated_matches(),
                             &current_forms_weak_);
   origin_ = form_manager_->observed_form().origin;
   SetState(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE);
 }
 
 void ManagePasswordsState::OnRequestCredentials(
@@ skipping 10 matching lines @@
 void ManagePasswordsState::OnAutoSignin(
     ScopedVector<autofill::PasswordForm> local_forms, const GURL& origin) {
   DCHECK(!local_forms.empty());
   ClearData();
   local_credentials_forms_ = ConstifyVector(&local_forms);
   origin_ = origin;
   SetState(password_manager::ui::AUTO_SIGNIN_STATE);
 }
 
 void ManagePasswordsState::OnAutomaticPasswordSave(
-    scoped_ptr<PasswordFormManager> form_manager) {
+    std::unique_ptr<PasswordFormManager> form_manager) {
   ClearData();
   form_manager_ = std::move(form_manager);
   autofill::ConstPasswordFormMap current_forms;
   for (const auto& match : form_manager_->best_matches()) {
     current_forms.insert(std::make_pair(match.first, match.second.get()));
   }
   current_forms[form_manager_->pending_credentials().username_value] =
       &form_manager_->pending_credentials();
   current_forms_weak_ = MapToVector(current_forms);
   AddRawPtrFromOwningVector(form_manager_->federated_matches(),
                             &current_forms_weak_);
   origin_ = form_manager_->observed_form().origin;
   SetState(password_manager::ui::CONFIRMATION_STATE);
 }
 
 void ManagePasswordsState::OnPasswordAutofilled(
     const PasswordFormMap& password_form_map,
     const GURL& origin,
-    const std::vector<scoped_ptr<autofill::PasswordForm>>* federated_matches) {
+    const std::vector<std::unique_ptr<autofill::PasswordForm>>*
+        federated_matches) {
   DCHECK(!password_form_map.empty());
   ClearData();
   bool only_PSL_matches =
       find_if(password_form_map.begin(), password_form_map.end(),
               [](const std::pair<const base::string16,
-                                 scoped_ptr<autofill::PasswordForm>>& p) {
+                                 std::unique_ptr<autofill::PasswordForm>>& p) {
                 return !p.second->is_public_suffix_match;
               }) == password_form_map.end();
   if (only_PSL_matches) {
     // Don't show the UI for PSL matched passwords. They are not stored for this
     // page and cannot be deleted.
     origin_ = GURL();
     SetState(password_manager::ui::INACTIVE_STATE);
   } else {
     local_credentials_forms_ = DeepCopyMapToVector(password_form_map);
     if (federated_matches) {
@@ skipping 112 matching lines @@
   DCHECK(client_);
   if (client_->GetLogManager()->IsLoggingActive()) {
     password_manager::BrowserSavePasswordProgressLogger logger(
         client_->GetLogManager());
     logger.LogNumber(
         autofill::SavePasswordProgressLogger::STRING_NEW_UI_STATE,
         state);
   }
   state_ = state;
 }