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