Remove stl_util's STLDeleteContainerPointers from autofill.

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>
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/adapters.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
@@ skipping 835 matching lines @@
 
 void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
                                               const base::string16& value) {
   autocomplete_history_manager_->OnRemoveAutocompleteEntry(name, value);
 }
 
 bool AutofillManager::IsShowingUnmaskPrompt() {
   return full_card_request_ && full_card_request_->IsGettingFullCard();
 }
 
-const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
-  return form_structures_.get();
+const std::vector<std::unique_ptr<FormStructure>>&
+AutofillManager::GetFormStructures() {
+  return form_structures_;
 }
 
 payments::FullCardRequest* AutofillManager::GetOrCreateFullCardRequest() {
   if (!full_card_request_) {
     full_card_request_.reset(new payments::FullCardRequest(
         client_, payments_client_.get(), personal_data_));
   }
 
   return full_card_request_.get();
 }
@@ skipping 13 matching lines @@
 }
 
 void AutofillManager::OnLoadedServerPredictions(
     std::string response,
     const std::vector<std::string>& form_signatures) {
   // We obtain the current valid FormStructures represented by
   // |form_signatures|. We invert both lists because most recent forms are at
   // the end of the list (and reverse the resulting pointer vector).
   std::vector<FormStructure*> queried_forms;
   for (const std::string& signature : base::Reversed(form_signatures)) {
-    for (FormStructure* cur_form : base::Reversed(form_structures_)) {
+    for (auto& cur_form : base::Reversed(form_structures_)) {
       if (cur_form->FormSignatureAsStr() == signature) {
-        queried_forms.push_back(cur_form);
+        queried_forms.push_back(cur_form.get());
         break;
       }
     }
   }
   std::reverse(queried_forms.begin(), queried_forms.end());
 
   // If there are no current forms corresponding to the queried signatures, drop
   // the query response.
   if (queried_forms.empty())
     return;
@@ skipping 650 matching lines @@
 
 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
   // forms might appear toward the beginning of the list.  The communication
   // protocol with the crowdsourcing server does not permit us to discard the
   // original versions of the forms.
   *form_structure = NULL;
-  for (FormStructure* cur_form : base::Reversed(form_structures_)) {
+  for (auto& cur_form : base::Reversed(form_structures_)) {
     if (*cur_form == form) {
-      *form_structure = cur_form;
+      *form_structure = cur_form.get();
 
       // The same form might be cached with multiple field counts: in some
       // cases, non-autofillable fields are filtered out, whereas in other cases
       // they are not.  To avoid thrashing the cache, keep scanning until we
       // find a cached version with the same number of fields, if there is one.
       if (cur_form->field_count() == form.fields.size())
         break;
     }
   }
 
@@ skipping 64 matching lines @@
   for (size_t i = 0; !needs_update && i < cached_form->field_count(); ++i)
     needs_update = !cached_form->field(i)->SameFieldAs(live_form.fields[i]);
 
   if (!needs_update)
     return true;
 
   if (form_structures_.size() >= kMaxFormCacheSize)
     return false;
 
   // Add the new or updated form to our cache.
-  form_structures_.push_back(new FormStructure(live_form));
-  *updated_form = *form_structures_.rbegin();
+  form_structures_.push_back(base::MakeUnique<FormStructure>(live_form));
+  *updated_form = form_structures_.rbegin()->get();
   (*updated_form)->DetermineHeuristicTypes();
 
   // If we have cached data, propagate it to the updated form.
   if (cached_form) {
     std::map<base::string16, const AutofillField*> cached_fields;
     for (size_t i = 0; i < cached_form->field_count(); ++i) {
       const AutofillField* field = cached_form->field(i);
       cached_fields[field->unique_name()] = field;
     }
 
@@ skipping 68 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();
 
-    std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
+    std::unique_ptr<FormStructure> form_structure =
+        base::MakeUnique<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));
 
     if (form_structures_.back()->ShouldBeCrowdsourced())
-      queryable_forms.push_back(form_structures_.back());
+      queryable_forms.push_back(form_structures_.back().get());
     else
-      non_queryable_forms.push_back(form_structures_.back());
+      non_queryable_forms.push_back(form_structures_.back().get());
 
     AutofillMetrics::LogParseFormTiming(base::TimeTicks::Now() -
                                         parse_form_start_time);
   }
 
   if (!queryable_forms.empty() && download_manager_) {
     // Query the server if at least one of the forms was parsed.
     download_manager_->StartQueryRequest(queryable_forms);
   }
 
   if (!queryable_forms.empty() || !non_queryable_forms.empty()) {
     AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
 #if defined(OS_IOS)
     // Log this from same location as AutofillMetrics::FORMS_LOADED to ensure
     // that KeyboardAccessoryButtonsIOS and UserHappiness UMA metrics will be
     // directly comparable.
     KeyboardAccessoryMetricsLogger::OnFormsLoaded();
 #endif
   }
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
   // When a credit card form is parsed and conditions are met, show an infobar
   // prompt for credit card assisted filling. Upon accepting the infobar, the
   // form will automatically be filled with the user's information through this
   // class' FillCreditCardForm().
-  if (autofill_assistant_.CanShowCreditCardAssist(form_structures_.get())) {
+  if (autofill_assistant_.CanShowCreditCardAssist(form_structures_)) {
     const std::vector<CreditCard*> cards =
         personal_data_->GetCreditCardsToSuggest();
     // Expired cards are last in the sorted order, so if the first one is
     // expired, they all are.
     if (!cards.empty() && !cards.front()->IsExpired(base::Time::Now()))
       autofill_assistant_.ShowAssistForCreditCard(*cards.front());
   }
 #endif
 
   // For the |non_queryable_forms|, we have all the field type info we're ever
@@ skipping 265 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill