1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "components/autofill/core/browser/autofill_manager.h"
6
7#include <stddef.h>
8
9#include <limits>
10#include <map>
11#include <set>
12#include <utility>
13
14#include "base/bind.h"
15#include "base/command_line.h"
16#include "base/guid.h"
17#include "base/logging.h"
18#include "base/prefs/pref_service.h"
19#include "base/strings/string16.h"
20#include "base/strings/string_util.h"
21#include "base/strings/utf_string_conversions.h"
22#include "base/threading/sequenced_worker_pool.h"
23#include "components/autofill/core/browser/autocomplete_history_manager.h"
24#include "components/autofill/core/browser/autofill_client.h"
25#include "components/autofill/core/browser/autofill_data_model.h"
26#include "components/autofill/core/browser/autofill_external_delegate.h"
27#include "components/autofill/core/browser/autofill_field.h"
28#include "components/autofill/core/browser/autofill_manager_test_delegate.h"
29#include "components/autofill/core/browser/autofill_metrics.h"
30#include "components/autofill/core/browser/autofill_profile.h"
31#include "components/autofill/core/browser/autofill_type.h"
32#include "components/autofill/core/browser/credit_card.h"
33#include "components/autofill/core/browser/form_structure.h"
34#include "components/autofill/core/browser/personal_data_manager.h"
35#include "components/autofill/core/browser/phone_number.h"
36#include "components/autofill/core/browser/phone_number_i18n.h"
37#include "components/autofill/core/browser/popup_item_ids.h"
38#include "components/autofill/core/common/autofill_data_validation.h"
39#include "components/autofill/core/common/autofill_pref_names.h"
40#include "components/autofill/core/common/autofill_switches.h"
41#include "components/autofill/core/common/form_data.h"
42#include "components/autofill/core/common/form_data_predictions.h"
43#include "components/autofill/core/common/form_field_data.h"
44#include "components/autofill/core/common/password_form_fill_data.h"
45#include "components/pref_registry/pref_registry_syncable.h"
46#include "grit/components_strings.h"
47#include "ui/base/l10n/l10n_util.h"
48#include "ui/gfx/rect.h"
49#include "url/gurl.h"
50
51namespace autofill {
52
53typedef PersonalDataManager::GUIDPair GUIDPair;
54
55using base::TimeTicks;
56
57namespace {
58
59// We only send a fraction of the forms to upload server.
60// The rate for positive/negative matches potentially could be different.
61const double kAutofillPositiveUploadRateDefaultValue = 0.20;
62const double kAutofillNegativeUploadRateDefaultValue = 0.20;
63
64const size_t kMaxRecentFormSignaturesToRemember = 3;
65
66// Set a conservative upper bound on the number of forms we are willing to
67// cache, simply to prevent unbounded memory consumption.
68const size_t kMaxFormCacheSize = 100;
69
70// Removes duplicate suggestions whilst preserving their original order.
71void RemoveDuplicateSuggestions(std::vector<base::string16>* values,
72                                std::vector<base::string16>* labels,
73                                std::vector<base::string16>* icons,
74                                std::vector<int>* unique_ids) {
75  DCHECK_EQ(values->size(), labels->size());
76  DCHECK_EQ(values->size(), icons->size());
77  DCHECK_EQ(values->size(), unique_ids->size());
78
79  std::set<std::pair<base::string16, base::string16> > seen_suggestions;
80  std::vector<base::string16> values_copy;
81  std::vector<base::string16> labels_copy;
82  std::vector<base::string16> icons_copy;
83  std::vector<int> unique_ids_copy;
84
85  for (size_t i = 0; i < values->size(); ++i) {
86    const std::pair<base::string16, base::string16> suggestion(
87        (*values)[i], (*labels)[i]);
88    if (seen_suggestions.insert(suggestion).second) {
89      values_copy.push_back((*values)[i]);
90      labels_copy.push_back((*labels)[i]);
91      icons_copy.push_back((*icons)[i]);
92      unique_ids_copy.push_back((*unique_ids)[i]);
93    }
94  }
95
96  values->swap(values_copy);
97  labels->swap(labels_copy);
98  icons->swap(icons_copy);
99  unique_ids->swap(unique_ids_copy);
100}
101
102// Precondition: |form_structure| and |form| should correspond to the same
103// logical form.  Returns true if any field in the given |section| within |form|
104// is auto-filled.
105bool SectionIsAutofilled(const FormStructure& form_structure,
106                         const FormData& form,
107                         const std::string& section) {
108  DCHECK_EQ(form_structure.field_count(), form.fields.size());
109  for (size_t i = 0; i < form_structure.field_count(); ++i) {
110    if (form_structure.field(i)->section() == section &&
111        form.fields[i].is_autofilled) {
112      return true;
113    }
114  }
115
116  return false;
117}
118
119bool FormIsHTTPS(const FormStructure& form) {
120  // TODO(blundell): Change this to use a constant once crbug.com/306258 is
121  // fixed.
122  return form.source_url().SchemeIs("https");
123}
124
125// Uses the existing personal data in |profiles| and |credit_cards| to determine
126// possible field types for the |submitted_form|.  This is potentially
127// expensive -- on the order of 50ms even for a small set of |stored_data|.
128// Hence, it should not run on the UI thread -- to avoid locking up the UI --
129// nor on the IO thread -- to avoid blocking IPC calls.
130void DeterminePossibleFieldTypesForUpload(
131    const std::vector<AutofillProfile>& profiles,
132    const std::vector<CreditCard>& credit_cards,
133    const std::string& app_locale,
134    FormStructure* submitted_form) {
135  // For each field in the |submitted_form|, extract the value.  Then for each
136  // profile or credit card, identify any stored types that match the value.
137  for (size_t i = 0; i < submitted_form->field_count(); ++i) {
138    AutofillField* field = submitted_form->field(i);
139    ServerFieldTypeSet matching_types;
140
141    base::string16 value;
142    base::TrimWhitespace(field->value, base::TRIM_ALL, &value);
143    for (std::vector<AutofillProfile>::const_iterator it = profiles.begin();
144         it != profiles.end(); ++it) {
145      it->GetMatchingTypes(value, app_locale, &matching_types);
146    }
147    for (std::vector<CreditCard>::const_iterator it = credit_cards.begin();
148         it != credit_cards.end(); ++it) {
149      it->GetMatchingTypes(value, app_locale, &matching_types);
150    }
151
152    if (matching_types.empty())
153      matching_types.insert(UNKNOWN_TYPE);
154
155    field->set_possible_types(matching_types);
156  }
157}
158
159}  // namespace
160
161AutofillManager::AutofillManager(
162    AutofillDriver* driver,
163    AutofillClient* client,
164    const std::string& app_locale,
165    AutofillDownloadManagerState enable_download_manager)
166    : driver_(driver),
167      client_(client),
168      app_locale_(app_locale),
169      personal_data_(client->GetPersonalDataManager()),
170      autocomplete_history_manager_(
171          new AutocompleteHistoryManager(driver, client)),
172      metric_logger_(new AutofillMetrics),
173      has_logged_autofill_enabled_(false),
174      has_logged_address_suggestions_count_(false),
175      did_show_suggestions_(false),
176      user_did_type_(false),
177      user_did_autofill_(false),
178      user_did_edit_autofilled_field_(false),
179      external_delegate_(NULL),
180      test_delegate_(NULL),
181      weak_ptr_factory_(this) {
182  if (enable_download_manager == ENABLE_AUTOFILL_DOWNLOAD_MANAGER) {
183    download_manager_.reset(
184        new AutofillDownloadManager(driver, client_->GetPrefs(), this));
185  }
186}
187
188AutofillManager::~AutofillManager() {}
189
190// static
191void AutofillManager::RegisterProfilePrefs(
192    user_prefs::PrefRegistrySyncable* registry) {
193  registry->RegisterBooleanPref(
194      prefs::kAutofillEnabled,
195      true,
196      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
197#if defined(OS_MACOSX)
198  registry->RegisterBooleanPref(
199      prefs::kAutofillAuxiliaryProfilesEnabled,
200      true,
201      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
202#else  // defined(OS_MACOSX)
203  registry->RegisterBooleanPref(
204      prefs::kAutofillAuxiliaryProfilesEnabled,
205      false,
206      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
207#endif  // defined(OS_MACOSX)
208#if defined(OS_MACOSX)
209  registry->RegisterBooleanPref(
210      prefs::kAutofillMacAddressBookQueried,
211      false,
212      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
213#endif  // defined(OS_MACOSX)
214  registry->RegisterDoublePref(
215      prefs::kAutofillPositiveUploadRate,
216      kAutofillPositiveUploadRateDefaultValue,
217      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
218  registry->RegisterDoublePref(
219      prefs::kAutofillNegativeUploadRate,
220      kAutofillNegativeUploadRateDefaultValue,
221      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
222
223#if defined(OS_MACOSX) && !defined(OS_IOS)
224  registry->RegisterBooleanPref(
225      prefs::kAutofillUseMacAddressBook,
226      false,
227      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
228  registry->RegisterIntegerPref(
229      prefs::kAutofillMacAddressBookShowedCount,
230      0,
231      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
232#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
233}
234
235#if defined(OS_MACOSX) && !defined(OS_IOS)
236void AutofillManager::MigrateUserPrefs(PrefService* prefs) {
237  const PrefService::Preference* pref =
238      prefs->FindPreference(prefs::kAutofillUseMacAddressBook);
239
240  // If the pref is not its default value, then the migration has already been
241  // performed.
242  if (!pref->IsDefaultValue())
243    return;
244
245  // Whether Chrome has already tried to access the user's Address Book.
246  const PrefService::Preference* pref_accessed =
247      prefs->FindPreference(prefs::kAutofillMacAddressBookQueried);
248  // Whether the user wants to use the Address Book to populate Autofill.
249  const PrefService::Preference* pref_enabled =
250      prefs->FindPreference(prefs::kAutofillAuxiliaryProfilesEnabled);
251
252  if (pref_accessed->IsDefaultValue() && pref_enabled->IsDefaultValue()) {
253    // This is likely a new user. Reset the default value to prevent the
254    // migration from happening again.
255    prefs->SetBoolean(prefs::kAutofillUseMacAddressBook,
256                      prefs->GetBoolean(prefs::kAutofillUseMacAddressBook));
257    return;
258  }
259
260  bool accessed;
261  bool enabled;
262  bool success = pref_accessed->GetValue()->GetAsBoolean(&accessed);
263  DCHECK(success);
264  success = pref_enabled->GetValue()->GetAsBoolean(&enabled);
265  DCHECK(success);
266
267  prefs->SetBoolean(prefs::kAutofillUseMacAddressBook, accessed && enabled);
268}
269#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
270
271void AutofillManager::SetExternalDelegate(AutofillExternalDelegate* delegate) {
272  // TODO(jrg): consider passing delegate into the ctor.  That won't
273  // work if the delegate has a pointer to the AutofillManager, but
274  // future directions may not need such a pointer.
275  external_delegate_ = delegate;
276  autocomplete_history_manager_->SetExternalDelegate(delegate);
277}
278
279void AutofillManager::ShowAutofillSettings() {
280  client_->ShowAutofillSettings();
281}
282
283#if defined(OS_MACOSX) && !defined(OS_IOS)
284bool AutofillManager::ShouldShowAccessAddressBookSuggestion(
285    const FormData& form,
286    const FormFieldData& field) {
287  if (!personal_data_ || !field.should_autocomplete)
288    return false;
289
290  FormStructure* form_structure = NULL;
291  AutofillField* autofill_field = NULL;
292  if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
293    return false;
294
295  if (!form_structure->IsAutofillable())
296    return false;
297
298  return personal_data_->ShouldShowAccessAddressBookSuggestion(
299      autofill_field->Type());
300}
301
302bool AutofillManager::AccessAddressBook() {
303  if (!personal_data_)
304    return false;
305  return personal_data_->AccessAddressBook();
306}
307
308void AutofillManager::ShowedAccessAddressBookPrompt() {
309  if (!personal_data_)
310    return;
311  return personal_data_->ShowedAccessAddressBookPrompt();
312}
313
314int AutofillManager::AccessAddressBookPromptCount() {
315  if (!personal_data_)
316    return 0;
317  return personal_data_->AccessAddressBookPromptCount();
318}
319#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
320
321bool AutofillManager::OnFormSubmitted(const FormData& form,
322                                      const TimeTicks& timestamp) {
323  if (!IsValidFormData(form))
324    return false;
325
326  // Let Autocomplete know as well.
327  autocomplete_history_manager_->OnFormSubmitted(form);
328
329  // Grab a copy of the form data.
330  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
331
332  if (!ShouldUploadForm(*submitted_form))
333    return false;
334
335  // Don't save data that was submitted through JavaScript.
336  if (!form.user_submitted)
337    return false;
338
339  // Ignore forms not present in our cache.  These are typically forms with
340  // wonky JavaScript that also makes them not auto-fillable.
341  FormStructure* cached_submitted_form;
342  if (!FindCachedForm(form, &cached_submitted_form))
343    return false;
344
345  submitted_form->UpdateFromCache(*cached_submitted_form);
346  if (submitted_form->IsAutofillable())
347    ImportFormData(*submitted_form);
348
349  // Only upload server statistics and UMA metrics if at least some local data
350  // is available to use as a baseline.
351  const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
352  const std::vector<CreditCard*>& credit_cards =
353      personal_data_->GetCreditCards();
354  if (!profiles.empty() || !credit_cards.empty()) {
355    // Copy the profile and credit card data, so that it can be accessed on a
356    // separate thread.
357    std::vector<AutofillProfile> copied_profiles;
358    copied_profiles.reserve(profiles.size());
359    for (std::vector<AutofillProfile*>::const_iterator it = profiles.begin();
360         it != profiles.end(); ++it) {
361      copied_profiles.push_back(**it);
362    }
363
364    std::vector<CreditCard> copied_credit_cards;
365    copied_credit_cards.reserve(credit_cards.size());
366    for (std::vector<CreditCard*>::const_iterator it = credit_cards.begin();
367         it != credit_cards.end(); ++it) {
368      copied_credit_cards.push_back(**it);
369    }
370
371    // Note that ownership of |submitted_form| is passed to the second task,
372    // using |base::Owned|.
373    FormStructure* raw_submitted_form = submitted_form.get();
374    driver_->GetBlockingPool()->PostTaskAndReply(
375        FROM_HERE,
376        base::Bind(&DeterminePossibleFieldTypesForUpload,
377                   copied_profiles,
378                   copied_credit_cards,
379                   app_locale_,
380                   raw_submitted_form),
381        base::Bind(&AutofillManager::UploadFormDataAsyncCallback,
382                   weak_ptr_factory_.GetWeakPtr(),
383                   base::Owned(submitted_form.release()),
384                   forms_loaded_timestamps_[form],
385                   initial_interaction_timestamp_,
386                   timestamp));
387  }
388
389  return true;
390}
391
392void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
393                                  const TimeTicks& timestamp) {
394  if (!IsValidFormDataVector(forms))
395    return;
396
397  if (!driver_->RendererIsAvailable())
398    return;
399
400  bool enabled = IsAutofillEnabled();
401  if (!has_logged_autofill_enabled_) {
402    metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
403    has_logged_autofill_enabled_ = true;
404  }
405
406  if (!enabled)
407    return;
408
409  for (size_t i = 0; i < forms.size(); ++i) {
410    forms_loaded_timestamps_[forms[i]] = timestamp;
411  }
412
413  ParseForms(forms);
414}
415
416void AutofillManager::OnTextFieldDidChange(const FormData& form,
417                                           const FormFieldData& field,
418                                           const TimeTicks& timestamp) {
419  if (!IsValidFormData(form) || !IsValidFormFieldData(field))
420    return;
421
422  FormStructure* form_structure = NULL;
423  AutofillField* autofill_field = NULL;
424  if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
425    return;
426
427  if (!user_did_type_) {
428    user_did_type_ = true;
429    metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
430  }
431
432  if (autofill_field->is_autofilled) {
433    autofill_field->is_autofilled = false;
434    metric_logger_->LogUserHappinessMetric(
435        AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
436
437    if (!user_did_edit_autofilled_field_) {
438      user_did_edit_autofilled_field_ = true;
439      metric_logger_->LogUserHappinessMetric(
440          AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE);
441    }
442  }
443
444  UpdateInitialInteractionTimestamp(timestamp);
445}
446
447void AutofillManager::OnQueryFormFieldAutofill(int query_id,
448                                               const FormData& form,
449                                               const FormFieldData& field,
450                                               const gfx::RectF& bounding_box,
451                                               bool display_warning) {
452  if (!IsValidFormData(form) || !IsValidFormFieldData(field))
453    return;
454
455  std::vector<base::string16> values;
456  std::vector<base::string16> labels;
457  std::vector<base::string16> icons;
458  std::vector<int> unique_ids;
459
460  external_delegate_->OnQuery(query_id,
461                              form,
462                              field,
463                              bounding_box,
464                              display_warning);
465  FormStructure* form_structure = NULL;
466  AutofillField* autofill_field = NULL;
467  if (RefreshDataModels() &&
468      driver_->RendererIsAvailable() &&
469      GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
470      // Don't send suggestions for forms that aren't auto-fillable.
471      form_structure->IsAutofillable()) {
472    AutofillType type = autofill_field->Type();
473    bool is_filling_credit_card = (type.group() == CREDIT_CARD);
474    if (is_filling_credit_card) {
475      GetCreditCardSuggestions(
476          field, type, &values, &labels, &icons, &unique_ids);
477    } else {
478      GetProfileSuggestions(*form_structure,
479                            field,
480                            *autofill_field,
481                            &values,
482                            &labels,
483                            &icons,
484                            &unique_ids);
485    }
486
487    DCHECK_EQ(values.size(), labels.size());
488    DCHECK_EQ(values.size(), icons.size());
489    DCHECK_EQ(values.size(), unique_ids.size());
490
491    if (!values.empty()) {
492      // Don't provide Autofill suggestions when Autofill is disabled, and don't
493      // provide credit card suggestions for non-HTTPS pages. However, provide a
494      // warning to the user in these cases.
495      int warning = 0;
496      if (is_filling_credit_card && !FormIsHTTPS(*form_structure))
497        warning = IDS_AUTOFILL_WARNING_INSECURE_CONNECTION;
498      if (warning) {
499        values.assign(1, l10n_util::GetStringUTF16(warning));
500        labels.assign(1, base::string16());
501        icons.assign(1, base::string16());
502        unique_ids.assign(1, POPUP_ITEM_ID_WARNING_MESSAGE);
503      } else {
504        bool section_is_autofilled =
505            SectionIsAutofilled(*form_structure, form,
506                                autofill_field->section());
507        if (section_is_autofilled) {
508          // If the relevant section is auto-filled and the renderer is querying
509          // for suggestions, then the user is editing the value of a field.
510          // In this case, mimic autocomplete: don't display labels or icons,
511          // as that information is redundant.
512          labels.assign(labels.size(), base::string16());
513          icons.assign(icons.size(), base::string16());
514        }
515
516        // When filling credit card suggestions, the values and labels are
517        // typically obfuscated, which makes detecting duplicates hard.  Since
518        // duplicates only tend to be a problem when filling address forms
519        // anyway, only don't de-dup credit card suggestions.
520        if (!is_filling_credit_card)
521          RemoveDuplicateSuggestions(&values, &labels, &icons, &unique_ids);
522
523        // The first time we show suggestions on this page, log the number of
524        // suggestions shown.
525        if (!has_logged_address_suggestions_count_ && !section_is_autofilled) {
526          metric_logger_->LogAddressSuggestionsCount(values.size());
527          has_logged_address_suggestions_count_ = true;
528        }
529      }
530    }
531  }
532
533  // Add the results from AutoComplete.  They come back asynchronously, so we
534  // hand off what we generated and they will send the results back to the
535  // renderer.
536  autocomplete_history_manager_->OnGetAutocompleteSuggestions(
537      query_id, field.name, field.value, field.form_control_type, values,
538      labels, icons, unique_ids);
539}
540
541void AutofillManager::FillOrPreviewForm(
542    AutofillDriver::RendererFormDataAction action,
543    int query_id,
544    const FormData& form,
545    const FormFieldData& field,
546    int unique_id) {
547  if (!IsValidFormData(form) || !IsValidFormFieldData(field))
548    return;
549
550  const AutofillDataModel* data_model = NULL;
551  size_t variant = 0;
552  FormStructure* form_structure = NULL;
553  AutofillField* autofill_field = NULL;
554  bool is_credit_card = false;
555  // NOTE: RefreshDataModels may invalidate |data_model| because it causes the
556  // PersonalDataManager to reload Mac address book entries. Thus it must come
557  // before GetProfileOrCreditCard.
558  if (!RefreshDataModels() ||
559      !driver_->RendererIsAvailable() ||
560      !GetProfileOrCreditCard(
561          unique_id, &data_model, &variant, &is_credit_card) ||
562      !GetCachedFormAndField(form, field, &form_structure, &autofill_field))
563    return;
564
565  DCHECK(form_structure);
566  DCHECK(autofill_field);
567
568  FormData result = form;
569
570  base::string16 profile_full_name;
571  std::string profile_language_code;
572  if (!is_credit_card) {
573    profile_full_name = data_model->GetInfo(
574        AutofillType(NAME_FULL), app_locale_);
575    profile_language_code =
576        static_cast<const AutofillProfile*>(data_model)->language_code();
577  }
578
579  // If the relevant section is auto-filled, we should fill |field| but not the
580  // rest of the form.
581  if (SectionIsAutofilled(*form_structure, form, autofill_field->section())) {
582    for (std::vector<FormFieldData>::iterator iter = result.fields.begin();
583         iter != result.fields.end(); ++iter) {
584      if ((*iter) == field) {
585        base::string16 value = data_model->GetInfoForVariant(
586            autofill_field->Type(), variant, app_locale_);
587        if (AutofillField::FillFormField(*autofill_field,
588                                         value,
589                                         profile_language_code,
590                                         app_locale_,
591                                         &(*iter))) {
592          // Mark the cached field as autofilled, so that we can detect when a
593          // user edits an autofilled field (for metrics).
594          autofill_field->is_autofilled = true;
595
596          // Mark the field as autofilled when a non-empty value is assigned to
597          // it. This allows the renderer to distinguish autofilled fields from
598          // fields with non-empty values, such as select-one fields.
599          iter->is_autofilled = true;
600
601          if (!is_credit_card && !value.empty())
602            client_->DidFillOrPreviewField(value, profile_full_name);
603        }
604        break;
605      }
606    }
607
608    driver_->SendFormDataToRenderer(query_id, action, result);
609    return;
610  }
611
612  // Cache the field type for the field from which the user initiated autofill.
613  FieldTypeGroup initiating_group_type = autofill_field->Type().group();
614  DCHECK_EQ(form_structure->field_count(), form.fields.size());
615  for (size_t i = 0; i < form_structure->field_count(); ++i) {
616    if (form_structure->field(i)->section() != autofill_field->section())
617      continue;
618
619    DCHECK_EQ(*form_structure->field(i), result.fields[i]);
620
621    const AutofillField* cached_field = form_structure->field(i);
622    FieldTypeGroup field_group_type = cached_field->Type().group();
623    if (field_group_type != NO_GROUP) {
624      // If the field being filled is either
625      //   (a) the field that the user initiated the fill from, or
626      //   (b) part of the same logical unit, e.g. name or phone number,
627      // then take the multi-profile "variant" into account.
628      // Otherwise fill with the default (zeroth) variant.
629      size_t use_variant = 0;
630      if (result.fields[i] == field ||
631          field_group_type == initiating_group_type) {
632        use_variant = variant;
633      }
634      base::string16 value = data_model->GetInfoForVariant(
635          cached_field->Type(), use_variant, app_locale_);
636
637      // Must match ForEachMatchingFormField() in form_autofill_util.cc.
638      // Only notify autofilling of empty fields and the field that initiated
639      // the filling (note that "select-one" controls may not be empty but will
640      // still be autofilled).
641      bool should_notify =
642          !is_credit_card &&
643          !value.empty() &&
644          (result.fields[i] == field ||
645           result.fields[i].form_control_type == "select-one" ||
646           result.fields[i].value.empty());
647      if (AutofillField::FillFormField(*cached_field,
648                                       value,
649                                       profile_language_code,
650                                       app_locale_,
651                                       &result.fields[i])) {
652        // Mark the cached field as autofilled, so that we can detect when a
653        // user edits an autofilled field (for metrics).
654        form_structure->field(i)->is_autofilled = true;
655
656        // Mark the field as autofilled when a non-empty value is assigned to
657        // it. This allows the renderer to distinguish autofilled fields from
658        // fields with non-empty values, such as select-one fields.
659        result.fields[i].is_autofilled = true;
660
661        if (should_notify)
662          client_->DidFillOrPreviewField(value, profile_full_name);
663      }
664    }
665  }
666
667  autofilled_form_signatures_.push_front(form_structure->FormSignature());
668  // Only remember the last few forms that we've seen, both to avoid false
669  // positives and to avoid wasting memory.
670  if (autofilled_form_signatures_.size() > kMaxRecentFormSignaturesToRemember)
671    autofilled_form_signatures_.pop_back();
672
673  driver_->SendFormDataToRenderer(query_id, action, result);
674}
675
676void AutofillManager::OnDidPreviewAutofillFormData() {
677  if (test_delegate_)
678    test_delegate_->DidPreviewFormData();
679}
680
681void AutofillManager::OnDidFillAutofillFormData(const TimeTicks& timestamp) {
682  if (test_delegate_)
683    test_delegate_->DidFillFormData();
684
685  metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
686  if (!user_did_autofill_) {
687    user_did_autofill_ = true;
688    metric_logger_->LogUserHappinessMetric(
689        AutofillMetrics::USER_DID_AUTOFILL_ONCE);
690  }
691
692  UpdateInitialInteractionTimestamp(timestamp);
693}
694
695void AutofillManager::DidShowSuggestions(bool is_new_popup) {
696  if (test_delegate_)
697    test_delegate_->DidShowSuggestions();
698
699  if (is_new_popup) {
700    metric_logger_->LogUserHappinessMetric(AutofillMetrics::SUGGESTIONS_SHOWN);
701
702    if (!did_show_suggestions_) {
703      did_show_suggestions_ = true;
704      metric_logger_->LogUserHappinessMetric(
705          AutofillMetrics::SUGGESTIONS_SHOWN_ONCE);
706    }
707  }
708}
709
710void AutofillManager::OnHidePopup() {
711  if (!IsAutofillEnabled())
712    return;
713
714  autocomplete_history_manager_->CancelPendingQuery();
715  client_->HideAutofillPopup();
716}
717
718void AutofillManager::RemoveAutofillProfileOrCreditCard(int unique_id) {
719  const AutofillDataModel* data_model = NULL;
720  size_t variant = 0;
721  bool unused_is_credit_card = false;
722  if (!GetProfileOrCreditCard(
723          unique_id, &data_model, &variant, &unused_is_credit_card)) {
724    NOTREACHED();
725    return;
726  }
727
728  // TODO(csharp): If we are dealing with a variant only the variant should
729  // be deleted, instead of doing nothing.
730  // http://crbug.com/124211
731  if (variant != 0)
732    return;
733
734  personal_data_->RemoveByGUID(data_model->guid());
735}
736
737void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
738                                              const base::string16& value) {
739  autocomplete_history_manager_->OnRemoveAutocompleteEntry(name, value);
740}
741
742const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
743  return form_structures_.get();
744}
745
746void AutofillManager::SetTestDelegate(AutofillManagerTestDelegate* delegate) {
747  test_delegate_ = delegate;
748}
749
750void AutofillManager::OnSetDataList(const std::vector<base::string16>& values,
751                                    const std::vector<base::string16>& labels) {
752  if (!IsValidString16Vector(values) ||
753      !IsValidString16Vector(labels) ||
754      values.size() != labels.size())
755    return;
756
757  external_delegate_->SetCurrentDataListValues(values, labels);
758}
759
760void AutofillManager::OnLoadedServerPredictions(
761    const std::string& response_xml) {
762  // Parse and store the server predictions.
763  FormStructure::ParseQueryResponse(response_xml,
764                                    form_structures_.get(),
765                                    *metric_logger_);
766
767  // Forward form structures to the password generation manager to detect
768  // account creation forms.
769  client_->DetectAccountCreationForms(form_structures_.get());
770
771  // If the corresponding flag is set, annotate forms with the predicted types.
772  driver_->SendAutofillTypePredictionsToRenderer(form_structures_.get());
773}
774
775void AutofillManager::OnDidEndTextFieldEditing() {
776  external_delegate_->DidEndTextFieldEditing();
777}
778
779bool AutofillManager::IsAutofillEnabled() const {
780  return client_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
781}
782
783void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
784  scoped_ptr<CreditCard> imported_credit_card;
785  if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
786    return;
787
788  // If credit card information was submitted, we need to confirm whether to
789  // save it.
790  if (imported_credit_card) {
791    client_->ConfirmSaveCreditCard(
792        *metric_logger_,
793        base::Bind(
794            base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
795            base::Unretained(personal_data_),
796            *imported_credit_card));
797  }
798}
799
800// Note that |submitted_form| is passed as a pointer rather than as a reference
801// so that we can get memory management right across threads.  Note also that we
802// explicitly pass in all the time stamps of interest, as the cached ones might
803// get reset before this method executes.
804void AutofillManager::UploadFormDataAsyncCallback(
805    const FormStructure* submitted_form,
806    const TimeTicks& load_time,
807    const TimeTicks& interaction_time,
808    const TimeTicks& submission_time) {
809  submitted_form->LogQualityMetrics(*metric_logger_,
810                                    load_time,
811                                    interaction_time,
812                                    submission_time);
813
814  if (submitted_form->ShouldBeCrowdsourced())
815    UploadFormData(*submitted_form);
816}
817
818void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
819  if (!download_manager_)
820    return;
821
822  // Check if the form is among the forms that were recently auto-filled.
823  bool was_autofilled = false;
824  std::string form_signature = submitted_form.FormSignature();
825  for (std::list<std::string>::const_iterator it =
826           autofilled_form_signatures_.begin();
827       it != autofilled_form_signatures_.end() && !was_autofilled;
828       ++it) {
829    if (*it == form_signature)
830      was_autofilled = true;
831  }
832
833  ServerFieldTypeSet non_empty_types;
834  personal_data_->GetNonEmptyTypes(&non_empty_types);
835
836  download_manager_->StartUploadRequest(submitted_form, was_autofilled,
837                                        non_empty_types);
838}
839
840bool AutofillManager::UploadPasswordForm(
841    const FormData& form,
842    const ServerFieldType& password_type) {
843  FormStructure form_structure(form);
844
845  if (!ShouldUploadForm(form_structure))
846    return false;
847
848  if (!form_structure.ShouldBeCrowdsourced())
849    return false;
850
851  // Find the first password field to label. We don't try to label anything
852  // else.
853  bool found_password_field = false;
854  for (size_t i = 0; i < form_structure.field_count(); ++i) {
855    AutofillField* field = form_structure.field(i);
856
857    ServerFieldTypeSet types;
858    if (!found_password_field && field->form_control_type == "password") {
859      types.insert(password_type);
860      found_password_field = true;
861    } else {
862      types.insert(UNKNOWN_TYPE);
863    }
864    field->set_possible_types(types);
865  }
866  DCHECK(found_password_field);
867
868  // Only one field type should be present.
869  ServerFieldTypeSet available_field_types;
870  available_field_types.insert(password_type);
871
872  // Force uploading as these events are relatively rare and we want to make
873  // sure to receive them. It also makes testing easier if these requests
874  // always pass.
875  form_structure.set_upload_required(UPLOAD_REQUIRED);
876
877  if (!download_manager_)
878    return false;
879
880  return download_manager_->StartUploadRequest(form_structure,
881                                               false /* was_autofilled */,
882                                               available_field_types);
883}
884
885void AutofillManager::Reset() {
886  form_structures_.clear();
887  has_logged_autofill_enabled_ = false;
888  has_logged_address_suggestions_count_ = false;
889  did_show_suggestions_ = false;
890  user_did_type_ = false;
891  user_did_autofill_ = false;
892  user_did_edit_autofilled_field_ = false;
893  forms_loaded_timestamps_.clear();
894  initial_interaction_timestamp_ = TimeTicks();
895  external_delegate_->Reset();
896}
897
898AutofillManager::AutofillManager(AutofillDriver* driver,
899                                 AutofillClient* client,
900                                 PersonalDataManager* personal_data)
901    : driver_(driver),
902      client_(client),
903      app_locale_("en-US"),
904      personal_data_(personal_data),
905      autocomplete_history_manager_(
906          new AutocompleteHistoryManager(driver, client)),
907      metric_logger_(new AutofillMetrics),
908      has_logged_autofill_enabled_(false),
909      has_logged_address_suggestions_count_(false),
910      did_show_suggestions_(false),
911      user_did_type_(false),
912      user_did_autofill_(false),
913      user_did_edit_autofilled_field_(false),
914      external_delegate_(NULL),
915      test_delegate_(NULL),
916      weak_ptr_factory_(this) {
917  DCHECK(driver_);
918  DCHECK(client_);
919}
920
921void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
922  metric_logger_.reset(metric_logger);
923}
924
925bool AutofillManager::RefreshDataModels() const {
926  if (!IsAutofillEnabled())
927    return false;
928
929  // No autofill data to return if the profiles are empty.
930  if (personal_data_->GetProfiles().empty() &&
931      personal_data_->GetCreditCards().empty()) {
932    return false;
933  }
934
935  return true;
936}
937
938bool AutofillManager::GetProfileOrCreditCard(
939    int unique_id,
940    const AutofillDataModel** data_model,
941    size_t* variant,
942    bool* is_credit_card) const {
943  // Unpack the |unique_id| into component parts.
944  GUIDPair credit_card_guid;
945  GUIDPair profile_guid;
946  UnpackGUIDs(unique_id, &credit_card_guid, &profile_guid);
947  DCHECK(!base::IsValidGUID(credit_card_guid.first) ||
948         !base::IsValidGUID(profile_guid.first));
949  *is_credit_card = false;
950
951  // Find the profile that matches the |profile_guid|, if one is specified.
952  // Otherwise find the credit card that matches the |credit_card_guid|,
953  // if specified.
954  if (base::IsValidGUID(profile_guid.first)) {
955    *data_model = personal_data_->GetProfileByGUID(profile_guid.first);
956    *variant = profile_guid.second;
957  } else if (base::IsValidGUID(credit_card_guid.first)) {
958    *data_model = personal_data_->GetCreditCardByGUID(credit_card_guid.first);
959    *variant = credit_card_guid.second;
960    *is_credit_card = true;
961  }
962
963  return !!*data_model;
964}
965
966bool AutofillManager::FindCachedForm(const FormData& form,
967                                     FormStructure** form_structure) const {
968  // Find the FormStructure that corresponds to |form|.
969  // Scan backward through the cached |form_structures_|, as updated versions of
970  // forms are added to the back of the list, whereas original versions of these
971  // forms might appear toward the beginning of the list.  The communication
972  // protocol with the crowdsourcing server does not permit us to discard the
973  // original versions of the forms.
974  *form_structure = NULL;
975  for (std::vector<FormStructure*>::const_reverse_iterator iter =
976           form_structures_.rbegin();
977       iter != form_structures_.rend(); ++iter) {
978    if (**iter == form) {
979      *form_structure = *iter;
980
981      // The same form might be cached with multiple field counts: in some
982      // cases, non-autofillable fields are filtered out, whereas in other cases
983      // they are not.  To avoid thrashing the cache, keep scanning until we
984      // find a cached version with the same number of fields, if there is one.
985      if ((*iter)->field_count() == form.fields.size())
986        break;
987    }
988  }
989
990  if (!(*form_structure))
991    return false;
992
993  return true;
994}
995
996bool AutofillManager::GetCachedFormAndField(const FormData& form,
997                                            const FormFieldData& field,
998                                            FormStructure** form_structure,
999                                            AutofillField** autofill_field) {
1000  // Find the FormStructure that corresponds to |form|.
1001  // If we do not have this form in our cache but it is parseable, we'll add it
1002  // in the call to |UpdateCachedForm()|.
1003  if (!FindCachedForm(form, form_structure) &&
1004      !FormStructure(form).ShouldBeParsed()) {
1005    return false;
1006  }
1007
1008  // Update the cached form to reflect any dynamic changes to the form data, if
1009  // necessary.
1010  if (!UpdateCachedForm(form, *form_structure, form_structure))
1011    return false;
1012
1013  // No data to return if there are no auto-fillable fields.
1014  if (!(*form_structure)->autofill_count())
1015    return false;
1016
1017  // Find the AutofillField that corresponds to |field|.
1018  *autofill_field = NULL;
1019  for (std::vector<AutofillField*>::const_iterator iter =
1020           (*form_structure)->begin();
1021       iter != (*form_structure)->end(); ++iter) {
1022    if ((**iter) == field) {
1023      *autofill_field = *iter;
1024      break;
1025    }
1026  }
1027
1028  // Even though we always update the cache, the field might not exist if the
1029  // website disables autocomplete while the user is interacting with the form.
1030  // See http://crbug.com/160476
1031  return *autofill_field != NULL;
1032}
1033
1034bool AutofillManager::UpdateCachedForm(const FormData& live_form,
1035                                       const FormStructure* cached_form,
1036                                       FormStructure** updated_form) {
1037  bool needs_update =
1038      (!cached_form ||
1039       live_form.fields.size() != cached_form->field_count());
1040  for (size_t i = 0; !needs_update && i < cached_form->field_count(); ++i) {
1041    needs_update = *cached_form->field(i) != live_form.fields[i];
1042  }
1043
1044  if (!needs_update)
1045    return true;
1046
1047  if (form_structures_.size() >= kMaxFormCacheSize)
1048    return false;
1049
1050  // Add the new or updated form to our cache.
1051  form_structures_.push_back(new FormStructure(live_form));
1052  *updated_form = *form_structures_.rbegin();
1053  (*updated_form)->DetermineHeuristicTypes(*metric_logger_);
1054
1055  // If we have cached data, propagate it to the updated form.
1056  if (cached_form) {
1057    std::map<base::string16, const AutofillField*> cached_fields;
1058    for (size_t i = 0; i < cached_form->field_count(); ++i) {
1059      const AutofillField* field = cached_form->field(i);
1060      cached_fields[field->unique_name()] = field;
1061    }
1062
1063    for (size_t i = 0; i < (*updated_form)->field_count(); ++i) {
1064      AutofillField* field = (*updated_form)->field(i);
1065      std::map<base::string16, const AutofillField*>::iterator cached_field =
1066          cached_fields.find(field->unique_name());
1067      if (cached_field != cached_fields.end()) {
1068        field->set_server_type(cached_field->second->server_type());
1069        field->is_autofilled = cached_field->second->is_autofilled;
1070      }
1071    }
1072
1073    // Note: We _must not_ remove the original version of the cached form from
1074    // the list of |form_structures_|.  Otherwise, we break parsing of the
1075    // crowdsourcing server's response to our query.
1076  }
1077
1078  // Annotate the updated form with its predicted types.
1079  std::vector<FormStructure*> forms(1, *updated_form);
1080  driver_->SendAutofillTypePredictionsToRenderer(forms);
1081
1082  return true;
1083}
1084
1085void AutofillManager::GetProfileSuggestions(
1086    const FormStructure& form,
1087    const FormFieldData& field,
1088    const AutofillField& autofill_field,
1089    std::vector<base::string16>* values,
1090    std::vector<base::string16>* labels,
1091    std::vector<base::string16>* icons,
1092    std::vector<int>* unique_ids) const {
1093  std::vector<ServerFieldType> field_types(form.field_count());
1094  for (size_t i = 0; i < form.field_count(); ++i) {
1095    field_types.push_back(form.field(i)->Type().GetStorableType());
1096  }
1097  std::vector<GUIDPair> guid_pairs;
1098
1099  personal_data_->GetProfileSuggestions(
1100      autofill_field.Type(), field.value, field.is_autofilled, field_types,
1101      base::Callback<bool(const AutofillProfile&)>(),
1102      values, labels, icons, &guid_pairs);
1103
1104  // Adjust phone number to display in prefix/suffix case.
1105  if (autofill_field.Type().GetStorableType() == PHONE_HOME_NUMBER) {
1106    for (size_t i = 0; i < values->size(); ++i) {
1107      (*values)[i] = AutofillField::GetPhoneNumberValue(
1108          autofill_field, (*values)[i], field);
1109    }
1110  }
1111
1112  for (size_t i = 0; i < guid_pairs.size(); ++i) {
1113    unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
1114                                    guid_pairs[i]));
1115  }
1116}
1117
1118void AutofillManager::GetCreditCardSuggestions(
1119    const FormFieldData& field,
1120    const AutofillType& type,
1121    std::vector<base::string16>* values,
1122    std::vector<base::string16>* labels,
1123    std::vector<base::string16>* icons,
1124    std::vector<int>* unique_ids) const {
1125  std::vector<GUIDPair> guid_pairs;
1126  personal_data_->GetCreditCardSuggestions(
1127      type, field.value, values, labels, icons, &guid_pairs);
1128
1129  for (size_t i = 0; i < guid_pairs.size(); ++i) {
1130    unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
1131  }
1132}
1133
1134void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
1135  std::vector<FormStructure*> non_queryable_forms;
1136  for (std::vector<FormData>::const_iterator iter = forms.begin();
1137       iter != forms.end(); ++iter) {
1138    scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
1139    if (!form_structure->ShouldBeParsed())
1140      continue;
1141
1142    form_structure->DetermineHeuristicTypes(*metric_logger_);
1143
1144    // Set aside forms with method GET or author-specified types, so that they
1145    // are not included in the query to the server.
1146    if (form_structure->ShouldBeCrowdsourced())
1147      form_structures_.push_back(form_structure.release());
1148    else
1149      non_queryable_forms.push_back(form_structure.release());
1150  }
1151
1152  if (!form_structures_.empty() && download_manager_) {
1153    // Query the server if we have at least one of the forms were parsed.
1154    download_manager_->StartQueryRequest(form_structures_.get(),
1155                                        *metric_logger_);
1156  }
1157
1158  for (std::vector<FormStructure*>::const_iterator iter =
1159           non_queryable_forms.begin();
1160       iter != non_queryable_forms.end(); ++iter) {
1161    form_structures_.push_back(*iter);
1162  }
1163
1164  if (!form_structures_.empty())
1165    metric_logger_->LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
1166
1167  // For the |non_queryable_forms|, we have all the field type info we're ever
1168  // going to get about them.  For the other forms, we'll wait until we get a
1169  // response from the server.
1170  driver_->SendAutofillTypePredictionsToRenderer(non_queryable_forms);
1171}
1172
1173int AutofillManager::GUIDToID(const GUIDPair& guid) const {
1174  if (!base::IsValidGUID(guid.first))
1175    return 0;
1176
1177  std::map<GUIDPair, int>::const_iterator iter = guid_id_map_.find(guid);
1178  if (iter == guid_id_map_.end()) {
1179    int id = guid_id_map_.size() + 1;
1180    guid_id_map_[guid] = id;
1181    id_guid_map_[id] = guid;
1182    return id;
1183  } else {
1184    return iter->second;
1185  }
1186}
1187
1188const GUIDPair AutofillManager::IDToGUID(int id) const {
1189  if (id == 0)
1190    return GUIDPair(std::string(), 0);
1191
1192  std::map<int, GUIDPair>::const_iterator iter = id_guid_map_.find(id);
1193  if (iter == id_guid_map_.end()) {
1194    NOTREACHED();
1195    return GUIDPair(std::string(), 0);
1196  }
1197
1198  return iter->second;
1199}
1200
1201// When sending IDs (across processes) to the renderer we pack credit card and
1202// profile IDs into a single integer.  Credit card IDs are sent in the high
1203// word and profile IDs are sent in the low word.
1204int AutofillManager::PackGUIDs(const GUIDPair& cc_guid,
1205                               const GUIDPair& profile_guid) const {
1206  int cc_id = GUIDToID(cc_guid);
1207  int profile_id = GUIDToID(profile_guid);
1208
1209  DCHECK(cc_id <= std::numeric_limits<unsigned short>::max());
1210  DCHECK(profile_id <= std::numeric_limits<unsigned short>::max());
1211
1212  return cc_id << std::numeric_limits<unsigned short>::digits | profile_id;
1213}
1214
1215// When receiving IDs (across processes) from the renderer we unpack credit card
1216// and profile IDs from a single integer.  Credit card IDs are stored in the
1217// high word and profile IDs are stored in the low word.
1218void AutofillManager::UnpackGUIDs(int id,
1219                                  GUIDPair* cc_guid,
1220                                  GUIDPair* profile_guid) const {
1221  int cc_id = id >> std::numeric_limits<unsigned short>::digits &
1222      std::numeric_limits<unsigned short>::max();
1223  int profile_id = id & std::numeric_limits<unsigned short>::max();
1224
1225  *cc_guid = IDToGUID(cc_id);
1226  *profile_guid = IDToGUID(profile_id);
1227}
1228
1229void AutofillManager::UpdateInitialInteractionTimestamp(
1230    const TimeTicks& interaction_timestamp) {
1231  if (initial_interaction_timestamp_.is_null() ||
1232      interaction_timestamp < initial_interaction_timestamp_) {
1233    initial_interaction_timestamp_ = interaction_timestamp;
1234  }
1235}
1236
1237bool AutofillManager::ShouldUploadForm(const FormStructure& form) {
1238  if (!IsAutofillEnabled())
1239    return false;
1240
1241  if (driver_->IsOffTheRecord())
1242    return false;
1243
1244  // Disregard forms that we wouldn't ever autofill in the first place.
1245  if (!form.ShouldBeParsed())
1246    return false;
1247
1248  return true;
1249}
1250
1251}  // namespace autofill
1252