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 24 matching lines @@
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autocomplete_history_manager.h"
 #include "components/autofill/core/browser/autofill_client.h"
 #include "components/autofill/core/browser/autofill_data_model.h"
 #include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_manager_test_delegate.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
+#include "components/autofill/core/browser/autofill_provider.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/browser/popup_item_ids.h"
 #include "components/autofill/core/browser/ui/save_card_bubble_controller.h"
@@ skipping 153 matching lines @@
 
   return cc_field_http_warning_suggestion;
 }
 
 }  // namespace
 
 AutofillManager::AutofillManager(
     AutofillDriver* driver,
     AutofillClient* client,
     const std::string& app_locale,
-    AutofillDownloadManagerState enable_download_manager)
+    AutofillDownloadManagerState enable_download_manager,
+    AutofillProvider* provider)
     : driver_(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_(
@@ skipping 13 matching lines @@
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       user_did_accept_upload_prompt_(false),
       should_cvc_be_requested_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
 #if defined(OS_ANDROID) || defined(OS_IOS)
       autofill_assistant_(this),
 #endif
+      provider_(provider),
       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());
@@ skipping 98 matching lines @@
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp) {
   if (!IsValidFormDataVector(forms))
     return;
 
   if (!driver_->RendererIsAvailable())
     return;
 
+  if (provider_)
+    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;
 
+  if (provider_) {
+    provider_->OnWillSubmitForm(this, form, timestamp);
+    return true;
+  }
+
   // 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 10 matching lines @@
 
   StartUploadProcess(std::move(submitted_form), timestamp, true);
 
   return true;
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form) {
   if (!IsValidFormData(form))
     return false;
 
+  if (provider_)
+    return true;
+
   // We will always give Autocomplete a chance to save the data.
   std::unique_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
   if (!submitted_form) {
     return false;
   }
 
   address_form_event_logger_->OnFormSubmitted();
   credit_card_form_event_logger_->OnFormSubmitted();
 
   // Update Personal Data with the form's submitted data.
@@ skipping 74 matching lines @@
 
   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;
 
+  if (provider_) {
+    provider_->OnTextFieldDidChange(this, form, field, timestamp);

[sebsg, 2017/05/08 15:38:17]

I notice there are a lot of if statements like this. It's difficult for me to
check how much of the original AutofillManager you are using, but you seem to
want to change/stop the behavior in a lot of places. 

Do you think subclassing the AutofillManager would be feasible?

I just feels weird to have all these if and return statements.

[michaelbai, 2017/05/09 00:27:03]

We were planing to cherry-pick this patch to M59, also I have been told your
guys will refactorying those code (well, maybe password manager related code),
so I didn't want to change the current code too much.

I think I can do something like below, but in a following up patch if you want,

Basically, Autofill provider is only care about the interface between
AutofillManager and ContentAutofillDriver, and takes advantage of validation
code, so we can

- extract this interface and common code into an abstract class AutofillManager
- and rename current AutofillManager to AutofillManagerImpl
- Also create a new class like AutofillManagerProxy which subclass
AutofillManager also forward call to AutofillProvider,
- we create different implementation of AutofillManager in ContentAutofillDriver
based on if AutofillProvider is available.

Thought?

[Roger McFarlane (Chromium), 2017/05/10 02:31:54]

That generally seems like a good approach.

But, you're right, that would likely be too large to merge into M59... so this
hooked approach makes sense in the interim. It's just tricky to make sure we
understand which functionality you meant to override vs reuse (i.e., if you
forgot a hook location, it's hard for us as reviewers to notice).

+    return;
+  }
+
   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 29 matching lines @@
 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);
 
+  if (provider_) {
+    provider_->OnQueryFormFieldAutofill(this, query_id, form, field,
+                                        transformed_box);
+    return;
+  }
+
   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.
@@ skipping 229 matching lines @@
   if (!IsValidFormData(form) || !IsValidFormFieldData(field) ||
       !driver_->RendererIsAvailable()) {
     return;
   }
 
   FillOrPreviewDataModelForm(AutofillDriver::FORM_DATA_ACTION_FILL, query_id,
                              form, field, credit_card, true, cvc);
 }
 
 void AutofillManager::OnFocusNoLongerOnForm() {
+  if (provider_) {
+    provider_->OnFocusNoLongerOnForm(this);
+    return;
+  }
   ProcessPendingFormForUpload();
 }
 
 void AutofillManager::OnDidPreviewAutofillFormData() {
   if (test_delegate_)
     test_delegate_->DidPreviewFormData();
 }
 
 void AutofillManager::OnDidFillAutofillFormData(const FormData& form,
                                                 const TimeTicks& timestamp) {
+  if (provider_) {
+    provider_->OnDidFillAutofillFormData(this, form, timestamp);
+    return;
+  }
+
   if (test_delegate_)
     test_delegate_->DidFillFormData();
 
   UpdatePendingForm(form);
 
   AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
   if (!user_did_autofill_) {
     user_did_autofill_ = true;
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::USER_DID_AUTOFILL_ONCE);
@@ skipping 23 matching lines @@
 
     if (autofill_field->Type().group() == CREDIT_CARD) {
       credit_card_form_event_logger_->OnDidShowSuggestions();
     } else {
       address_form_event_logger_->OnDidShowSuggestions();
     }
   }
 }
 
 void AutofillManager::OnHidePopup() {
-  if (!IsAutofillEnabled())
+  if (!IsAutofillEnabled() || provider_)
     return;
 
   autocomplete_history_manager_->CancelPendingQuery();
   client_->HideAutofillPopup();
 }
 
 bool AutofillManager::GetDeletionConfirmationText(const base::string16& value,
                                                   int identifier,
                                                   base::string16* title,
                                                   base::string16* body) {
@@ skipping 93 matching lines @@
 
   return full_card_request_.get();
 }
 
 void AutofillManager::SetTestDelegate(AutofillManagerTestDelegate* delegate) {
   test_delegate_ = delegate;
 }
 
 void AutofillManager::OnSetDataList(const std::vector<base::string16>& values,
                                     const std::vector<base::string16>& labels) {
+  if (provider_)
+    return;
+
   if (!IsValidString16Vector(values) ||
       !IsValidString16Vector(labels) ||
       values.size() != labels.size())
     return;
 
   external_delegate_->SetCurrentDataListValues(values, labels);
 }
 
 void AutofillManager::OnLoadedServerPredictions(
     std::string response,
@@ skipping 145 matching lines @@
     if (upload_request_.cvc.empty()) {
       DCHECK(client_->GetSaveCardBubbleController());
       upload_request_.cvc =
           client_->GetSaveCardBubbleController()->GetCvcEnteredByUser();
     }
     payments_client_->UploadCard(upload_request_);
   }
 }
 
 void AutofillManager::OnDidEndTextFieldEditing() {
+  if (provider_)
+    return;
   external_delegate_->DidEndTextFieldEditing();
 }
 
 bool AutofillManager::IsAutofillEnabled() const {
   return ::autofill::IsAutofillEnabled(client_->GetPrefs());
 }
 
 bool AutofillManager::IsCreditCardUploadEnabled() {
   return ::autofill::IsCreditCardUploadEnabled(
       client_->GetPrefs(), client_->GetSyncService(),
@@ skipping 299 matching lines @@
   form_structures_.clear();
   form_interactions_ukm_logger_.reset(
       new AutofillMetrics::FormInteractionsUkmLogger(client_->GetUkmService()));
   address_form_event_logger_.reset(new AutofillMetrics::FormEventLogger(
       false /* is_for_credit_card */, form_interactions_ukm_logger_.get()));
   credit_card_form_event_logger_.reset(new AutofillMetrics::FormEventLogger(
       true /* is_for_credit_card */, form_interactions_ukm_logger_.get()));
 #if defined(OS_ANDROID) || defined(OS_IOS)
   autofill_assistant_.Reset();
 #endif
+  if (provider_)
+    provider_->Reset(this);
   has_logged_autofill_enabled_ = false;
   has_logged_address_suggestions_count_ = false;
   did_show_suggestions_ = false;
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
   masked_card_ = CreditCard();
   unmasking_query_id_ = -1;
   unmasking_form_ = FormData();
   unmasking_field_ = FormFieldData();
@@ skipping 242 matching lines @@
     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);
 }
 
+void AutofillManager::SendFormDataToRenderer(
+    int query_id,
+    AutofillDriver::RendererFormDataAction action,
+    const FormData& data) {
+  driver_->SendFormDataToRenderer(query_id, action, data);
+}
+
 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
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
@@ skipping 512 matching lines @@
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisionUkm(
     AutofillMetrics::CardUploadDecisionMetric upload_decision) {
   AutofillMetrics::LogCardUploadDecisionUkm(
       client_->GetUkmService(), pending_upload_request_url_, upload_decision);
 }
 
 }  // namespace autofill