Display a warning when autofill is disabled for a website.

chrome/browser/autofill/autofill_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/autofill/autofill_manager.h"
 
 #include <limits>
 #include <string>
 
+#include "app/l10n_util.h"
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_dialog.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/guid.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "grit/generated_resources.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_field.h"
 
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 
 namespace {
 
 // We only send a fraction of the forms to upload server.
 // The rate for positive/negative matches potentially could be different.
@@ skipping 90 matching lines @@
   if (tab_contents_->profile()->IsOffTheRecord())
     return;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return;
 
   // Grab a copy of the form data.
   upload_form_structure_.reset(new FormStructure(form));
 
-  if (!upload_form_structure_->IsAutoFillable())
+  if (!upload_form_structure_->IsAutoFillable(true))
     return;
 
   // Determine the possible field types and upload the form structure to the
   // PersonalDataManager.
   DeterminePossibleFieldTypes(upload_form_structure_.get());
   HandleSubmit();
 }
 
 void AutoFillManager::FormsSeen(const std::vector<FormData>& forms) {
   if (!IsAutoFillEnabled())
     return;
 
   ParseForms(forms);
 }
 
-bool AutoFillManager::GetAutoFillSuggestions(int query_id,
-                                             bool field_autofilled,
+bool AutoFillManager::GetAutoFillSuggestions(bool field_autofilled,
                                              const FormField& field) {
   if (!IsAutoFillEnabled())
     return false;
 
   RenderViewHost* host = tab_contents_->render_view_host();
   if (!host)
     return false;
 
   if (personal_data_->profiles().empty() &&
       personal_data_->credit_cards().empty())
     return false;
 
   // Loops through the cached FormStructures looking for the FormStructure that
   // contains |field| and the associated AutoFillFieldType.
   FormStructure* form = NULL;
   AutoFillField* autofill_field = NULL;
   for (std::vector<FormStructure*>::iterator form_iter =
            form_structures_.begin();
        form_iter != form_structures_.end() && !autofill_field; ++form_iter) {
     form = *form_iter;
 
     // Don't send suggestions for forms that aren't auto-fillable.
-    if (!form->IsAutoFillable())
+    if (!form->IsAutoFillable(false))
       continue;
 
     for (std::vector<AutoFillField*>::const_iterator iter = form->begin();
          iter != form->end(); ++iter) {
       // The field list is terminated with a NULL AutoFillField, so don't try to
       // dereference it.
       if (!*iter)
         break;
 
       if ((**iter) == field) {
@@ skipping 21 matching lines @@
   }
 
   DCHECK_EQ(values.size(), labels.size());
   DCHECK_EQ(values.size(), icons.size());
   DCHECK_EQ(values.size(), unique_ids.size());
 
   // No suggestions.
   if (values.empty())
     return false;
 
+  // Don't provide AutoFill suggestions when AutoFill is disabled, but provide a
+  // warning to the user.
+  if (!form->IsAutoFillable(true)) {
+    values.assign(
+        1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED));
+    labels.assign(1, string16());
+    icons.assign(1, string16());
+    unique_ids.assign(1, -1);
+    host->AutoFillSuggestionsReturned(values, labels, icons, unique_ids);
+    return true;
+  }
+
+  // Don't provide credit card suggestions for non-HTTPS pages, but provide a
+  // warning to the user.
+  if (!FormIsHTTPS(form) && type.group() == AutoFillType::CREDIT_CARD) {
+    values.assign(
+        1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION));
+    labels.assign(1, string16());
+    icons.assign(1, string16());
+    unique_ids.assign(1, -1);
+    host->AutoFillSuggestionsReturned(values, labels, icons, unique_ids);
+    return true;
+  }
+
   // If the form is auto-filled and the renderer is querying for suggestions,
   // then the user is editing the value of a field.  In this case, mimick
   // autocomplete.  In particular, don't display labels, as that information is
   // redundant. In addition, remove duplicate values.
   if (field_autofilled) {
     RemoveDuplicateElements(&values, &unique_ids);
     labels.resize(values.size());
     icons.resize(values.size());
     unique_ids.resize(values.size());
 
     for (size_t i = 0; i < labels.size(); ++i) {
       labels[i] = string16();
       icons[i] = string16();
       unique_ids[i] = 0;
     }
   }
 
-  host->AutoFillSuggestionsReturned(
-      query_id, values, labels, icons, unique_ids);
+  host->AutoFillSuggestionsReturned(values, labels, icons, unique_ids);
   return true;
 }
 
 bool AutoFillManager::FillAutoFillFormData(int query_id,
                                            const FormData& form,
                                            int unique_id) {
   if (!IsAutoFillEnabled())
     return false;
 
   RenderViewHost* host = tab_contents_->render_view_host();
@@ skipping 272 matching lines @@
   icons->resize(values->size());
 }
 
 void AutoFillManager::GetCreditCardSuggestions(FormStructure* form,
                                                const FormField& field,
                                                AutoFillType type,
                                                std::vector<string16>* values,
                                                std::vector<string16>* labels,
                                                std::vector<string16>* icons,
                                                std::vector<int>* unique_ids) {
-  // Don't return CC suggestions for non-HTTPS pages.
-  if (!FormIsHTTPS(form))
-    return;
-
   for (std::vector<CreditCard*>::const_iterator iter =
            personal_data_->credit_cards().begin();
        iter != personal_data_->credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
     string16 creditcard_field_value = credit_card->GetFieldText(type);
     if (!creditcard_field_value.empty() &&
         StartsWith(creditcard_field_value, field.value(), false)) {
       if (type.field_type() == CREDIT_CARD_NUMBER)
@@ skipping 50 matching lines @@
   } else if (has_valid_suffix_and_prefix &&
              field->size() == kAutoFillPhoneNumberSuffixCount) {
     number = number.substr(kAutoFillPhoneNumberSuffixOffset,
                            kAutoFillPhoneNumberSuffixCount);
     field->set_value(number);
   } else {
     field->set_value(number);
   }
 }
 
-void AutoFillManager::ParseForms(
-    const std::vector<webkit_glue::FormData>& forms) {
-  for (std::vector<FormData>::const_iterator iter =
-           forms.begin();
+void AutoFillManager::ParseForms(const std::vector<FormData>& forms) {
+  std::vector<FormStructure *> non_queryable_forms;
+  for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
-    if (!form_structure->ShouldBeParsed())
+    if (!form_structure->ShouldBeParsed(false))
       continue;
 
     DeterminePossibleFieldTypes(form_structure.get());
-    form_structures_.push_back(form_structure.release());
+
+    // Set aside forms with method GET so that they are not included in the
+    // query to the server.
+    if (form_structure->ShouldBeParsed(true))
+      form_structures_.push_back(form_structure.release());
+    else
+      non_queryable_forms.push_back(form_structure.release());
   }
 
   // If none of the forms were parsed, no use querying the server.
   if (!form_structures_.empty() && !disable_download_manager_requests_)
     download_manager_.StartQueryRequest(form_structures_);
+
+  for (std::vector<FormStructure *>::const_iterator iter =
+           non_queryable_forms.begin();
+       iter != non_queryable_forms.end(); ++iter) {
+    form_structures_.push_back(*iter);
+  }
 }
 
 // When sending IDs (across processes) to the renderer we pack credit card and
 // profile IDs into a single integer.  Credit card IDs are sent in the high
 // word and profile IDs are sent in the low word.
 int AutoFillManager::PackGUIDs(const std::string& cc_guid,
                                const std::string& profile_guid) {
   int cc_id = GUIDToID(cc_guid);
   int profile_id = GUIDToID(profile_guid);
 
@@ skipping 38 matching lines @@
     return std::string();
 
   std::map<int, std::string>::const_iterator iter = id_guid_map_.find(id);
   if (iter == id_guid_map_.end()) {
     NOTREACHED();
     return std::string();
   }
 
   return iter->second;
 }