Move forms/ out of webkit/.

chrome/browser/autofill/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 "chrome/browser/autofill/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 24 matching lines @@
 #include "chrome/browser/autofill/password_generator.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/autofill/phone_number.h"
 #include "chrome/browser/autofill/phone_number_i18n.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/form_data.h"
+#include "chrome/common/form_data_predictions.h"
+#include "chrome/common/form_field_data.h"
+#include "chrome/common/password_form_fill_data.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
-#include "webkit/forms/form_data.h"
-#include "webkit/forms/form_data_predictions.h"
-#include "webkit/forms/form_field.h"
-#include "webkit/forms/password_form_dom_manager.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 using content::RenderViewHost;
 using switches::kEnableAutofillFeedback;
-using webkit::forms::FormData;
-using webkit::forms::FormDataPredictions;
-using webkit::forms::FormField;
 
 namespace {
 
 // We only send a fraction of the forms to upload server.
 // The rate for positive/negative matches potentially could be different.
 const double kAutofillPositiveUploadRateDefaultValue = 0.20;
 const double kAutofillNegativeUploadRateDefaultValue = 0.20;
 
 const size_t kMaxRecentFormSignaturesToRemember = 3;
 
@@ skipping 353 matching lines @@
   }
 
   if (!enabled)
     return;
 
   forms_loaded_timestamp_ = timestamp;
   ParseForms(forms);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
-                                           const FormField& field,
+                                           const FormFieldData& field,
                                            const TimeTicks& timestamp) {
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   if (!user_did_type_) {
     user_did_type_ = true;
     metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
   }
 
   if (autofill_field->is_autofilled) {
     autofill_field->is_autofilled = false;
     metric_logger_->LogUserHappinessMetric(
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
 
     if (!user_did_edit_autofilled_field_) {
       user_did_edit_autofilled_field_ = true;
       metric_logger_->LogUserHappinessMetric(
           AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE);
     }
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
 
 void AutofillManager::OnQueryFormFieldAutofill(int query_id,
                                                const FormData& form,
-                                               const FormField& field,
+                                               const FormFieldData& field,
                                                const gfx::Rect& bounding_box,
                                                bool display_warning) {
   std::vector<string16> values;
   std::vector<string16> labels;
   std::vector<string16> icons;
   std::vector<int> unique_ids;
 
   if (external_delegate_) {
     external_delegate_->OnQuery(query_id,
                                 form,
@@ skipping 73 matching lines @@
   // Add the results from AutoComplete.  They come back asynchronously, so we
   // hand off what we generated and they will send the results back to the
   // renderer.
   AutocompleteHistoryManager::FromWebContents(tab_contents_->web_contents())->
       OnGetAutocompleteSuggestions(
           query_id, field.name, field.value, values, labels, icons, unique_ids);
 }
 
 void AutofillManager::OnFillAutofillFormData(int query_id,
                                              const FormData& form,
-                                             const FormField& field,
+                                             const FormFieldData& field,
                                              int unique_id) {
   const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
   const AutofillProfile* profile = NULL;
   const CreditCard* credit_card = NULL;
   size_t variant = 0;
   RenderViewHost* host = NULL;
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetProfileOrCreditCard(unique_id, profiles, credit_cards, &profile,
                               &credit_card, &variant) ||
       !GetHost(profiles, credit_cards, &host) ||
       !GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   DCHECK(host);
   DCHECK(form_structure);
   DCHECK(autofill_field);
   DCHECK(profile || credit_card);
 
   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<FormField>::iterator iter = result.fields.begin();
+    for (std::vector<FormFieldData>::iterator iter = result.fields.begin();
          iter != result.fields.end(); ++iter) {
       if ((*iter) == field) {
         AutofillFieldType field_type = autofill_field->type();
         if (profile) {
           DCHECK_NE(AutofillType::CREDIT_CARD,
                     AutofillType(field_type).group());
           FillFormField(*profile, *autofill_field, variant, &(*iter));
         } else {
           DCHECK_EQ(AutofillType::CREDIT_CARD,
                     AutofillType(field_type).group());
@@ skipping 105 matching lines @@
 }
 
 void AutofillManager::OnHideAutofillPopup() {
   if (external_delegate_)
     external_delegate_->HideAutofillPopup();
 }
 
 void AutofillManager::OnShowPasswordGenerationPopup(
     const gfx::Rect& bounds,
     int max_length,
-    const webkit::forms::PasswordForm& form) {
+    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 std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
   const AutofillProfile* profile = NULL;
   const CreditCard* credit_card = NULL;
@@ skipping 10 matching lines @@
   if (variant != 0)
     return;
 
   if (profile)
     personal_data_->RemoveProfile(profile->guid());
   else
     personal_data_->RemoveCreditCard(credit_card->guid());
 }
 
 void AutofillManager::OnAddPasswordFormMapping(
-      const webkit::forms::FormField& form,
-      const webkit::forms::PasswordFormFillData& fill_data) {
+      const FormFieldData& form,
+      const PasswordFormFillData& fill_data) {
   if (external_delegate_)
     external_delegate_->AddPasswordFormMapping(form, fill_data);
 }
 
 void AutofillManager::OnShowPasswordSuggestions(
-    const webkit::forms::FormField& field,
+    const FormFieldData& field,
     const gfx::Rect& bounds,
     const std::vector<string16>& suggestions) {
   if (external_delegate_)
     external_delegate_->OnShowPasswordSuggestions(suggestions, field, bounds);
 }
 
 void AutofillManager::OnSetDataList(const std::vector<string16>& values,
                                     const std::vector<string16>& labels,
                                     const std::vector<string16>& icons,
                                     const std::vector<int>& unique_ids) {
@@ skipping 229 matching lines @@
     }
   }
 
   if (!(*form_structure))
     return false;
 
   return true;
 }
 
 bool AutofillManager::GetCachedFormAndField(const FormData& form,
-                                            const FormField& field,
+                                            const FormFieldData& field,
                                             FormStructure** form_structure,
                                             AutofillField** autofill_field) {
   // Find the FormStructure that corresponds to |form|.
   // If we do not have this form in our cache but it is parseable, we'll add it
   // in the call to |UpdateCachedForm()|.
   if (!FindCachedForm(form, form_structure) &&
       !FormStructure(form).ShouldBeParsed(false)) {
     return false;
   }
 
@@ skipping 68 matching lines @@
 
   // Annotate the updated form with its predicted types.
   std::vector<FormStructure*> forms(1, *updated_form);
   SendAutofillTypePredictions(forms);
 
   return true;
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
-    const FormField& field,
+    const FormFieldData& field,
     AutofillFieldType type,
     std::vector<string16>* values,
     std::vector<string16>* labels,
     std::vector<string16>* icons,
     std::vector<int>* unique_ids) const {
   const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   if (!field.is_autofilled) {
     std::vector<AutofillProfile*> matched_profiles;
     for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
          iter != profiles.end(); ++iter) {
@@ skipping 66 matching lines @@
     // No labels for previously filled fields.
     labels->resize(values->size());
 
     // No icons for profile suggestions.
     icons->resize(values->size());
   }
 }
 
 void AutofillManager::GetCreditCardSuggestions(
     FormStructure* form,
-    const FormField& field,
+    const FormFieldData& field,
     AutofillFieldType type,
     std::vector<string16>* values,
     std::vector<string16>* labels,
     std::vector<string16>* icons,
     std::vector<int>* unique_ids) const {
   for (std::vector<CreditCard*>::const_iterator iter =
            personal_data_->credit_cards().begin();
        iter != personal_data_->credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
@@ skipping 18 matching lines @@
       labels->push_back(label);
       icons->push_back(UTF8ToUTF16(credit_card->type()));
       unique_ids->push_back(PackGUIDs(GUIDPair(credit_card->guid(), 0),
                                       GUIDPair(std::string(), 0)));
     }
   }
 }
 
 void AutofillManager::FillCreditCardFormField(const CreditCard& credit_card,
                                               AutofillFieldType type,
-                                              FormField* field) {
+                                              FormFieldData* field) {
   DCHECK_EQ(AutofillType::CREDIT_CARD, AutofillType(type).group());
   DCHECK(field);
 
   if (field->form_control_type == ASCIIToUTF16("select-one")) {
     autofill::FillSelectControl(credit_card, type, field);
   } else if (field->form_control_type == ASCIIToUTF16("month")) {
     // HTML5 input="month" consists of year-month.
     string16 year =
         credit_card.GetCanonicalizedInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR);
     string16 month = credit_card.GetCanonicalizedInfo(CREDIT_CARD_EXP_MONTH);
     if (!year.empty() && !month.empty()) {
       // Fill the value only if |credit_card| includes both year and month
       // information.
       field->value = year + ASCIIToUTF16("-") + month;
     }
   } else {
     field->value = credit_card.GetCanonicalizedInfo(type);
   }
 }
 
 void AutofillManager::FillFormField(const AutofillProfile& profile,
                                     const AutofillField& cached_field,
                                     size_t variant,
-                                    FormField* field) {
+                                    FormFieldData* field) {
   AutofillFieldType type = cached_field.type();
   DCHECK_NE(AutofillType::CREDIT_CARD, AutofillType(type).group());
   DCHECK(field);
 
   if (type == PHONE_HOME_NUMBER) {
     FillPhoneNumberField(profile, cached_field, variant, field);
   } else {
     if (field->form_control_type == ASCIIToUTF16("select-one")) {
       autofill::FillSelectControl(profile, type, field);
     } else {
       std::vector<string16> values;
       profile.GetCanonicalizedMultiInfo(type, &values);
       if (variant >= values.size()) {
         // If the variant is unavailable, bail.  This case is reachable, for
         // example if Sync updates a profile during the filling process.
         return;
       }
 
       field->value = values[variant];
     }
   }
 }
 
 void AutofillManager::FillPhoneNumberField(const AutofillProfile& profile,
                                            const AutofillField& cached_field,
                                            size_t variant,
-                                           FormField* field) {
+                                           FormFieldData* field) {
   std::vector<string16> values;
   profile.GetCanonicalizedMultiInfo(cached_field.type(), &values);
   DCHECK(variant < values.size());
 
   // If we are filling a phone number, check to see if the size field
   // matches the "prefix" or "suffix" sizes and fill accordingly.
   string16 number = values[variant];
   if (number.length() ==
           (PhoneNumber::kPrefixLength + PhoneNumber::kSuffixLength)) {
     if (cached_field.phone_part() == AutofillField::PHONE_PREFIX ||
@@ skipping 105 matching lines @@
   *profile_guid = IDToGUID(profile_id);
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }