Implement the autofill UI for chromium powered android webview.

components/autofill/browser/autofill_manager.cc

 // Copyright (c) 2012 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/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 391 matching lines @@
                    initial_interaction_timestamp_,
                    timestamp));
   }
 
   return true;
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp,
                                   autofill::FormsSeenState state) {
+
   bool is_post_document_load = state == autofill::DYNAMIC_FORMS_SEEN;
   bool has_more_forms = state == autofill::PARTIAL_FORMS_SEEN;
   // If new forms were added via AJAX or DHML, treat as new page.
   if (is_post_document_load)
     Reset();
 
   RenderViewHost* host = web_contents()->GetRenderViewHost();
   if (!host)
     return;
 
   if (!GetAutocheckoutURLPrefix().empty()) {
     // If whitelisted URL, fetch all the forms.
     if (has_more_forms)
       host->Send(new AutofillMsg_GetAllForms(host->GetRoutingID()));
     if (!is_post_document_load) {
       host->Send(
           new AutofillMsg_AutocheckoutSupported(host->GetRoutingID()));
     }
     // Now return early, as OnFormsSeen will get called again with all forms.
     if (has_more_forms)
       return;
   }
 
   autocheckout_manager_.OnFormsSeen();
   bool enabled = IsAutofillEnabled();
   if (!has_logged_autofill_enabled_) {
     metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
-
   if (!enabled)
     return;
 
   forms_loaded_timestamp_ = timestamp;
   ParseForms(forms);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
                                            const FormFieldData& field,
                                            const TimeTicks& timestamp) {
@@ skipping 60 matching lines @@
 void AutofillManager::GetAutofillSuggestions(
     const FormData& form,
     const FormFieldData& field,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<string16>* icons,
     std::vector<int>* unique_ids) {
   RenderViewHost* host = NULL;
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
-  if (GetHost(&host) &&
+  if (personal_data_ &&
+      GetHost(&host) &&
       GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions for forms that aren't auto-fillable.
       form_structure->IsAutofillable(false)) {
     AutofillFieldType type = autofill_field->type();
     bool is_filling_credit_card =
         (AutofillType(type).group() == AutofillType::CREDIT_CARD);
     if (is_filling_credit_card) {
       GetCreditCardSuggestions(
           field, type, values, labels, icons, unique_ids);
     } else {
@@ skipping 176 matching lines @@
   }
 }
 
 void AutofillManager::OnHideAutofillUi() {
   if (IsNativeUiEnabled())
     manager_delegate_->HideAutofillPopup();
   manager_delegate_->HideAutocheckoutBubble();
 }
 
 void AutofillManager::RemoveAutofillProfileOrCreditCard(int unique_id) {
+
+  if (!personal_data_)
+    return;
+
   const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
   if (!GetProfileOrCreditCard(unique_id, &data_model, &variant)) {
     NOTREACHED();
     return;
   }
 
   // TODO(csharp): If we are dealing with a variant only the variant should
   // be deleted, instead of doing nothing.
   // http://crbug.com/124211
@@ skipping 59 matching lines @@
     external_delegate_->SetCurrentDataListValues(values,
                                                  labels,
                                                  icons,
                                                  unique_ids);
   }
 }
 
 void AutofillManager::OnRequestAutocomplete(
     const FormData& form,
     const GURL& frame_url) {
+
   if (!IsAutofillEnabled()) {
     ReturnAutocompleteResult(WebFormElement::AutocompleteResultErrorDisabled,
                              FormData());
     return;
   }
 
   base::Callback<void(const FormStructure*, const std::string&)> callback =
       base::Bind(&AutofillManager::ReturnAutocompleteData,
                  weak_ptr_factory_.GetWeakPtr());
   ShowRequestAutocompleteDialog(
@@ skipping 151 matching lines @@
   if (!HasServerSpecifiedFieldTypes(*cached_form))
     return;
 
   autocheckout_manager_.MaybeShowAutocheckoutBubble(
       form.origin,
       form.ssl_status,
       bounding_box);
 }
 
 void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
-  if (!download_manager_)
+  if (!download_manager_ || !personal_data_)
     return;
 
   // Check if the form is among the forms that were recently auto-filled.
   bool was_autofilled = false;
   std::string form_signature = submitted_form.FormSignature();
   for (std::list<std::string>::const_iterator it =
            autofilled_form_signatures_.begin();
        it != autofilled_form_signatures_.end() && !was_autofilled;
        ++it) {
     if (*it == form_signature)
@@ skipping 51 matching lines @@
 
 bool AutofillManager::GetHost(RenderViewHost** host) const {
 
   if (!IsAutofillEnabled())
     return false;
 
   if (!personal_data_)
     return false;
 
   // No autofill data to return if the profiles are empty.
-  if (personal_data_->GetProfiles().empty() &&
+  if (personal_data_ &&
+      personal_data_->GetProfiles().empty() &&
       personal_data_->GetCreditCards().empty()) {
     return false;
   }
 
   *host = web_contents()->GetRenderViewHost();
   if (!*host)
     return false;
 
   return true;
 }
 
 bool AutofillManager::GetProfileOrCreditCard(
     int unique_id,
     const AutofillDataModel** data_model,
     size_t* variant) const {
+  if (!personal_data_)
+    return false;
+
   // Unpack the |unique_id| into component parts.
   GUIDPair credit_card_guid;
   GUIDPair profile_guid;
   UnpackGUIDs(unique_id, &credit_card_guid, &profile_guid);
   DCHECK(!base::IsValidGUID(credit_card_guid.first) ||
          !base::IsValidGUID(profile_guid.first));
 
   // Find the profile that matches the |profile_guid|, if one is specified.
   // Otherwise find the credit card that matches the |credit_card_guid|,
   // if specified.
@@ skipping 129 matching lines @@
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
     const FormFieldData& field,
     AutofillFieldType type,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
+
+  if (!personal_data_)
+    return;
   std::vector<AutofillFieldType> field_types(form->field_count());
   for (size_t i = 0; i < form->field_count(); ++i) {
     field_types[i] = form->field(i)->type();
   }
   std::vector<GUIDPair> guid_pairs;
 
   personal_data_->GetProfileSuggestions(
       type, field.value, field.is_autofilled, field_types,
       values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
                                     guid_pairs[i]));
   }
 }
 
 void AutofillManager::GetCreditCardSuggestions(
     const FormFieldData& field,
     AutofillFieldType type,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
+
+  if (!personal_data_)
+    return;
+
   std::vector<GUIDPair> guid_pairs;
   personal_data_->GetCreditCardSuggestions(
       type, field.value, values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
@@ skipping 101 matching lines @@
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
 }  // namespace autofill