Add support for autofilling radio buttons and checkboxes.

chrome/renderer/autofill/form_cache.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 "chrome/renderer/autofill/form_cache.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/form_data.h"
 #include "chrome/common/form_data_predictions.h"
@@ skipping 25 matching lines @@
 // The number of fields required by Autofill.  Ideally we could send the forms
 // to Autofill no matter how many fields are in the forms; however, finding the
 // label for each field is a costly operation and we can't spare the cycles if
 // it's not necessary.
 const size_t kRequiredAutofillFields = 3;
 
 }  // namespace
 
 namespace autofill {
 
+// Helper function to discard state of various WebFormElements when they go out
+// of web frame's scope. This is done to release memory that we no longer need
+// to hold.
+// K should inherit from WebFormControlElement as the function looks to extract
+// WebFormElement for K.form().
+template <class K, class V>
+void RemoveOldElements(const WebFrame& frame, std::map<const K, V>* states) {
+  std::vector<K> to_remove;
+  for (typename std::map<const K, V>::const_iterator it = states->begin();
+       it != states->end(); ++it) {
+    WebFormElement form_element = it->first.form();
+    if (form_element.isNull()) {
+      to_remove.push_back(it->first);
+    } else {
+      const WebFrame* element_frame = form_element.document().frame();
+      if (!element_frame || element_frame == &frame)
+        to_remove.push_back(it->first);
+    }
+  }
+
+  for (typename std::vector<K>::const_iterator it = to_remove.begin();
+       it != to_remove.end(); ++it) {
+    states->erase(*it);
+  }
+}
+
 FormCache::FormCache() {
 }
 
 FormCache::~FormCache() {
 }
 
 void FormCache::ExtractForms(const WebFrame& frame,
                              std::vector<FormData>* forms) {
   // Reset the cache for this frame.
   ResetFrame(frame);
@@ skipping 17 matching lines @@
     for (size_t j = 0; j < control_elements.size(); ++j) {
       WebFormControlElement element = control_elements[j];
 
       // Save original values of <select> elements so we can restore them
       // when |ClearFormWithNode()| is invoked.
       if (IsSelectElement(element)) {
         const WebSelectElement select_element =
             element.toConst<WebSelectElement>();
         initial_select_values_.insert(std::make_pair(select_element,
                                                      select_element.value()));
+      } else {
+        const WebInputElement input_element =
+            element.toConst<WebInputElement>();
+        if (IsCheckableElement(&input_element))
+          initial_checked_state_.insert(
+              std::make_pair(input_element, input_element.isChecked()));
       }
     }
 
     // To avoid overly expensive computation, we impose a minimum number of
     // allowable fields.  The corresponding maximum number of allowable fields
     // is imposed by WebFormElementToFormData().
     if (control_elements.size() < kRequiredAutofillFields)
       continue;
 
     FormData form;
@@ skipping 19 matching lines @@
     if (!document_frame || document_frame == &frame)
       documents_to_delete.push_back(*it);
   }
 
   for (std::vector<WebDocument>::const_iterator it =
            documents_to_delete.begin();
        it != documents_to_delete.end(); ++it) {
     web_documents_.erase(*it);
   }
 
-  std::vector<WebSelectElement> select_values_to_delete;
-  for (std::map<const WebSelectElement, string16>::const_iterator it =
-           initial_select_values_.begin();
-       it != initial_select_values_.end(); ++it) {
-    WebFormElement form_element = it->first.form();
-    if (form_element.isNull()) {
-      select_values_to_delete.push_back(it->first);
-    } else {
-      const WebFrame* element_frame = form_element.document().frame();
-      if (!element_frame || element_frame == &frame)
-        select_values_to_delete.push_back(it->first);
-    }
-  }
-
-  for (std::vector<WebSelectElement>::const_iterator it =
-           select_values_to_delete.begin();
-       it != select_values_to_delete.end(); ++it) {
-    initial_select_values_.erase(*it);
-  }
+  RemoveOldElements(frame, &initial_select_values_);
+  RemoveOldElements(frame, &initial_checked_state_);
 }
 
 bool FormCache::ClearFormWithElement(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, autofill::REQUIRE_NONE,
                               &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement control_element = control_elements[i];
     WebInputElement* input_element = toWebInputElement(&control_element);
     if (IsTextInput(input_element)) {
       // We don't modify the value of disabled fields.
       if (!input_element->isEnabled())
         continue;
 
       input_element->setValue(string16(), true);
       input_element->setAutofilled(false);
 
       // Clearing the value in the focused node (above) can cause selection
       // to be lost. We force selection range to restore the text cursor.
       if (element == *input_element) {
         int length = input_element->value().length();
         input_element->setSelectionRange(length, length);
       }
-    } else {
-      DCHECK(IsSelectElement(control_element));
+    } else if (IsSelectElement(control_element)) {
       WebSelectElement select_element = control_element.to<WebSelectElement>();
 
       std::map<const WebSelectElement, string16>::const_iterator
           initial_value_iter = initial_select_values_.find(select_element);
       if (initial_value_iter != initial_select_values_.end() &&
           select_element.value() != initial_value_iter->second) {
         select_element.setValue(initial_value_iter->second);
         select_element.dispatchFormControlChangeEvent();
       }
+    } else {
+      WebInputElement input_element = control_element.to<WebInputElement>();
+      DCHECK(IsCheckableElement(&input_element));
+      std::map<const WebInputElement, bool>::const_iterator it =
+          initial_checked_state_.find(input_element);
+      if (it != initial_checked_state_.end() &&
+          input_element.isChecked() != it->second) {
+        input_element.setChecked(it->second, true);
+      }
     }
   }
 
   return true;
 }
 
 bool FormCache::ShowPredictions(const FormDataPredictions& form) {
   DCHECK_EQ(form.data.fields.size(), form.fields.size());
 
   // Find the form.
@@ skipping 55 matching lines @@
         UTF8ToUTF16(form.experiment_id));
     if (!element->hasAttribute("placeholder"))
       element->setAttribute("placeholder", WebString(UTF8ToUTF16(placeholder)));
     element->setAttribute("title", WebString(title));
   }
 
   return true;
 }
 
 }  // namespace autofill