Enable Autocomplete feature for chromium 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 305 matching lines @@
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form,
                                       const TimeTicks& timestamp) {
   // Let AutoComplete know as well.
   autocomplete_history_manager_.OnFormSubmitted(form);
 
   if (!IsAutofillEnabled())
     return false;
 
-  if (web_contents()->GetBrowserContext()->IsOffTheRecord())
+  if (external_delegate_ && external_delegate_->ShouldIgnoreFormData())
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return false;
 
+  // If there is no personal_data_, nothing to do.
+  if (!personal_data_)
+    return false;
+
   // Grab a copy of the form data.
   scoped_ptr<FormStructure> submitted_form(
       new FormStructure(form, GetAutocheckoutURLPrefix()));
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!submitted_form->ShouldBeParsed(true))
     return false;
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
@@ skipping 46 matching lines @@
                    initial_interaction_timestamp_,
                    timestamp));
   }
 
   return true;
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp,
                                   autofill::FormsSeenState state) {
+

[benm (inactive), 2013/05/23 12:02:21]

nit: remove?

[sgurun-gerrit only, 2013/05/23 17:10:01]

Done.

   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 36 matching lines @@
   std::vector<int> unique_ids;
 
   if (external_delegate_) {
     external_delegate_->OnQuery(query_id,
                                 form,
                                 field,
                                 bounding_box,
                                 display_warning);
   }
 
+  if (personal_data_) {
+    OnQueryFormFieldAutofillPersonalData(query_id,
+                                         form,
+                                         field,
+                                         &values,
+                                         &labels,
+                                         &icons,
+                                         &unique_ids);
+  }
+  // Add the results from AutoComplete.  They come back asynchronously, so we
+  // hand off what we generated and they will send the results back to the
+  // renderer.
+  autocomplete_history_manager_.OnGetAutocompleteSuggestions(
+      query_id, field.name, field.value, values, labels, icons, unique_ids);
+}
+
+void AutofillManager::OnQueryFormFieldAutofillPersonalData(
+    int query_id,
+    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) &&
       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);
+          field, type, values, labels, icons, unique_ids);
     } else {
       GetProfileSuggestions(
-          form_structure, field, type, &values, &labels, &icons, &unique_ids);
+          form_structure, field, type, values, labels, icons, unique_ids);
     }
 
-    DCHECK_EQ(values.size(), labels.size());
-    DCHECK_EQ(values.size(), icons.size());
-    DCHECK_EQ(values.size(), unique_ids.size());
+    DCHECK_EQ(values->size(), labels->size());
+    DCHECK_EQ(values->size(), icons->size());
+    DCHECK_EQ(values->size(), unique_ids->size());
 
-    if (!values.empty()) {
+    if (!values->empty()) {
       // Don't provide Autofill suggestions when Autofill is disabled, and don't
       // provide credit card suggestions for non-HTTPS pages. However, provide a
       // warning to the user in these cases.
       int warning = 0;
       if (!form_structure->IsAutofillable(true))
         warning = IDS_AUTOFILL_WARNING_FORM_DISABLED;
       else if (is_filling_credit_card && !FormIsHTTPS(*form_structure))
         warning = IDS_AUTOFILL_WARNING_INSECURE_CONNECTION;
       if (warning) {
-        values.assign(1, l10n_util::GetStringUTF16(warning));
-        labels.assign(1, base::string16());
-        icons.assign(1, base::string16());
-        unique_ids.assign(1,
-                          WebKit::WebAutofillClient::MenuItemIDWarningMessage);
+        values->assign(1, l10n_util::GetStringUTF16(warning));
+        labels->assign(1, base::string16());
+        icons->assign(1, base::string16());
+        unique_ids->assign(1,
+                           WebKit::WebAutofillClient::MenuItemIDWarningMessage);
       } else {
         bool section_is_autofilled =
             SectionIsAutofilled(*form_structure, form,
                                 autofill_field->section());
         if (section_is_autofilled) {
           // If the relevant section is auto-filled and the renderer is querying
           // for suggestions, then the user is editing the value of a field.
           // In this case, mimic autocomplete: don't display labels or icons,
           // as that information is redundant.
-          labels.assign(labels.size(), base::string16());
-          icons.assign(icons.size(), base::string16());
+          labels->assign(labels->size(), base::string16());
+          icons->assign(icons->size(), base::string16());
         }
 
         // When filling credit card suggestions, the values and labels are
         // typically obfuscated, which makes detecting duplicates hard.  Since
         // duplicates only tend to be a problem when filling address forms
         // anyway, only don't de-dup credit card suggestions.
         if (!is_filling_credit_card)
-          RemoveDuplicateSuggestions(&values, &labels, &icons, &unique_ids);
+          RemoveDuplicateSuggestions(values, labels, icons, unique_ids);
 
         // The first time we show suggestions on this page, log the number of
         // suggestions shown.
         if (!has_logged_address_suggestions_count_ && !section_is_autofilled) {
-          metric_logger_->LogAddressSuggestionsCount(values.size());
+          metric_logger_->LogAddressSuggestionsCount(values->size());
           has_logged_address_suggestions_count_ = true;
         }
       }
     }
   }
-
-  // Add the results from AutoComplete.  They come back asynchronously, so we
-  // hand off what we generated and they will send the results back to the
-  // renderer.
-  autocomplete_history_manager_.OnGetAutocompleteSuggestions(
-      query_id, field.name, field.value, values, labels, icons, unique_ids);
 }
 
 void AutofillManager::OnFillAutofillFormData(int query_id,
                                              const FormData& form,
                                              const FormFieldData& field,
                                              int unique_id) {
   RenderViewHost* host = NULL;
   const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
   FormStructure* form_structure = NULL;
@@ skipping 114 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) {
+

[benm (inactive), 2013/05/23 12:02:21]

nit: remove

[sgurun-gerrit only, 2013/05/23 17:10:01]

Done.

   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 62 matching lines @@
 }
 
 void AutofillManager::OnClickFailed(autofill::AutocheckoutStatus status) {
   autocheckout_manager_.OnClickFailed(status);
 }
 
 void AutofillManager::OnMaybeShowAutocheckoutBubble(
     const GURL& source_url,
     const content::SSLStatus& ssl_status,
     const gfx::RectF& bounding_box) {
+

[benm (inactive), 2013/05/23 12:02:21]

nit: remove

[sgurun-gerrit only, 2013/05/23 17:10:01]

Done.

   if (!IsAutofillEnabled())
     return;
 
   autocheckout_manager_.MaybeShowAutocheckoutBubble(
       source_url,
       ssl_status,
       bounding_box);
 }
 
 std::string AutofillManager::GetAutocheckoutURLPrefix() const {
   if (!web_contents())
     return std::string();
 
   autofill::autocheckout::WhitelistManager* whitelist_manager =
       manager_delegate_->GetAutocheckoutWhitelistManager();
 
-  return whitelist_manager->GetMatchedURLPrefix(web_contents()->GetURL());
+  return whitelist_manager ?
+      whitelist_manager->GetMatchedURLPrefix(web_contents()->GetURL()) :
+      std::string();
 }
 
 bool AutofillManager::IsAutofillEnabled() const {
   return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
 }
 
 void AutofillManager::SendAutofillTypePredictions(
     const std::vector<FormStructure*>& forms) const {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kShowAutofillTypePredictions))
     return;
 
   RenderViewHost* host = web_contents()->GetRenderViewHost();
   if (!host)
     return;
 
   std::vector<FormDataPredictions> type_predictions;
   FormStructure::GetFieldTypePredictions(forms, &type_predictions);
   host->Send(
       new AutofillMsg_FieldTypePredictionsAvailable(host->GetRoutingID(),
                                                     type_predictions));
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   const CreditCard* imported_credit_card;
+
+  if (!personal_data_)
+    return;
+
   if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
     return;
 
   // If credit card information was submitted, we need to confirm whether to
   // save it.
   if (imported_credit_card) {
     manager_delegate_->ConfirmSaveCreditCard(
         *metric_logger_,
         *imported_credit_card,
         base::Bind(&PersonalDataManager::SaveImportedCreditCard,
@@ skipping 13 matching lines @@
   submitted_form->LogQualityMetrics(*metric_logger_,
                                     load_time,
                                     interaction_time,
                                     submission_time);
 
   if (submitted_form->ShouldBeCrowdsourced())
     UploadFormData(*submitted_form);
 }
 
 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 46 matching lines @@
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 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() &&
       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