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 311 matching lines @@
     IPC_MESSAGE_HANDLER(AutofillHostMsg_MaybeShowAutocheckoutBubble,
                         OnMaybeShowAutocheckoutBubble)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 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())
-    return false;

[Ilya Sherman, 2013/06/15 00:28:09]

I think this check is still needed.

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

+  // Let AutoComplete know as well.
+  autocomplete_history_manager_.OnFormSubmitted(form);

[Ilya Sherman, 2013/06/15 00:28:09]

Does this re-ordering still make sense given the updated definition of
IsAutofillEnabled()?

[sgurun-gerrit only, 2013/06/17 21:20:32]

There seems multiple issues with enabling/disabling the logic as you pointed
out. I have removed ShouldIgnoreFormDAta and introduced IsAutocompleteEnabled()
which I think would be cleaner and solve the problem in a different way.

On 2013/06/15 00:28:09, Ilya Sherman wrote:

 
   // 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 132 matching lines @@
   std::vector<int> unique_ids;
 
   if (external_delegate_) {
     external_delegate_->OnQuery(query_id,
                                 form,
                                 field,
                                 bounding_box,
                                 display_warning);
   }
 
+  GetAutofillSuggestions(form,
+                         field,
+                         &values,
+                         &labels,
+                         &icons,
+                         &unique_ids);

[Ilya Sherman, 2013/06/15 00:28:09]

nit: This all fits on a single line.

[Ilya Sherman, 2013/06/15 00:28:09]

What's the purpose of decomposing out this method?

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

+
+  // 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::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) &&
       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 278 matching lines @@
   autocheckout_manager_.OnClickFailed(status);
 }
 
 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);
+  return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled)
+      && !manager_delegate_->ShouldIgnoreFormData() ;

[Ilya Sherman, 2013/06/15 00:28:09]

nit: The "&&" should go on the previous line.

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

 }
 
 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;
+

[Ilya Sherman, 2013/06/15 00:28:09]

nit: Spurious diff.

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

   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 100 matching lines @@
       weak_ptr_factory_(this) {
   DCHECK(web_contents);
   DCHECK(manager_delegate_);
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 bool AutofillManager::GetHost(RenderViewHost** host) const {
+

[Ilya Sherman, 2013/06/15 00:28:09]

nit: Spurious diff.

[sgurun-gerrit only, 2013/06/17 21:20:32]

Done.

   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;
 
@@ skipping 290 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