autofill_manager.cc revision 4ec1b5c8bfb53483c6105db0656c81740f798f10 
1// Copyright (c) 2011 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 "chrome/browser/autofill/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/logging.h"
15#include "base/string16.h"
16#include "base/string_util.h"
17#include "base/utf_string_conversions.h"
18#ifndef ANDROID
19#include "chrome/browser/autocomplete_history_manager.h"
20#include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
21#endif
22#include "chrome/browser/autofill/autofill_field.h"
23#include "chrome/browser/autofill/autofill_metrics.h"
24#include "chrome/browser/autofill/autofill_profile.h"
25#include "chrome/browser/autofill/autofill_type.h"
26#include "chrome/browser/autofill/credit_card.h"
27#include "chrome/browser/autofill/form_structure.h"
28#include "chrome/browser/autofill/personal_data_manager.h"
29#include "chrome/browser/autofill/phone_number.h"
30#include "chrome/browser/autofill/select_control_handler.h"
31#include "chrome/browser/prefs/pref_service.h"
32#include "chrome/browser/profiles/profile.h"
33#ifndef ANDROID
34#include "chrome/browser/ui/browser.h"
35#include "chrome/browser/ui/browser_list.h"
36#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
37#include "chrome/common/autofill_messages.h"
38#endif
39#include "chrome/common/guid.h"
40#include "chrome/common/pref_names.h"
41#include "chrome/common/url_constants.h"
42#ifndef ANDROID
43#include "content/browser/renderer_host/render_view_host.h"
44#include "content/browser/tab_contents/tab_contents.h"
45#include "content/common/notification_service.h"
46#include "content/common/notification_source.h"
47#include "content/common/notification_type.h"
48#endif
49#include "googleurl/src/gurl.h"
50#include "grit/generated_resources.h"
51#ifndef ANDROID
52#include "ipc/ipc_message_macros.h"
53#endif
54#include "ui/base/l10n/l10n_util.h"
55#include "webkit/glue/form_data.h"
56#include "webkit/glue/form_field.h"
57
58using webkit_glue::FormData;
59using webkit_glue::FormField;
60
61namespace {
62
63// We only send a fraction of the forms to upload server.
64// The rate for positive/negative matches potentially could be different.
65const double kAutofillPositiveUploadRateDefaultValue = 0.20;
66const double kAutofillNegativeUploadRateDefaultValue = 0.20;
67
68const string16::value_type kCreditCardPrefix[] = {'*', 0};
69
70// Removes duplicate suggestions whilst preserving their original order.
71void RemoveDuplicateSuggestions(std::vector<string16>* values,
72                                std::vector<string16>* labels,
73                                std::vector<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<string16, string16> > seen_suggestions;
80  std::vector<string16> values_copy;
81  std::vector<string16> labels_copy;
82  std::vector<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<string16, string16> suggestion((*values)[i], (*labels)[i]);
87    if (seen_suggestions.insert(suggestion).second) {
88      values_copy.push_back((*values)[i]);
89      labels_copy.push_back((*labels)[i]);
90      icons_copy.push_back((*icons)[i]);
91      unique_ids_copy.push_back((*unique_ids)[i]);
92    }
93  }
94
95  values->swap(values_copy);
96  labels->swap(labels_copy);
97  icons->swap(icons_copy);
98  unique_ids->swap(unique_ids_copy);
99}
100
101// Precondition: |form| should be the cached version of the form that is to be
102// autofilled, and |field| should be the field in the |form| that corresponds to
103// the initiating field. |is_filling_credit_card| should be true if filling
104// credit card data, false otherwise.
105// Fills |section_start| and |section_end| so that [section_start, section_end)
106// gives the bounds of logical section within |form| that includes |field|.
107// Logical sections are identified by two heuristics:
108//  1. The fields in the section must all be profile or credit card fields,
109//     depending on whether |is_filling_credit_card| is true.
110//  2. A logical section should not include multiple fields of the same autofill
111//     type (except for phone/fax numbers, as described below).
112void FindSectionBounds(const FormStructure& form,
113                       const AutofillField& field,
114                       bool is_filling_credit_card,
115                       size_t* section_start,
116                       size_t* section_end) {
117  DCHECK(section_start);
118  DCHECK(section_end);
119
120  // By default, the relevant section is the entire form.
121  *section_start = 0;
122  *section_end = form.field_count();
123
124  std::set<AutofillFieldType> seen_types;
125  bool initiating_field_is_in_current_section = false;
126  for (size_t i = 0; i < form.field_count(); ++i) {
127    const AutofillField* current_field = form.field(i);
128    const AutofillFieldType current_type =
129        AutofillType::GetEquivalentFieldType(current_field->type());
130
131    // Fields of unknown type don't help us to distinguish sections.
132    if (current_type == UNKNOWN_TYPE)
133      continue;
134
135    bool already_saw_current_type = seen_types.count(current_type) > 0;
136    // Forms often ask for multiple phone numbers -- e.g. both a daytime and
137    // evening phone number.  Our phone and fax number detection is also
138    // generally a little off.  Hence, ignore both field types as a signal here.
139    // Likewise, forms often ask for multiple email addresses, so ignore this
140    // field type as well.
141    AutofillType::FieldTypeGroup current_type_group =
142        AutofillType(current_type).group();
143    if (current_type_group == AutofillType::PHONE_HOME ||
144        current_type_group == AutofillType::PHONE_FAX ||
145        current_type_group == AutofillType::EMAIL)
146      already_saw_current_type = false;
147
148    // If we are filling credit card data, the relevant section should include
149    // only credit card fields; and similarly for profile data.
150    bool is_credit_card_field = current_type_group == AutofillType::CREDIT_CARD;
151    bool is_appropriate_type = is_credit_card_field == is_filling_credit_card;
152
153    if (already_saw_current_type || !is_appropriate_type) {
154      if (initiating_field_is_in_current_section) {
155        // We reached the end of the section containing the initiating field.
156        *section_end = i;
157        break;
158      }
159
160      // We reached the end of a section, so start a new section.
161      seen_types.clear();
162
163      // Only include the current field in the new section if it matches the
164      // type of data we are filling.
165      if (is_appropriate_type) {
166        *section_start = i;
167      } else {
168        *section_start = i + 1;
169        continue;
170      }
171    }
172
173    seen_types.insert(current_type);
174
175    if (current_field == &field)
176      initiating_field_is_in_current_section = true;
177  }
178
179  // We should have found the initiating field.
180  DCHECK(initiating_field_is_in_current_section);
181}
182
183// Precondition: |form_structure| and |form| should correspond to the same
184// logical form. Returns true if the relevant portion of |form| is auto-filled.
185// The "relevant" fields in |form| are ones corresponding to fields in
186// |form_structure| with indices in the range [section_start, section_end).
187bool SectionIsAutofilled(const FormStructure* form_structure,
188                         const webkit_glue::FormData& form,
189                         size_t section_start,
190                         size_t section_end) {
191  // TODO(isherman): It would be nice to share most of this code with the loop
192  // in |FillAutofillFormData()|, but I don't see a particularly clean way to do
193  // that.
194
195  // The list of fields in |form_structure| and |form.fields| often match
196  // directly and we can fill these corresponding fields; however, when the
197  // |form_structure| and |form.fields| do not match directly we search
198  // ahead in the |form_structure| for the matching field.
199  for (size_t i = section_start, j = 0;
200       i < section_end && j < form.fields.size();
201       j++) {
202    size_t k = i;
203
204    // Search forward in the |form_structure| for a corresponding field.
205    while (k < form_structure->field_count() &&
206           *form_structure->field(k) != form.fields[j]) {
207      k++;
208    }
209
210    // If we didn't find a match, continue on to the next |form| field.
211    if (k >= form_structure->field_count())
212      continue;
213
214    AutofillType autofill_type(form_structure->field(k)->type());
215    if (form.fields[j].is_autofilled)
216      return true;
217
218    // We found a matching field in the |form_structure| so we
219    // proceed to the next |form| field, and the next |form_structure|.
220    ++i;
221  }
222
223  return false;
224}
225
226bool FormIsHTTPS(FormStructure* form) {
227  return form->source_url().SchemeIs(chrome::kHttpsScheme);
228}
229
230}  // namespace
231
232AutofillManager::AutofillManager(TabContents* tab_contents)
233    : TabContentsObserver(tab_contents),
234      personal_data_(NULL),
235      download_manager_(tab_contents->profile()),
236      disable_download_manager_requests_(false),
237      metric_logger_(new AutofillMetrics),
238      has_logged_autofill_enabled_(false),
239      has_logged_address_suggestions_count_(false) {
240  DCHECK(tab_contents);
241
242  // |personal_data_| is NULL when using TestTabContents.
243  personal_data_ =
244      tab_contents->profile()->GetOriginalProfile()->GetPersonalDataManager();
245  download_manager_.SetObserver(this);
246}
247
248AutofillManager::~AutofillManager() {
249  download_manager_.SetObserver(NULL);
250}
251
252#ifndef ANDROID
253// static
254void AutofillManager::RegisterBrowserPrefs(PrefService* prefs) {
255  prefs->RegisterDictionaryPref(prefs::kAutofillDialogPlacement);
256}
257#endif
258
259#ifndef ANDROID
260// static
261void AutofillManager::RegisterUserPrefs(PrefService* prefs) {
262  prefs->RegisterBooleanPref(prefs::kAutofillEnabled, true);
263#if defined(OS_MACOSX)
264  prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, true);
265#else
266  prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, false);
267#endif
268  prefs->RegisterDoublePref(prefs::kAutofillPositiveUploadRate,
269                            kAutofillPositiveUploadRateDefaultValue);
270  prefs->RegisterDoublePref(prefs::kAutofillNegativeUploadRate,
271                            kAutofillNegativeUploadRateDefaultValue);
272}
273#endif
274
275#ifndef ANDROID
276void AutofillManager::DidNavigateMainFramePostCommit(
277    const NavigationController::LoadCommittedDetails& details,
278    const ViewHostMsg_FrameNavigate_Params& params) {
279  Reset();
280}
281#endif
282
283#ifndef ANDROID
284bool AutofillManager::OnMessageReceived(const IPC::Message& message) {
285  bool handled = true;
286  IPC_BEGIN_MESSAGE_MAP(AutofillManager, message)
287    IPC_MESSAGE_HANDLER(AutofillHostMsg_FormsSeen, OnFormsSeen)
288    IPC_MESSAGE_HANDLER(AutofillHostMsg_FormSubmitted, OnFormSubmitted)
289    IPC_MESSAGE_HANDLER(AutofillHostMsg_QueryFormFieldAutofill,
290                        OnQueryFormFieldAutofill)
291    IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowAutofillDialog,
292                        OnShowAutofillDialog)
293    IPC_MESSAGE_HANDLER(AutofillHostMsg_FillAutofillFormData,
294                        OnFillAutofillFormData)
295    IPC_MESSAGE_HANDLER(AutofillHostMsg_DidFillAutofillFormData,
296                        OnDidFillAutofillFormData)
297    IPC_MESSAGE_HANDLER(AutofillHostMsg_DidShowAutofillSuggestions,
298                        OnDidShowAutofillSuggestions)
299    IPC_MESSAGE_UNHANDLED(handled = false)
300  IPC_END_MESSAGE_MAP()
301
302  return handled;
303}
304#endif
305
306void AutofillManager::OnFormSubmitted(const FormData& form) {
307  // Let AutoComplete know as well.
308#ifndef ANDROID
309  TabContentsWrapper* wrapper =
310      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents());
311  wrapper->autocomplete_history_manager()->OnFormSubmitted(form);
312#endif
313
314  if (!IsAutofillEnabled())
315    return;
316
317  if (tab_contents()->profile()->IsOffTheRecord())
318    return;
319
320  // Don't save data that was submitted through JavaScript.
321  if (!form.user_submitted)
322    return;
323
324  // Grab a copy of the form data.
325  FormStructure submitted_form(form);
326
327  // Disregard forms that we wouldn't ever autofill in the first place.
328  if (!submitted_form.ShouldBeParsed(true))
329    return;
330
331  // Ignore forms not present in our cache.  These are typically forms with
332  // wonky JavaScript that also makes them not auto-fillable.
333  FormStructure* cached_submitted_form;
334  if (!FindCachedForm(form, &cached_submitted_form))
335    return;
336
337  DeterminePossibleFieldTypesForUpload(&submitted_form);
338  UploadFormData(submitted_form);
339
340  submitted_form.UpdateFromCache(*cached_submitted_form);
341  submitted_form.LogQualityMetrics(*metric_logger_);
342
343  if (!submitted_form.IsAutofillable(true))
344    return;
345
346  ImportFormData(submitted_form);
347}
348
349void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms) {
350  bool enabled = IsAutofillEnabled();
351  if (!has_logged_autofill_enabled_) {
352    metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
353    has_logged_autofill_enabled_ = true;
354  }
355
356  if (!enabled)
357    return;
358
359  ParseForms(forms);
360}
361
362#ifdef ANDROID
363bool AutofillManager::OnQueryFormFieldAutofill(
364#else
365void AutofillManager::OnQueryFormFieldAutofill(
366#endif
367    int query_id,
368    const webkit_glue::FormData& form,
369    const webkit_glue::FormField& field) {
370  std::vector<string16> values;
371  std::vector<string16> labels;
372  std::vector<string16> icons;
373  std::vector<int> unique_ids;
374
375#ifdef ANDROID
376  AutoFillHost* host = NULL;
377#else
378  RenderViewHost* host = NULL;
379#endif
380  FormStructure* form_structure = NULL;
381  AutofillField* autofill_field = NULL;
382  if (GetHost(
383          personal_data_->profiles(), personal_data_->credit_cards(), &host) &&
384      FindCachedFormAndField(form, field, &form_structure, &autofill_field) &&
385      // Don't send suggestions for forms that aren't auto-fillable.
386      form_structure->IsAutofillable(false)) {
387    AutofillFieldType type = autofill_field->type();
388    bool is_filling_credit_card =
389        (AutofillType(type).group() == AutofillType::CREDIT_CARD);
390    if (is_filling_credit_card) {
391      GetCreditCardSuggestions(
392          form_structure, field, type, &values, &labels, &icons, &unique_ids);
393    } else {
394      GetProfileSuggestions(
395          form_structure, field, type, &values, &labels, &icons, &unique_ids);
396    }
397
398    DCHECK_EQ(values.size(), labels.size());
399    DCHECK_EQ(values.size(), icons.size());
400    DCHECK_EQ(values.size(), unique_ids.size());
401
402    if (!values.empty()) {
403#ifndef ANDROID
404      // Don't provide Autofill suggestions when Autofill is disabled, and don't
405      // provide credit card suggestions for non-HTTPS pages. However, provide a
406      // warning to the user in these cases.
407      int warning = 0;
408      if (!form_structure->IsAutofillable(true))
409        warning = IDS_AUTOFILL_WARNING_FORM_DISABLED;
410      else if (is_filling_credit_card && !FormIsHTTPS(form_structure))
411        warning = IDS_AUTOFILL_WARNING_INSECURE_CONNECTION;
412      if (warning) {
413        values.assign(1, l10n_util::GetStringUTF16(warning));
414        labels.assign(1, string16());
415        icons.assign(1, string16());
416        unique_ids.assign(1, -1);
417      } else {
418        size_t section_start, section_end;
419        FindSectionBounds(*form_structure, *autofill_field,
420                          is_filling_credit_card, &section_start, &section_end);
421
422        bool section_is_autofilled = SectionIsAutofilled(form_structure,
423                                                         form,
424                                                         section_start,
425                                                         section_end);
426        if (section_is_autofilled) {
427          // If the relevant section is auto-filled and the renderer is querying
428          // for suggestions, then the user is editing the value of a field.
429          // In this case, mimic autocomplete: don't display labels or icons,
430          // as that information is redundant.
431          labels.assign(labels.size(), string16());
432          icons.assign(icons.size(), string16());
433        }
434
435        // When filling credit card suggestions, the values and labels are
436        // typically obfuscated, which makes detecting duplicates hard.  Since
437        // duplicates only tend to be a problem when filling address forms
438        // anyway, only don't de-dup credit card suggestions.
439        if (!is_filling_credit_card)
440          RemoveDuplicateSuggestions(&values, &labels, &icons, &unique_ids);
441
442        // The first time we show suggestions on this page, log the number of
443        // suggestions shown.
444        if (!has_logged_address_suggestions_count_ && !section_is_autofilled) {
445          metric_logger_->LogAddressSuggestionsCount(values.size());
446          has_logged_address_suggestions_count_ = true;
447        }
448      }
449#endif
450    }
451#ifdef ANDROID
452    else {
453      return false;
454    }
455#endif
456  }
457#ifdef ANDROID
458  else {
459    return false;
460  }
461#endif
462
463#ifdef ANDROID
464  host->AutoFillSuggestionsReturned(values, labels, icons, unique_ids);
465  return true;
466#else
467  // Add the results from AutoComplete.  They come back asynchronously, so we
468  // hand off what we generated and they will send the results back to the
469  // renderer.
470  TabContentsWrapper* wrapper =
471      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents());
472  wrapper->autocomplete_history_manager()->OnGetAutocompleteSuggestions(
473      query_id, field.name, field.value, values, labels, icons, unique_ids);
474#endif
475}
476
477void AutofillManager::OnFillAutofillFormData(int query_id,
478                                             const FormData& form,
479                                             const FormField& field,
480                                             int unique_id) {
481  const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
482  const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
483#ifdef ANDROID
484  AutoFillHost* host = NULL;
485#else
486  RenderViewHost* host = NULL;
487#endif
488  FormStructure* form_structure = NULL;
489  AutofillField* autofill_field = NULL;
490  if (!GetHost(profiles, credit_cards, &host) ||
491      !FindCachedFormAndField(form, field, &form_structure, &autofill_field))
492    return;
493
494  DCHECK(host);
495  DCHECK(form_structure);
496  DCHECK(autofill_field);
497
498  // Unpack the |unique_id| into component parts.
499  GUIDPair cc_guid;
500  GUIDPair profile_guid;
501  UnpackGUIDs(unique_id, &cc_guid, &profile_guid);
502  DCHECK(!guid::IsValidGUID(cc_guid.first) ||
503         !guid::IsValidGUID(profile_guid.first));
504
505  // Find the profile that matches the |profile_id|, if one is specified.
506  const AutofillProfile* profile = NULL;
507  if (guid::IsValidGUID(profile_guid.first)) {
508    for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
509         iter != profiles.end(); ++iter) {
510      if ((*iter)->guid() == profile_guid.first) {
511        profile = *iter;
512        break;
513      }
514    }
515    DCHECK(profile);
516  }
517
518  // Find the credit card that matches the |cc_id|, if one is specified.
519  const CreditCard* credit_card = NULL;
520  if (guid::IsValidGUID(cc_guid.first)) {
521    for (std::vector<CreditCard*>::const_iterator iter = credit_cards.begin();
522         iter != credit_cards.end(); ++iter) {
523      if ((*iter)->guid() == cc_guid.first) {
524        credit_card = *iter;
525        break;
526      }
527    }
528    DCHECK(credit_card);
529  }
530
531  if (!profile && !credit_card)
532    return;
533
534  // Find the section of the form that we are autofilling.
535  size_t section_start, section_end;
536  FindSectionBounds(*form_structure, *autofill_field, (credit_card != NULL),
537                    &section_start, &section_end);
538
539  FormData result = form;
540
541  // If the relevant section is auto-filled, we should fill |field| but not the
542  // rest of the form.
543  if (SectionIsAutofilled(form_structure, form, section_start, section_end)) {
544    for (std::vector<FormField>::iterator iter = result.fields.begin();
545         iter != result.fields.end(); ++iter) {
546      if ((*iter) == field) {
547        AutofillFieldType field_type = autofill_field->type();
548        if (profile) {
549          DCHECK_NE(AutofillType::CREDIT_CARD,
550                    AutofillType(field_type).group());
551          FillFormField(profile, field_type, profile_guid.second, &(*iter));
552        } else {
553          DCHECK_EQ(AutofillType::CREDIT_CARD,
554                    AutofillType(field_type).group());
555          FillCreditCardFormField(credit_card, field_type, &(*iter));
556        }
557        break;
558      }
559    }
560
561#ifdef ANDROID
562    host->AutoFillFormDataFilled(query_id, result);
563#else
564    host->Send(new AutofillMsg_FormDataFilled(host->routing_id(), query_id,
565                                              result));
566#endif
567    return;
568  }
569
570  // The list of fields in |form_structure| and |result.fields| often match
571  // directly and we can fill these corresponding fields; however, when the
572  // |form_structure| and |result.fields| do not match directly we search
573  // ahead in the |form_structure| for the matching field.
574  // See unit tests: AutofillManagerTest.FormChangesRemoveField and
575  // AutofillManagerTest.FormChangesAddField for usage.
576  for (size_t i = section_start, j = 0;
577       i < section_end && j < result.fields.size();
578       j++) {
579    size_t k = i;
580
581    // Search forward in the |form_structure| for a corresponding field.
582    while (k < section_end && *form_structure->field(k) != result.fields[j]) {
583      k++;
584    }
585
586    // If we've found a match then fill the |result| field with the found
587    // field in the |form_structure|.
588    if (k >= section_end)
589      continue;
590
591    AutofillFieldType field_type = form_structure->field(k)->type();
592    FieldTypeGroup field_group_type = AutofillType(field_type).group();
593    if (field_group_type != AutofillType::NO_GROUP) {
594      if (profile) {
595        DCHECK_NE(AutofillType::CREDIT_CARD, field_group_type);
596        // If the field being filled is the field that the user initiated the
597        // fill from, then take the multi-profile "variant" into account.
598        // Otherwise fill with the default (zeroth) variant.
599        if (result.fields[j] == field) {
600          FillFormField(profile, field_type, profile_guid.second,
601                        &result.fields[j]);
602        } else {
603          FillFormField(profile, field_type, 0, &result.fields[j]);
604        }
605      } else {
606        DCHECK_EQ(AutofillType::CREDIT_CARD, field_group_type);
607        FillCreditCardFormField(credit_card, field_type, &result.fields[j]);
608      }
609    }
610
611    // We found a matching field in the |form_structure| so we
612    // proceed to the next |result| field, and the next |form_structure|.
613    ++i;
614  }
615  autofilled_forms_signatures_.push_front(form_structure->FormSignature());
616
617#ifdef ANDROID
618  host->AutoFillFormDataFilled(query_id, result);
619#else
620  host->Send(new AutofillMsg_FormDataFilled(
621      host->routing_id(), query_id, result));
622#endif
623}
624
625void AutofillManager::OnShowAutofillDialog() {
626#ifndef ANDROID
627  Browser* browser = BrowserList::GetLastActive();
628  if (browser)
629    browser->ShowOptionsTab(chrome::kAutofillSubPage);
630#endif
631}
632
633void AutofillManager::OnDidFillAutofillFormData() {
634#ifndef ANDROID
635  NotificationService::current()->Notify(
636      NotificationType::AUTOFILL_DID_FILL_FORM_DATA,
637      Source<RenderViewHost>(tab_contents()->render_view_host()),
638      NotificationService::NoDetails());
639#endif
640}
641
642void AutofillManager::OnDidShowAutofillSuggestions() {
643#ifndef ANDROID
644  NotificationService::current()->Notify(
645      NotificationType::AUTOFILL_DID_SHOW_SUGGESTIONS,
646      Source<RenderViewHost>(tab_contents()->render_view_host()),
647      NotificationService::NoDetails());
648#endif
649}
650
651void AutofillManager::OnLoadedAutofillHeuristics(
652    const std::string& heuristic_xml) {
653  // TODO(jhawkins): Store |upload_required| in the AutofillManager.
654  UploadRequired upload_required;
655  FormStructure::ParseQueryResponse(heuristic_xml,
656                                    form_structures_.get(),
657                                    &upload_required,
658                                    *metric_logger_);
659}
660
661void AutofillManager::OnUploadedAutofillHeuristics(
662    const std::string& form_signature) {
663}
664
665void AutofillManager::OnHeuristicsRequestError(
666    const std::string& form_signature,
667    AutofillDownloadManager::AutofillRequestType request_type,
668    int http_error) {
669}
670
671bool AutofillManager::IsAutofillEnabled() const {
672#ifdef ANDROID
673  // TODO: This should be a setting in the android UI.
674  return true;
675#else
676  return const_cast<AutofillManager*>(this)->tab_contents()->profile()->
677      GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
678#endif
679}
680
681void AutofillManager::DeterminePossibleFieldTypesForUpload(
682    FormStructure* submitted_form) {
683  for (size_t i = 0; i < submitted_form->field_count(); i++) {
684    const AutofillField* field = submitted_form->field(i);
685    FieldTypeSet field_types;
686    personal_data_->GetPossibleFieldTypes(field->value, &field_types);
687
688    DCHECK(!field_types.empty());
689    submitted_form->set_possible_types(i, field_types);
690  }
691}
692
693void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
694  std::vector<const FormStructure*> submitted_forms;
695  submitted_forms.push_back(&submitted_form);
696
697  const CreditCard* imported_credit_card;
698  if (!personal_data_->ImportFormData(submitted_forms, &imported_credit_card))
699    return;
700
701#ifndef ANDROID
702  // If credit card information was submitted, show an infobar to offer to save
703  // it.
704  scoped_ptr<const CreditCard> scoped_credit_card(imported_credit_card);
705  if (imported_credit_card && tab_contents()) {
706    tab_contents()->AddInfoBar(
707        new AutofillCCInfoBarDelegate(tab_contents(),
708                                      scoped_credit_card.release(),
709                                      personal_data_,
710                                      metric_logger_.get()));
711  }
712#endif
713}
714
715void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
716  if (!disable_download_manager_requests_) {
717    bool was_autofilled = false;
718    // Check if the form among last 3 forms that were auto-filled.
719    // Clear older signatures.
720    std::list<std::string>::iterator it;
721    int total_form_checked = 0;
722    for (it = autofilled_forms_signatures_.begin();
723         it != autofilled_forms_signatures_.end() && total_form_checked < 3;
724         ++it, ++total_form_checked) {
725      if (*it == submitted_form.FormSignature())
726        was_autofilled = true;
727    }
728    // Remove outdated form signatures.
729    if (total_form_checked == 3 && it != autofilled_forms_signatures_.end()) {
730      autofilled_forms_signatures_.erase(it,
731                                         autofilled_forms_signatures_.end());
732    }
733    download_manager_.StartUploadRequest(submitted_form, was_autofilled);
734  }
735}
736
737void AutofillManager::Reset() {
738  form_structures_.reset();
739  has_logged_autofill_enabled_ = false;
740  has_logged_address_suggestions_count_ = false;
741}
742
743AutofillManager::AutofillManager(TabContents* tab_contents,
744                                 PersonalDataManager* personal_data)
745    : TabContentsObserver(tab_contents),
746      personal_data_(personal_data),
747      download_manager_(NULL),
748      disable_download_manager_requests_(true),
749      metric_logger_(new AutofillMetrics),
750      has_logged_autofill_enabled_(false),
751      has_logged_address_suggestions_count_(false) {
752  DCHECK(tab_contents);
753}
754
755void AutofillManager::set_metric_logger(
756    const AutofillMetrics* metric_logger) {
757  metric_logger_.reset(metric_logger);
758}
759
760bool AutofillManager::GetHost(const std::vector<AutofillProfile*>& profiles,
761                              const std::vector<CreditCard*>& credit_cards,
762#ifdef ANDROID
763                              AutoFillHost** host) {
764#else
765                              RenderViewHost** host) const {
766#endif
767  if (!IsAutofillEnabled())
768    return false;
769
770  // No autofill data to return if the profiles are empty.
771  if (profiles.empty() && credit_cards.empty())
772    return false;
773
774#ifdef ANDROID
775  *host = tab_contents()->autofill_host();
776#else
777  *host = tab_contents()->render_view_host();
778#endif
779  if (!*host)
780    return false;
781
782  return true;
783}
784
785bool AutofillManager::FindCachedForm(const FormData& form,
786                                     FormStructure** form_structure) const {
787  // Find the FormStructure that corresponds to |form|.
788  *form_structure = NULL;
789  for (std::vector<FormStructure*>::const_iterator iter =
790       form_structures_.begin();
791       iter != form_structures_.end(); ++iter) {
792    if (**iter == form) {
793      *form_structure = *iter;
794      break;
795    }
796  }
797
798  if (!(*form_structure))
799    return false;
800
801  return true;
802}
803
804bool AutofillManager::FindCachedFormAndField(const FormData& form,
805                                             const FormField& field,
806                                             FormStructure** form_structure,
807                                             AutofillField** autofill_field) {
808  // Find the FormStructure that corresponds to |form|.
809  if (!FindCachedForm(form, form_structure))
810    return false;
811
812  // No data to return if there are no auto-fillable fields.
813  if (!(*form_structure)->autofill_count())
814    return false;
815
816  // Find the AutofillField that corresponds to |field|.
817  *autofill_field = NULL;
818  for (std::vector<AutofillField*>::const_iterator iter =
819           (*form_structure)->begin();
820       iter != (*form_structure)->end(); ++iter) {
821    // The field list is terminated with a NULL AutofillField, so don't try to
822    // dereference it.
823    if (!*iter)
824      break;
825
826    if ((**iter) == field) {
827      *autofill_field = *iter;
828      break;
829    }
830  }
831
832  if (!(*autofill_field))
833    return false;
834
835  return true;
836}
837
838void AutofillManager::GetProfileSuggestions(FormStructure* form,
839                                            const FormField& field,
840                                            AutofillFieldType type,
841                                            std::vector<string16>* values,
842                                            std::vector<string16>* labels,
843                                            std::vector<string16>* icons,
844                                            std::vector<int>* unique_ids) {
845  const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
846  if (!field.is_autofilled) {
847    std::vector<AutofillProfile*> matched_profiles;
848    for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
849         iter != profiles.end(); ++iter) {
850      AutofillProfile* profile = *iter;
851
852      // The value of the stored data for this field type in the |profile|.
853      std::vector<string16> multi_values;
854      profile->GetMultiInfo(type, &multi_values);
855
856      for (size_t i = 0; i < multi_values.size(); ++i) {
857        if (!multi_values[i].empty() &&
858            StartsWith(multi_values[i], field.value, false)) {
859          matched_profiles.push_back(profile);
860          values->push_back(multi_values[i]);
861          unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
862                                          GUIDPair(profile->guid(), i)));
863          break;
864        }
865      }
866    }
867
868    std::vector<AutofillFieldType> form_fields;
869    form_fields.reserve(form->field_count());
870    for (std::vector<AutofillField*>::const_iterator iter = form->begin();
871         iter != form->end(); ++iter) {
872      // The field list is terminated with a NULL AutofillField, so don't try to
873      // dereference it.
874      if (!*iter)
875        break;
876      form_fields.push_back((*iter)->type());
877    }
878
879    AutofillProfile::CreateInferredLabels(&matched_profiles, &form_fields,
880                                          type, 1, labels);
881
882    // No icons for profile suggestions.
883    icons->resize(values->size());
884  } else {
885    for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
886         iter != profiles.end(); ++iter) {
887      AutofillProfile* profile = *iter;
888
889      // The value of the stored data for this field type in the |profile|.
890      std::vector<string16> multi_values;
891      profile->GetMultiInfo(type, &multi_values);
892
893      for (size_t i = 0; i < multi_values.size(); ++i) {
894        if (!multi_values[i].empty() &&
895            StringToLowerASCII(multi_values[i])
896                == StringToLowerASCII(field.value)) {
897          for (size_t j = 0; j < multi_values.size(); ++j) {
898            if (!multi_values[j].empty()) {
899              values->push_back(multi_values[j]);
900              unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
901                                              GUIDPair(profile->guid(), j)));
902            }
903          }
904          // We've added all the values for this profile so move on to the next.
905          break;
906        }
907      }
908    }
909
910    // No labels for previously filled fields.
911    labels->resize(values->size());
912
913    // No icons for profile suggestions.
914    icons->resize(values->size());
915  }
916}
917
918void AutofillManager::GetCreditCardSuggestions(FormStructure* form,
919                                               const FormField& field,
920                                               AutofillFieldType type,
921                                               std::vector<string16>* values,
922                                               std::vector<string16>* labels,
923                                               std::vector<string16>* icons,
924                                               std::vector<int>* unique_ids) {
925  for (std::vector<CreditCard*>::const_iterator iter =
926           personal_data_->credit_cards().begin();
927       iter != personal_data_->credit_cards().end(); ++iter) {
928    CreditCard* credit_card = *iter;
929
930    // The value of the stored data for this field type in the |credit_card|.
931    string16 creditcard_field_value = credit_card->GetInfo(type);
932    if (!creditcard_field_value.empty() &&
933        StartsWith(creditcard_field_value, field.value, false)) {
934      if (type == CREDIT_CARD_NUMBER)
935        creditcard_field_value = credit_card->ObfuscatedNumber();
936
937      string16 label;
938      if (credit_card->number().empty()) {
939        // If there is no CC number, return name to show something.
940        label = credit_card->GetInfo(CREDIT_CARD_NAME);
941      } else {
942        label = kCreditCardPrefix;
943        label.append(credit_card->LastFourDigits());
944      }
945
946      values->push_back(creditcard_field_value);
947      labels->push_back(label);
948      icons->push_back(UTF8ToUTF16(credit_card->type()));
949      unique_ids->push_back(PackGUIDs(GUIDPair(credit_card->guid(), 0),
950                                      GUIDPair(std::string(), 0)));
951    }
952  }
953}
954
955void AutofillManager::FillCreditCardFormField(const CreditCard* credit_card,
956                                              AutofillFieldType type,
957                                              webkit_glue::FormField* field) {
958  DCHECK(credit_card);
959  DCHECK_EQ(AutofillType::CREDIT_CARD, AutofillType(type).group());
960  DCHECK(field);
961
962  if (field->form_control_type == ASCIIToUTF16("select-one")) {
963    autofill::FillSelectControl(*credit_card, type, field);
964  } else if (field->form_control_type == ASCIIToUTF16("month")) {
965    // HTML5 input="month" consists of year-month.
966    string16 year = credit_card->GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR);
967    string16 month = credit_card->GetInfo(CREDIT_CARD_EXP_MONTH);
968    if (!year.empty() && !month.empty()) {
969      // Fill the value only if |credit_card| includes both year and month
970      // information.
971      field->value = year + ASCIIToUTF16("-") + month;
972    }
973  } else {
974    string16 value = credit_card->GetInfo(type);
975    if (type == CREDIT_CARD_NUMBER)
976      value = CreditCard::StripSeparators(value);
977    field->value = value;
978  }
979}
980
981void AutofillManager::FillFormField(const AutofillProfile* profile,
982                                    AutofillFieldType type,
983                                    size_t variant,
984                                    webkit_glue::FormField* field) {
985  DCHECK(profile);
986  DCHECK_NE(AutofillType::CREDIT_CARD, AutofillType(type).group());
987  DCHECK(field);
988
989  if (AutofillType(type).subgroup() == AutofillType::PHONE_NUMBER) {
990    FillPhoneNumberField(profile, type, variant, field);
991  } else {
992    if (field->form_control_type == ASCIIToUTF16("select-one")) {
993      autofill::FillSelectControl(*profile, type, field);
994    } else {
995      std::vector<string16> values;
996      profile->GetMultiInfo(type, &values);
997      DCHECK(variant < values.size());
998      field->value = values[variant];
999    }
1000  }
1001}
1002
1003void AutofillManager::FillPhoneNumberField(const AutofillProfile* profile,
1004                                           AutofillFieldType type,
1005                                           size_t variant,
1006                                           webkit_glue::FormField* field) {
1007  // If we are filling a phone number, check to see if the size field
1008  // matches the "prefix" or "suffix" sizes and fill accordingly.
1009  std::vector<string16> values;
1010  profile->GetMultiInfo(type, &values);
1011  DCHECK(variant < values.size());
1012  string16 number = values[variant];
1013  bool has_valid_suffix_and_prefix = (number.length() ==
1014      static_cast<size_t>(PhoneNumber::kPrefixLength +
1015                          PhoneNumber::kSuffixLength));
1016  if (has_valid_suffix_and_prefix &&
1017      field->max_length == PhoneNumber::kPrefixLength) {
1018    number = number.substr(PhoneNumber::kPrefixOffset,
1019                           PhoneNumber::kPrefixLength);
1020    field->value = number;
1021  } else if (has_valid_suffix_and_prefix &&
1022             field->max_length == PhoneNumber::kSuffixLength) {
1023    number = number.substr(PhoneNumber::kSuffixOffset,
1024                           PhoneNumber::kSuffixLength);
1025    field->value = number;
1026  } else {
1027    field->value = number;
1028  }
1029}
1030
1031void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
1032  std::vector<FormStructure*> non_queryable_forms;
1033  for (std::vector<FormData>::const_iterator iter = forms.begin();
1034       iter != forms.end(); ++iter) {
1035    scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
1036    if (!form_structure->ShouldBeParsed(false))
1037      continue;
1038
1039    form_structure->DetermineHeuristicTypes();
1040
1041    // Set aside forms with method GET so that they are not included in the
1042    // query to the server.
1043    if (form_structure->ShouldBeParsed(true))
1044      form_structures_.push_back(form_structure.release());
1045    else
1046      non_queryable_forms.push_back(form_structure.release());
1047  }
1048
1049  // If none of the forms were parsed, no use querying the server.
1050  if (!form_structures_.empty() && !disable_download_manager_requests_)
1051    download_manager_.StartQueryRequest(form_structures_, *metric_logger_);
1052
1053  for (std::vector<FormStructure*>::const_iterator iter =
1054           non_queryable_forms.begin();
1055       iter != non_queryable_forms.end(); ++iter) {
1056    form_structures_.push_back(*iter);
1057  }
1058}
1059
1060int AutofillManager::GUIDToID(const GUIDPair& guid) {
1061  static int last_id = 1;
1062
1063  if (!guid::IsValidGUID(guid.first))
1064    return 0;
1065
1066  std::map<GUIDPair, int>::const_iterator iter = guid_id_map_.find(guid);
1067  if (iter == guid_id_map_.end()) {
1068    guid_id_map_[guid] = last_id;
1069    id_guid_map_[last_id] = guid;
1070    return last_id++;
1071  } else {
1072    return iter->second;
1073  }
1074}
1075
1076const AutofillManager::GUIDPair AutofillManager::IDToGUID(int id) {
1077  if (id == 0)
1078    return GUIDPair(std::string(), 0);
1079
1080  std::map<int, GUIDPair>::const_iterator iter = id_guid_map_.find(id);
1081  if (iter == id_guid_map_.end()) {
1082    NOTREACHED();
1083    return GUIDPair(std::string(), 0);
1084  }
1085
1086  return iter->second;
1087}
1088
1089// When sending IDs (across processes) to the renderer we pack credit card and
1090// profile IDs into a single integer.  Credit card IDs are sent in the high
1091// word and profile IDs are sent in the low word.
1092int AutofillManager::PackGUIDs(const GUIDPair& cc_guid,
1093                               const GUIDPair& profile_guid) {
1094  int cc_id = GUIDToID(cc_guid);
1095  int profile_id = GUIDToID(profile_guid);
1096
1097  DCHECK(cc_id <= std::numeric_limits<unsigned short>::max());
1098  DCHECK(profile_id <= std::numeric_limits<unsigned short>::max());
1099
1100  return cc_id << std::numeric_limits<unsigned short>::digits | profile_id;
1101}
1102
1103// When receiving IDs (across processes) from the renderer we unpack credit card
1104// and profile IDs from a single integer.  Credit card IDs are stored in the
1105// high word and profile IDs are stored in the low word.
1106void AutofillManager::UnpackGUIDs(int id,
1107                                  GUIDPair* cc_guid,
1108                                  GUIDPair* profile_guid) {
1109  int cc_id = id >> std::numeric_limits<unsigned short>::digits &
1110      std::numeric_limits<unsigned short>::max();
1111  int profile_id = id & std::numeric_limits<unsigned short>::max();
1112
1113  *cc_guid = IDToGUID(cc_id);
1114  *profile_guid = IDToGUID(profile_id);
1115}
1116