WebView autofill implementation

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 201 matching lines @@
   return cc_field_http_warning_suggestion;
 }
 
 }  // namespace
 
 AutofillManager::AutofillManager(
     AutofillDriver* driver,
     AutofillClient* client,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
-    : driver_(driver),
+    : AutofillHandler(driver),
       client_(client),
       payments_client_(base::MakeUnique<payments::PaymentsClient>(
           driver->GetURLRequestContext(),
           this)),
       app_locale_(app_locale),
       personal_data_(client->GetPersonalDataManager()),
       autocomplete_history_manager_(
           base::MakeUnique<AutocompleteHistoryManager>(driver, client)),
       form_interactions_ukm_logger_(
           base::MakeUnique<AutofillMetrics::FormInteractionsUkmLogger>(
@@ skipping 23 matching lines @@
       autofill_assistant_(this),
 #endif
       weak_ptr_factory_(this) {
   if (enable_download_manager == ENABLE_AUTOFILL_DOWNLOAD_MANAGER) {
     download_manager_.reset(new AutofillDownloadManager(driver, this));
   }
   CountryNames::SetLocaleString(app_locale_);
   if (personal_data_ && client_)
     personal_data_->OnSyncServiceInitialized(client_->GetSyncService());
 
-  if (personal_data_ && driver_)
-    personal_data_->SetURLRequestContextGetter(driver_->GetURLRequestContext());
+  if (personal_data_ && driver)
+    personal_data_->SetURLRequestContextGetter(driver->GetURLRequestContext());
 }
 
 AutofillManager::~AutofillManager() {}
 
 // static
 void AutofillManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // This pref is not synced because it's for a signin promo, which by
   // definition will not be synced.
   registry->RegisterIntegerPref(
@@ skipping 88 matching lines @@
   }
 
   return false;
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp) {
   if (!IsValidFormDataVector(forms))
     return;
 
-  if (!driver_->RendererIsAvailable())
+  if (!driver()->RendererIsAvailable())
     return;
 
   bool enabled = IsAutofillEnabled();
   if (!has_logged_autofill_enabled_) {
     AutofillMetrics::LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
 
   if (!enabled)
     return;
 
   for (const FormData& form : forms) {
     forms_loaded_timestamps_[form] = timestamp;
   }
 
   ParseForms(forms);
 }
 
-bool AutofillManager::OnWillSubmitForm(const FormData& form,
-                                       const TimeTicks& timestamp) {
-  if (!IsValidFormData(form))
-    return false;
-
+bool AutofillManager::OnWillSubmitFormImpl(const FormData& form,
+                                           const TimeTicks& timestamp) {
   // We will always give Autocomplete a chance to save the data.
   std::unique_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
   if (!submitted_form) {
     autocomplete_history_manager_->OnWillSubmitForm(form);
     return false;
   }
 
   // However, if Autofill has recognized a field as CVC, that shouldn't be
   // saved.
   FormData form_for_autocomplete = submitted_form->ToFormData();
@@ skipping 99 matching lines @@
   // upload process. |pending_form_data_| is reset.
   std::unique_ptr<FormStructure> upload_form =
       ValidateSubmittedForm(*pending_form_data_);
   pending_form_data_.reset();
   if (!upload_form)
     return;
 
   StartUploadProcess(std::move(upload_form), TimeTicks::Now(), false);
 }
 
-void AutofillManager::OnTextFieldDidChange(const FormData& form,
-                                           const FormFieldData& field,
-                                           const TimeTicks& timestamp) {
-  if (!IsValidFormData(form) || !IsValidFormFieldData(field))
-    return;
-
+void AutofillManager::OnTextFieldDidChangeImpl(const FormData& form,
+                                               const FormFieldData& field,
+                                               const TimeTicks& timestamp) {
   if (test_delegate_)
     test_delegate_->OnTextFieldChanged();
 
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   UpdatePendingForm(form);
 
@@ skipping 19 matching lines @@
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
 
 bool AutofillManager::IsFormNonSecure(const FormData& form) const {
   return !client_->IsContextSecure() ||
          (form.action.is_valid() && form.action.SchemeIs("http"));
 }
 
-void AutofillManager::OnQueryFormFieldAutofill(int query_id,
-                                               const FormData& form,
-                                               const FormFieldData& field,
-                                               const gfx::RectF& bounding_box) {
-  if (!IsValidFormData(form) || !IsValidFormFieldData(field))
-    return;
-
-  gfx::RectF transformed_box =
-      driver_->TransformBoundingBoxToViewportCoordinates(bounding_box);
-
+void AutofillManager::OnQueryFormFieldAutofillImpl(
+    int query_id,
+    const FormData& form,
+    const FormFieldData& field,
+    const gfx::RectF& transformed_box) {
   external_delegate_->OnQuery(query_id, form, field, transformed_box);
 
   // Need to refresh models before using the form_event_loggers.
   bool is_autofill_possible = RefreshDataModels();
 
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   bool got_autofillable_form =
       GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions or track forms that should not be parsed.
       form_structure->ShouldBeParsed();
 
   bool is_filling_credit_card = false;
 
   // Log interactions of forms that are autofillable.
   if (got_autofillable_form) {
     if (autofill_field->Type().group() == CREDIT_CARD) {
       is_filling_credit_card = true;
-      driver_->DidInteractWithCreditCardForm();
+      driver()->DidInteractWithCreditCardForm();
       credit_card_form_event_logger_->OnDidInteractWithAutofillableForm();
     } else {
       address_form_event_logger_->OnDidInteractWithAutofillableForm();
     }
   }
 
   std::vector<Suggestion> suggestions;
   const bool is_context_secure = !IsFormNonSecure(form);
   const bool is_http_warning_enabled =
       security_state::IsHttpWarningInFormEnabled();
 
-  // TODO(rogerm): Early exit here on !driver_->RendererIsAvailable()?
+  // TODO(rogerm): Early exit here on !driver()->RendererIsAvailable()?
   // We skip populating autofill data, but might generate warnings and or
   // signin promo to show over the unavailable renderer. That seems a mistake.
 
-  if (is_autofill_possible &&
-      driver_->RendererIsAvailable() &&
+  if (is_autofill_possible && driver()->RendererIsAvailable() &&
       got_autofillable_form) {
     // On desktop, don't return non credit card related suggestions for forms or
     // fields that have the "autocomplete" attribute set to off.
     if (IsDesktopPlatform() && !is_filling_credit_card &&
         !field.should_autocomplete) {
       return;
     }
     if (is_filling_credit_card) {
       suggestions = GetCreditCardSuggestions(field, autofill_field->Type());
     } else {
@@ skipping 167 matching lines @@
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     int unique_id) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field))
     return;
 
   // NOTE: RefreshDataModels may invalidate |data_model| because it causes the
   // PersonalDataManager to reload Mac address book entries. Thus it must come
   // before GetProfile or GetCreditCard.
-  if (!RefreshDataModels() || !driver_->RendererIsAvailable())
+  if (!RefreshDataModels() || !driver()->RendererIsAvailable())
     return;
 
   const CreditCard* credit_card = nullptr;
   const AutofillProfile* profile = nullptr;
   if (GetCreditCard(unique_id, &credit_card))
     FillOrPreviewCreditCardForm(action, query_id, form, field, *credit_card);
   else if (GetProfile(unique_id, &profile))
     FillOrPreviewProfileForm(action, query_id, form, field, *profile);
 }
 
 void AutofillManager::FillCreditCardForm(int query_id,
                                          const FormData& form,
                                          const FormFieldData& field,
                                          const CreditCard& credit_card,
                                          const base::string16& cvc) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field) ||
-      !driver_->RendererIsAvailable()) {
+      !driver()->RendererIsAvailable()) {
     return;
   }
 
   FillOrPreviewDataModelForm(AutofillDriver::FORM_DATA_ACTION_FILL, query_id,
                              form, field, credit_card, true, cvc);
 }
 
 void AutofillManager::OnFocusNoLongerOnForm() {
   ProcessPendingFormForUpload();
 }
@@ skipping 196 matching lines @@
   FormStructure::ParseQueryResponse(std::move(response), queried_forms,
                                     client_->GetRapporServiceImpl());
 
   // Will log quality metrics for each FormStructure based on the presence of
   // autocomplete attributes, if available.
   for (FormStructure* cur_form : queried_forms)
     cur_form->LogQualityMetricsBasedOnAutocomplete();
 
   // Forward form structures to the password generation manager to detect
   // account creation forms.
-  driver_->PropagateAutofillPredictions(queried_forms);
+  driver()->PropagateAutofillPredictions(queried_forms);
 
   // If the corresponding flag is set, annotate forms with the predicted types.
-  driver_->SendAutofillTypePredictionsToRenderer(queried_forms);
+  driver()->SendAutofillTypePredictionsToRenderer(queried_forms);
 }
 
 IdentityProvider* AutofillManager::GetIdentityProvider() {
   return client_->GetIdentityProvider();
 }
 
 void AutofillManager::OnDidGetRealPan(AutofillClient::PaymentsRpcResult result,
                                       const std::string& real_pan) {
   DCHECK(full_card_request_);
   full_card_request_->OnDidGetRealPan(result, real_pan);
@@ skipping 67 matching lines @@
 
 void AutofillManager::OnFullCardRequestSucceeded(const CreditCard& card,
                                                  const base::string16& cvc) {
   credit_card_form_event_logger_->OnDidFillSuggestion(masked_card_);
   FillCreditCardForm(unmasking_query_id_, unmasking_form_, unmasking_field_,
                      card, cvc);
   masked_card_ = CreditCard();
 }
 
 void AutofillManager::OnFullCardRequestFailed() {
-  driver_->RendererShouldClearPreviewedForm();
+  driver()->RendererShouldClearPreviewedForm();
 }
 
 void AutofillManager::ShowUnmaskPrompt(
     const CreditCard& card,
     AutofillClient::UnmaskCardReason reason,
     base::WeakPtr<CardUnmaskDelegate> delegate) {
   client_->ShowUnmaskPrompt(card, reason, delegate);
 }
 
 void AutofillManager::OnUnmaskVerificationResult(
@@ skipping 39 matching lines @@
   return ::autofill::IsAutofillEnabled(client_->GetPrefs());
 }
 
 bool AutofillManager::IsCreditCardUploadEnabled() {
   return ::autofill::IsCreditCardUploadEnabled(
       client_->GetPrefs(), client_->GetSyncService(),
       GetIdentityProvider()->GetActiveUsername());
 }
 
 bool AutofillManager::ShouldUploadForm(const FormStructure& form) {
-  return IsAutofillEnabled() && !driver_->IsIncognito() &&
+  return IsAutofillEnabled() && !driver()->IsIncognito() &&
          form.ShouldBeParsed() &&
          (form.active_field_count() >= kRequiredFieldsForUpload ||
           (form.all_fields_are_passwords() &&
            form.active_field_count() >=
                kRequiredFieldsForFormsWithOnlyPasswordFields));
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   std::unique_ptr<CreditCard> imported_credit_card;
   bool imported_credit_card_matches_masked_server_credit_card;
@@ skipping 363 matching lines @@
   unmasking_form_ = FormData();
   unmasking_field_ = FormFieldData();
   forms_loaded_timestamps_.clear();
   initial_interaction_timestamp_ = TimeTicks();
   external_delegate_->Reset();
 }
 
 AutofillManager::AutofillManager(AutofillDriver* driver,
                                  AutofillClient* client,
                                  PersonalDataManager* personal_data)
-    : driver_(driver),
+    : AutofillHandler(driver),
       client_(client),
       payments_client_(base::MakeUnique<payments::PaymentsClient>(
           driver->GetURLRequestContext(),
           this)),
       app_locale_("en-US"),
       personal_data_(personal_data),
       autocomplete_history_manager_(
           base::MakeUnique<AutocompleteHistoryManager>(driver, client)),
       form_interactions_ukm_logger_(
           base::MakeUnique<AutofillMetrics::FormInteractionsUkmLogger>(
@@ skipping 12 matching lines @@
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       unmasking_query_id_(-1),
       external_delegate_(NULL),
       test_delegate_(NULL),
 #if defined(OS_ANDROID) || defined(OS_IOS)
       autofill_assistant_(this),
 #endif
       weak_ptr_factory_(this) {
-  DCHECK(driver_);
+  DCHECK(driver);
   DCHECK(client_);
   CountryNames::SetLocaleString(app_locale_);
 }
 
 bool AutofillManager::RefreshDataModels() {
   if (!IsAutofillEnabled())
     return false;
 
   // No autofill data to return if the profiles are empty.
   const std::vector<AutofillProfile*>& profiles =
@@ skipping 116 matching lines @@
         }
         break;
       }
     }
 
     // Note that this may invalidate |data_model|, particularly if it is a Mac
     // address book entry.
     if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
       personal_data_->RecordUseOf(data_model);
 
-    driver_->SendFormDataToRenderer(query_id, action, result);
+    driver()->SendFormDataToRenderer(query_id, action, result);
     return;
   }
 
   DCHECK_EQ(form_structure->field_count(), form.fields.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i) {
     if (form_structure->field(i)->section() != autofill_field->section())
       continue;
 
     DCHECK(form_structure->field(i)->SameFieldAs(result.fields[i]));
 
@@ skipping 50 matching lines @@
   // Only remember the last few forms that we've seen, both to avoid false
   // positives and to avoid wasting memory.
   if (autofilled_form_signatures_.size() > kMaxRecentFormSignaturesToRemember)
     autofilled_form_signatures_.pop_back();
 
   // Note that this may invalidate |data_model|, particularly if it is a Mac
   // address book entry.
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
     personal_data_->RecordUseOf(data_model);
 
-  driver_->SendFormDataToRenderer(query_id, action, result);
+  driver()->SendFormDataToRenderer(query_id, action, result);
 }
 
 std::unique_ptr<FormStructure> AutofillManager::ValidateSubmittedForm(
     const FormData& form) {
   std::unique_ptr<FormStructure> submitted_form(
       base::MakeUnique<FormStructure>(form));
   if (!ShouldUploadForm(*submitted_form))
     return std::unique_ptr<FormStructure>();
 
   // Ignore forms not present in our cache.  These are typically forms with
@@ skipping 102 matching lines @@
   // Note: We _must not_ remove the original version of the cached form from
   // the list of |form_structures_|. Otherwise, we break parsing of the
   // crowdsourcing server's response to our query.
   if (!ParseForm(live_form, updated_form))
     return false;
 
   if (cached_form)
     (*updated_form)->UpdateFromCache(*cached_form, true);
 
   // Annotate the updated form with its predicted types.
-  driver_->SendAutofillTypePredictionsToRenderer({*updated_form});
+  driver()->SendAutofillTypePredictionsToRenderer({*updated_form});
 
   return true;
 }
 
 std::vector<Suggestion> AutofillManager::GetProfileSuggestions(
     const FormStructure& form,
     const FormFieldData& field,
     const AutofillField& autofill_field) const {
   address_form_event_logger_->OnDidPollSuggestions(field);
 
@@ skipping 93 matching lines @@
     // Expired cards are last in the sorted order, so if the first one is
     // expired, they all are.
     if (!cards.empty() && !cards.front()->IsExpired(AutofillClock::Now()))
       autofill_assistant_.ShowAssistForCreditCard(*cards.front());
   }
 #endif
 
   // For the |non_queryable_forms|, we have all the field type info we're ever
   // going to get about them.  For the other forms, we'll wait until we get a
   // response from the server.
-  driver_->SendAutofillTypePredictionsToRenderer(non_queryable_forms);
+  driver()->SendAutofillTypePredictionsToRenderer(non_queryable_forms);
 }
 
 bool AutofillManager::ParseForm(const FormData& form,
                                 FormStructure** parsed_form_structure) {
   DCHECK(parsed_form_structure);
   if (form_structures_.size() >= kMaxFormCacheSize)
     return false;
 
   auto form_structure = base::MakeUnique<FormStructure>(form);
   form_structure->ParseFieldTypesFromAutocompleteAttributes();
@@ skipping 279 matching lines @@
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisions(int upload_decision_metrics) {
   AutofillMetrics::LogCardUploadDecisionMetrics(upload_decision_metrics);
   AutofillMetrics::LogCardUploadDecisionsUkm(client_->GetUkmService(),
                                              pending_upload_request_url_,
                                              upload_decision_metrics);
 }
 
 }  // namespace autofill