src/components/autofill/core/browser/autofill_manager.cc

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