components/autofill: scoped_ptr -> unique_ptr

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 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 "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 276 matching lines @@
 
   ParseForms(forms);
 }
 
 bool AutofillManager::OnWillSubmitForm(const FormData& form,
                                        const TimeTicks& timestamp) {
   if (!IsValidFormData(form))
     return false;
 
   // We will always give Autocomplete a chance to save the data.
-  scoped_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
+  std::unique_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
   if (!submitted_form) {
     autocomplete_history_manager_->OnWillSubmitForm(form);
     return false;
   }
 
   // However, if Autofill has recognized a field as CVC, that shouldn't be
   // saved.
   FormData form_for_autocomplete = submitted_form->ToFormData();
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     if (submitted_form->field(i)->Type().GetStorableType() ==
         CREDIT_CARD_VERIFICATION_CODE) {
       form_for_autocomplete.fields[i].should_autocomplete = false;
     }
   }
   autocomplete_history_manager_->OnWillSubmitForm(form_for_autocomplete);
 
   address_form_event_logger_->OnWillSubmitForm();
   credit_card_form_event_logger_->OnWillSubmitForm();
 
   StartUploadProcess(std::move(submitted_form), timestamp, true);
 
   return true;
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form) {
   if (!IsValidFormData(form))
     return false;
 
   // We will always give Autocomplete a chance to save the data.
-  scoped_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
+  std::unique_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
   if (!submitted_form) {
     return false;
   }
 
   address_form_event_logger_->OnFormSubmitted();
   credit_card_form_event_logger_->OnFormSubmitted();
 
   // Update Personal Data with the form's submitted data.
   if (submitted_form->IsAutofillable())
     ImportFormData(*submitted_form);
 
   return true;
 }
 
 void AutofillManager::StartUploadProcess(
-    scoped_ptr<FormStructure> form_structure,
+    std::unique_ptr<FormStructure> form_structure,
     const TimeTicks& timestamp,
     bool observed_submission) {
   // It is possible for |personal_data_| to be null, such as when used in the
   // Android webview.
   if (!personal_data_)
     return;
 
   // Only upload server statistics and UMA metrics if at least some local data
   // is available to use as a baseline.
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
@@ skipping 41 matching lines @@
   // A new pending form is assigned.
   pending_form_data_.reset(new FormData(form));
 }
 
 void AutofillManager::ProcessPendingFormForUpload() {
   if (!pending_form_data_)
     return;
 
   // We get the FormStructure corresponding to |pending_form_data_|, used in the
   // upload process. |pending_form_data_| is reset.
-  scoped_ptr<FormStructure> upload_form =
+  std::unique_ptr<FormStructure> upload_form =
       ValidateSubmittedForm(*pending_form_data_);
   pending_form_data_.reset();
   if (!upload_form)
     return;
 
   StartUploadProcess(std::move(upload_form), base::TimeTicks::Now(), false);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
                                            const FormFieldData& field,
@@ skipping 491 matching lines @@
     FillCreditCardForm(unmasking_query_id_, unmasking_form_, unmasking_field_,
                        unmask_request_.card);
   }
 
   client_->OnUnmaskVerificationResult(result);
 }
 
 void AutofillManager::OnDidGetUploadDetails(
     AutofillClient::PaymentsRpcResult result,
     const base::string16& context_token,
-    scoped_ptr<base::DictionaryValue> legal_message) {
+    std::unique_ptr<base::DictionaryValue> legal_message) {
   // TODO(jdonnelly): Log duration.
   if (result == AutofillClient::SUCCESS) {
     // Do *not* call payments_client_->Prepare() here. We shouldn't send
     // credentials until the user has explicitly accepted a prompt to upload.
     upload_request_.context_token = context_token;
     user_did_accept_upload_prompt_ = false;
     client_->ConfirmSaveCreditCardToCloud(
         upload_request_.card, std::move(legal_message),
         base::Bind(&AutofillManager::OnUserDidAcceptUpload,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 70 matching lines @@
 bool AutofillManager::ShouldUploadForm(const FormStructure& form) {
   return IsAutofillEnabled() && !driver_->IsOffTheRecord() &&
          form.ShouldBeParsed() &&
          (form.active_field_count() >= kRequiredFieldsForUpload ||
           (form.all_fields_are_passwords() &&
            form.active_field_count() >=
                kRequiredFieldsForFormsWithOnlyPasswordFields));
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
-  scoped_ptr<CreditCard> imported_credit_card;
+  std::unique_ptr<CreditCard> imported_credit_card;
   if (!personal_data_->ImportFormData(
           submitted_form, IsCreditCardUploadEnabled(), &imported_credit_card)) {
     return;
   }
 
 #ifdef ENABLE_FORM_DEBUG_DUMP
   // Debug code for research on what autofill Chrome extracts from the last few
   // forms when submitting credit card data. See DumpAutofillData().
   bool dump_data = base::CommandLine::ForCurrentProcess()->HasSwitch(
       "dump-autofill-data");
@@ skipping 469 matching lines @@
     autofilled_form_signatures_.pop_back();
 
   // Note that this may invalidate |data_model|, particularly if it is a Mac
   // address book entry.
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
     personal_data_->RecordUseOf(data_model);
 
   driver_->SendFormDataToRenderer(query_id, action, result);
 }
 
-scoped_ptr<FormStructure> AutofillManager::ValidateSubmittedForm(
+std::unique_ptr<FormStructure> AutofillManager::ValidateSubmittedForm(
     const FormData& form) {
-  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
+  std::unique_ptr<FormStructure> submitted_form(new FormStructure(form));
   if (!ShouldUploadForm(*submitted_form))
-    return scoped_ptr<FormStructure>();
+    return std::unique_ptr<FormStructure>();
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
-    return scoped_ptr<FormStructure>();
+    return std::unique_ptr<FormStructure>();
 
   submitted_form->UpdateFromCache(*cached_submitted_form);
   return submitted_form;
 }
 
 bool AutofillManager::FindCachedForm(const FormData& form,
                                      FormStructure** form_structure) const {
   // Find the FormStructure that corresponds to |form|.
   // Scan backward through the cached |form_structures_|, as updated versions of
   // forms are added to the back of the list, whereas original versions of these
@@ skipping 167 matching lines @@
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   if (forms.empty())
     return;
 
   std::vector<FormStructure*> non_queryable_forms;
   std::vector<FormStructure*> queryable_forms;
   for (const FormData& form : forms) {
     const auto parse_form_start_time = base::TimeTicks::Now();
 
-    scoped_ptr<FormStructure> form_structure(new FormStructure(form));
+    std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
     form_structure->ParseFieldTypesFromAutocompleteAttributes();
     if (!form_structure->ShouldBeParsed())
       continue;
 
     form_structure->DetermineHeuristicTypes();
 
     // Ownership is transferred to |form_structures_| which maintains it until
     // the manager is Reset() or destroyed. It is safe to use references below
     // as long as receivers don't take ownership.
     form_structures_.push_back(std::move(form_structure));
@@ skipping 291 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill