[Autofill] Split off AutofillDataModel as a subclass of FormData.

components/autofill/browser/autofill_manager.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 "components/autofill/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "components/autofill/browser/autocheckout/whitelist_manager.h"
 #include "components/autofill/browser/autocheckout_manager.h"
 #include "components/autofill/browser/autocomplete_history_manager.h"
+#include "components/autofill/browser/autofill_data_model.h"
 #include "components/autofill/browser/autofill_external_delegate.h"
 #include "components/autofill/browser/autofill_field.h"
 #include "components/autofill/browser/autofill_manager_delegate.h"
 #include "components/autofill/browser/autofill_manager_test_delegate.h"
 #include "components/autofill/browser/autofill_metrics.h"
 #include "components/autofill/browser/autofill_profile.h"
 #include "components/autofill/browser/autofill_type.h"
 #include "components/autofill/browser/credit_card.h"
 #include "components/autofill/browser/form_structure.h"
 #include "components/autofill/browser/password_generator.h"
@@ skipping 569 matching lines @@
   // renderer.
   autocomplete_history_manager_.OnGetAutocompleteSuggestions(
       query_id, field.name, field.value, values, labels, icons, unique_ids);
 }
 
 void AutofillManager::OnFillAutofillFormData(int query_id,
                                              const FormData& form,
                                              const FormFieldData& field,
                                              int unique_id) {
   RenderViewHost* host = NULL;
-  const FormGroup* form_group = NULL;
+  const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
-  // NOTE: GetHost may invalidate |form_group| because it causes the
+  // NOTE: GetHost may invalidate |data_model| because it causes the
   // PersonalDataManager to reload Mac address book entries. Thus it must
   // come before GetProfileOrCreditCard.
   if (!GetHost(&host) ||
-      !GetProfileOrCreditCard(unique_id, &form_group, &variant) ||
+      !GetProfileOrCreditCard(unique_id, &data_model, &variant) ||
       !GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   DCHECK(host);
   DCHECK(form_structure);
   DCHECK(autofill_field);
 
   FormData result = form;
 
   // If the relevant section is auto-filled, we should fill |field| but not the
   // rest of the form.
   if (SectionIsAutofilled(*form_structure, form, autofill_field->section())) {
     for (std::vector<FormFieldData>::iterator iter = result.fields.begin();
          iter != result.fields.end(); ++iter) {
       if ((*iter) == field) {
-        form_group->FillFormField(
+        data_model->FillFormField(
             *autofill_field, variant, app_locale_, &(*iter));
         // Mark the cached field as autofilled, so that we can detect when a
         // user edits an autofilled field (for metrics).
         autofill_field->is_autofilled = true;
         break;
       }
     }
 
     host->Send(new AutofillMsg_FormDataFilled(host->GetRoutingID(), query_id,
                                               result));
@@ skipping 17 matching lines @@
       // If the field being filled is either
       //   (a) the field that the user initiated the fill from, or
       //   (b) part of the same logical unit, e.g. name or phone number,
       // then take the multi-profile "variant" into account.
       // Otherwise fill with the default (zeroth) variant.
       size_t use_variant = 0;
       if (result.fields[i] == field ||
           field_group_type == initiating_group_type) {
         use_variant = variant;
       }
-      form_group->FillFormField(*cached_field,
+      data_model->FillFormField(*cached_field,
                                 use_variant,
                                 app_locale_,
                                 &result.fields[i]);
       // Mark the cached field as autofilled, so that we can detect when a user
       // edits an autofilled field (for metrics).
       form_structure->field(i)->is_autofilled = true;
     }
   }
 
   autofilled_form_signatures_.push_front(form_structure->FormSignature());
@@ skipping 53 matching lines @@
 void AutofillManager::OnShowPasswordGenerationPopup(
     const gfx::Rect& bounds,
     int max_length,
     const content::PasswordForm& form) {
   password_generator_.reset(new autofill::PasswordGenerator(max_length));
   manager_delegate_->ShowPasswordGenerationBubble(
       bounds, form, password_generator_.get());
 }
 
 void AutofillManager::RemoveAutofillProfileOrCreditCard(int unique_id) {
-  const FormGroup* form_group = NULL;
+  const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
-  if (!GetProfileOrCreditCard(unique_id, &form_group, &variant)) {
+  if (!GetProfileOrCreditCard(unique_id, &data_model, &variant)) {
     NOTREACHED();
     return;
   }
 
   // TODO(csharp): If we are dealing with a variant only the variant should
   // be deleted, instead of doing nothing.
   // http://crbug.com/124211
   if (variant != 0)
     return;
 
-  personal_data_->RemoveByGUID(form_group->GetGUID());
+  personal_data_->RemoveByGUID(data_model->guid());
 }
 
 void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
                                               const base::string16& value) {
   autocomplete_history_manager_.OnRemoveAutocompleteEntry(name, value);
 }
 
 content::WebContents* AutofillManager::GetWebContents() const {
   return web_contents();
 }
@@ skipping 278 matching lines @@
 
   *host = web_contents()->GetRenderViewHost();
   if (!*host)
     return false;
 
   return true;
 }
 
 bool AutofillManager::GetProfileOrCreditCard(
     int unique_id,
-    const FormGroup** form_group,
+    const AutofillDataModel** data_model,
     size_t* variant) const {
   // Unpack the |unique_id| into component parts.
   GUIDPair credit_card_guid;
   GUIDPair profile_guid;
   UnpackGUIDs(unique_id, &credit_card_guid, &profile_guid);
   DCHECK(!base::IsValidGUID(credit_card_guid.first) ||
          !base::IsValidGUID(profile_guid.first));
 
   // Find the profile that matches the |profile_guid|, if one is specified.
   // Otherwise find the credit card that matches the |credit_card_guid|,
   // if specified.
   if (base::IsValidGUID(profile_guid.first)) {
-    *form_group = personal_data_->GetProfileByGUID(profile_guid.first);
+    *data_model = personal_data_->GetProfileByGUID(profile_guid.first);
     *variant = profile_guid.second;
   } else if (base::IsValidGUID(credit_card_guid.first)) {
-    *form_group =
-        personal_data_->GetCreditCardByGUID(credit_card_guid.first);
+    *data_model = personal_data_->GetCreditCardByGUID(credit_card_guid.first);
     *variant = credit_card_guid.second;
   }
 
-  return !!*form_group;
+  return !!*data_model;
 }
 
 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.
@@ skipping 254 matching lines @@
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
 }  // namespace autofill