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