android-4.3_r1.1/s

/*
 * Copyright (c) 2010 The Chromium Authors. All rights reserved.
 * Copyright 2010, The Android Open Source Project
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "FormManagerAndroid.h"

#include "DocumentLoader.h"
#include "Element.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "HTMLCollection.h"
#include "HTMLFormControlElement.h"
#include "HTMLFormElement.h"
#include "HTMLInputElement.h"
#include "HTMLLabelElement.h"
#include "HTMLNames.h"
#include "HTMLOptionElement.h"
#include "HTMLSelectElement.h"
#include "InputElement.h"
#include "Node.h"
#include "NodeList.h"
#include "HTMLCollection.h"
#include "FormAssociatedElement.h"
#include "QualifiedName.h"
#include "StringUtils.h"

// TODO: This file is taken from chromium/chrome/renderer/form_manager.cc and
// customised to use WebCore types rather than WebKit API types. It would be
// nice and would ease future merge pain if the two could be combined.

using webkit_glue::FormData;
using webkit_glue::FormField;
using WebCore::Element;
using WebCore::FormAssociatedElement;
using WebCore::HTMLCollection;
using WebCore::HTMLElement;
using WebCore::HTMLFormControlElement;
using WebCore::HTMLFormElement;
using WebCore::HTMLInputElement;
using WebCore::HTMLLabelElement;
using WebCore::HTMLOptionElement;
using WebCore::HTMLSelectElement;
using WebCore::InputElement;
using WebCore::Node;
using WebCore::NodeList;

using namespace WebCore::HTMLNames;

namespace {

// Android helper function.
HTMLInputElement* HTMLFormControlElementToHTMLInputElement(const HTMLFormControlElement& element) {
    Node* node = const_cast<Node*>(static_cast<const Node*>(&element));
    InputElement* input_element = node->toInputElement();
    if (node && node->isHTMLElement())
        return static_cast<HTMLInputElement*>(input_element);

    return 0;
}

// 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.
// Note the on ANDROID we reduce this from Chromium's 3 as it allows us to
// Autofill simple name/email forms for example. This improves the mobile
// device experience where form filling can be time consuming and frustrating.
const size_t kRequiredAutofillFields = 2;

// The maximum number of form fields we are willing to parse, due to
// computational costs. This is a very conservative upper bound.
const size_t kMaxParseableFields = 1000;

// The maximum length allowed for form data.
const size_t kMaxDataLength = 1024;

// In HTML5, all text fields except password are text input fields to
// autocomplete.
bool IsTextInput(const HTMLInputElement* element) {
    if (!element)
        return false;

    return element->isTextField() && !element->isPasswordField();
}

bool IsSelectElement(const HTMLFormControlElement& element) {
    return formControlType(element) == kSelectOne;
}

bool IsOptionElement(Element& element) {
    return element.hasTagName(optionTag);
}

bool IsAutofillableElement(const HTMLFormControlElement& element) {
    HTMLInputElement* html_input_element = HTMLFormControlElementToHTMLInputElement(element);
    return (html_input_element && IsTextInput(html_input_element)) || IsSelectElement(element);
}

// This is a helper function for the FindChildText() function (see below).
// Search depth is limited with the |depth| parameter.
string16 FindChildTextInner(Node* node, int depth) {
    string16 element_text;
    if (!node || depth <= 0)
        return element_text;

    string16 node_text = WTFStringToString16(node->nodeValue());
    TrimWhitespace(node_text, TRIM_ALL, &node_text);
    if (!node_text.empty())
        element_text = node_text;

    string16 child_text = FindChildTextInner(node->firstChild(), depth-1);
    if (!child_text.empty())
        element_text = element_text + child_text;

    string16 sibling_text = FindChildTextInner(node->nextSibling(), depth-1);
    if (!sibling_text.empty())
        element_text = element_text + sibling_text;

    return element_text;
}

// Returns the aggregated values of the decendants or siblings of |element| that
// are non-empty text nodes. This is a faster alternative to |innerText()| for
// performance critical operations. It does a full depth-first search so can be
// used when the structure is not directly known. Whitesapce is trimmed from
// text accumulated at descendant and sibling. Search is limited to within 10
// siblings and/or descendants.
string16 FindChildText(Element* element) {
    Node* child = element->firstChild();

    const int kChildSearchDepth = 10;
    return FindChildTextInner(child, kChildSearchDepth);
}

// Helper for |InferLabelForElement()| that infers a label, if possible, from
// a previous node of |element|.
string16 InferLabelFromPrevious(const HTMLFormControlElement& element) {
    string16 inferred_label;
    Node* previous = element.previousSibling();
    if (!previous)
        return string16();

    if (previous->isTextNode()) {
        inferred_label = WTFStringToString16(previous->nodeValue());
        TrimWhitespace(inferred_label, TRIM_ALL, &inferred_label);
    }

    // If we didn't find text, check for previous paragraph.
    // Eg. <p>Some Text</p><input ...>
    // Note the lack of whitespace between <p> and <input> elements.
    if (inferred_label.empty() && previous->isElementNode()) {
        Element* element = static_cast<Element*>(previous);
        if (element->hasTagName(pTag))
            inferred_label = FindChildText(element);
    }

    // If we didn't find paragraph, check for previous paragraph to this.
    // Eg. <p>Some Text</p>   <input ...>
    // Note the whitespace between <p> and <input> elements.
    if (inferred_label.empty()) {
        Node* sibling = previous->previousSibling();
        if (sibling && sibling->isElementNode()) {
            Element* element = static_cast<Element*>(sibling);
            if (element->hasTagName(pTag))
                inferred_label = FindChildText(element);
        }
    }

    // Look for text node prior to <img> tag.
    // Eg. Some Text<img/><input ...>
    if (inferred_label.empty()) {
        while (inferred_label.empty() && previous) {
            if (previous->isTextNode()) {
                inferred_label = WTFStringToString16(previous->nodeValue());
                TrimWhitespace(inferred_label, TRIM_ALL, &inferred_label);
            } else if (previous->isElementNode()) {
                Element* element = static_cast<Element*>(previous);
                if (!element->hasTagName(imgTag))
                    break;
            } else
                break;
            previous = previous->previousSibling();
        }
    }

    // Look for label node prior to <input> tag.
    // Eg. <label>Some Text</label><input ...>
    if (inferred_label.empty()) {
        while (inferred_label.empty() && previous) {
            if (previous->isTextNode()) {
                inferred_label = WTFStringToString16(previous->nodeValue());
                TrimWhitespace(inferred_label, TRIM_ALL, &inferred_label);
            } else if (previous->isElementNode()) {
                Element* element = static_cast<Element*>(previous);
                if (element->hasTagName(labelTag)) {
                    inferred_label = FindChildText(element);
                } else {
                    break;
                }
            } else {
                break;
            }

            previous = previous->previousSibling();
         }
    }

    return inferred_label;
}

// Helper for |InferLabelForElement()| that infers a label, if possible, from
// surrounding table structure.
// Eg. <tr><td>Some Text</td><td><input ...></td></tr>
// Eg. <tr><td><b>Some Text</b></td><td><b><input ...></b></td></tr>
string16 InferLabelFromTable(const HTMLFormControlElement& element) {
    string16 inferred_label;
    Node* parent = element.parentNode();
    while (parent && parent->isElementNode() && !static_cast<Element*>(parent)->hasTagName(tdTag))
        parent = parent->parentNode();

    // Check all previous siblings, skipping non-element nodes, until we find a
    // non-empty text block.
    Node* previous = parent;
    while(previous) {
        if (previous->isElementNode()) {
            Element* e = static_cast<Element*>(previous);
            if (e->hasTagName(tdTag)) {
                inferred_label = FindChildText(e);
                if (!inferred_label.empty())
                    break;
            }
        }
        previous = previous->previousSibling();
    }
    return inferred_label;
}

// Helper for |InferLabelForElement()| that infers a label, if possible, from
// a surrounding div table.
// Eg. <div>Some Text<span><input ...></span></div>
string16 InferLabelFromDivTable(const HTMLFormControlElement& element) {
    Node* parent = element.parentNode();
    while (parent && parent->isElementNode() && !static_cast<Element*>(parent)->hasTagName(divTag))
        parent = parent->parentNode();

    if (!parent || !parent->isElementNode())
        return string16();

    Element* e = static_cast<Element*>(parent);
    if (!e || !e->hasTagName(divTag))
        return string16();

    return FindChildText(e);
}

// Helper for |InferLabelForElement()| that infers a label, if possible, from
// a surrounding definition list.
// Eg. <dl><dt>Some Text</dt><dd><input ...></dd></dl>
// Eg. <dl><dt><b>Some Text</b></dt><dd><b><input ...></b></dd></dl>
string16 InferLabelFromDefinitionList(const HTMLFormControlElement& element) {
    string16 inferred_label;
    Node* parent = element.parentNode();
    while (parent && parent->isElementNode() && !static_cast<Element*>(parent)->hasTagName(ddTag))
        parent = parent->parentNode();

    if (parent && parent->isElementNode()) {
        Element* element = static_cast<Element*>(parent);
        if (element->hasTagName(ddTag)) {
            Node* previous = parent->previousSibling();

            // Skip by any intervening text nodes.
            while (previous && previous->isTextNode())
                previous = previous->previousSibling();

            if (previous && previous->isElementNode()) {
                element = static_cast<Element*>(previous);
                if (element->hasTagName(dtTag))
                    inferred_label = FindChildText(element);
            }
        }
    }
    return inferred_label;
}

// Infers corresponding label for |element| from surrounding context in the DOM.
// Contents of preceding <p> tag or preceding text element found in the form.
string16 InferLabelForElement(const HTMLFormControlElement& element) {
    string16 inferred_label = InferLabelFromPrevious(element);

    // If we didn't find a label, check for table cell case.
    if (inferred_label.empty())
        inferred_label = InferLabelFromTable(element);

    // If we didn't find a label, check for div table case.
    if (inferred_label.empty())
        inferred_label = InferLabelFromDivTable(element);

    // If we didn't find a label, check for definition list case.
    if (inferred_label.empty())
        inferred_label = InferLabelFromDefinitionList(element);

    return inferred_label;
}

void GetOptionStringsFromElement(const HTMLSelectElement& select_element, std::vector<string16>* option_strings) {
    DCHECK(option_strings);
    option_strings->clear();
    WTF::Vector<Element*> list_items = select_element.listItems();
    option_strings->reserve(list_items.size());
    for (size_t i = 0; i < list_items.size(); ++i) {
        if (IsOptionElement(*list_items[i])) {
                option_strings->push_back(WTFStringToString16(static_cast<HTMLOptionElement*>(list_items[i])->value()));
        }
    }
}

// Returns the form's |name| attribute if non-empty; otherwise the form's |id|
// attribute.
const string16 GetFormIdentifier(const HTMLFormElement& form) {
    string16 identifier = WTFStringToString16(form.name());
    if (identifier.empty())
        identifier = WTFStringToString16(form.getIdAttribute());
    return identifier;
}

}  // namespace

namespace android {

struct FormManager::FormElement {
    RefPtr<HTMLFormElement> form_element;
    std::vector<RefPtr<HTMLFormControlElement> > control_elements;
    std::vector<string16> control_values;
};

FormManager::FormManager() {
}

FormManager::~FormManager() {
    Reset();
}

// static
void FormManager::HTMLFormControlElementToFormField(HTMLFormControlElement* element, ExtractMask extract_mask, FormField* field) {
    DCHECK(field);
    DCHECK(element);

    // The label is not officially part of a HTMLFormControlElement; however, the
    // labels for all form control elements are scraped from the DOM and set in
    // WebFormElementToFormData.
    field->name = nameForAutofill(*element);
    field->form_control_type = formControlType(*element);

    if (!IsAutofillableElement(*element))
        return;

    HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*element);

    if (IsTextInput(input_element)) {
        field->max_length = input_element->maxLength();
        field->is_autofilled = input_element->isAutofilled();
    } else if (extract_mask & EXTRACT_OPTIONS) {
        // Set option strings on the field is available.
        DCHECK(IsSelectElement(*element));
        HTMLSelectElement* select_element = static_cast<HTMLSelectElement*>(element);
        std::vector<string16> option_strings;
        GetOptionStringsFromElement(*select_element, &option_strings);
        field->option_strings = option_strings;
    }

    if (!(extract_mask & EXTRACT_VALUE))
        return;

    string16 value;
    if (IsTextInput(input_element)) {
        value = WTFStringToString16(input_element->value());
    } else {
        DCHECK(IsSelectElement(*element));
        HTMLSelectElement* select_element = static_cast<HTMLSelectElement*>(element);
        value = WTFStringToString16(select_element->value());

        // Convert the |select_element| value to text if requested.
        if (extract_mask & EXTRACT_OPTION_TEXT) {
            Vector<Element*> list_items = select_element->listItems();
            for (size_t i = 0; i < list_items.size(); ++i) {
                if (IsOptionElement(*list_items[i]) &&
                    WTFStringToString16(static_cast<HTMLOptionElement*>(list_items[i])->value()) == value) {
                    value = WTFStringToString16(static_cast<HTMLOptionElement*>(list_items[i])->text());
                    break;
                }
            }
        }
    }

    // TODO: This is a temporary stop-gap measure designed to prevent
    // a malicious site from DOS'ing the browser with extremely large profile
    // data.  The correct solution is to parse this data asynchronously.
    // See http://crbug.com/49332.
    if (value.size() > kMaxDataLength)
        value = value.substr(0, kMaxDataLength);

    field->value = value;
}

// static
string16 FormManager::LabelForElement(const HTMLFormControlElement& element) {
    // Don't scrape labels for elements we can't possible autofill anyway.
    if (!IsAutofillableElement(element))
        return string16();

    RefPtr<NodeList> labels = element.document()->getElementsByTagName("label");
    for (unsigned i = 0; i < labels->length(); ++i) {
        Node* e = labels->item(i);
        DCHECK(e->hasTagName(labelTag));
        HTMLLabelElement* label = static_cast<HTMLLabelElement*>(e);
        if (label->control() == &element)
            return FindChildText(label);
    }

    // Infer the label from context if not found in label element.
    return InferLabelForElement(element);
}

// static
bool FormManager::HTMLFormElementToFormData(HTMLFormElement* element, RequirementsMask requirements, ExtractMask extract_mask, FormData* form) {
    DCHECK(form);

    Frame* frame = element->document()->frame();
    if (!frame)
        return false;

    if (requirements & REQUIRE_AUTOCOMPLETE && !element->autoComplete())
        return false;

    form->name = GetFormIdentifier(*element);
    form->method = WTFStringToString16(element->method());
    form->origin = GURL(WTFStringToString16(frame->loader()->documentLoader()->url().string()));
    form->action = GURL(WTFStringToString16(frame->document()->completeURL(element->action())));
    form->user_submitted = element->wasUserSubmitted();

    // If the completed URL is not valid, just use the action we get from
    // WebKit.
    if (!form->action.is_valid())
        form->action = GURL(WTFStringToString16(element->action()));

    // A map from a FormField's name to the FormField itself.
    std::map<string16, FormField*> name_map;

    // The extracted FormFields.  We use pointers so we can store them in
    // |name_map|.
    ScopedVector<FormField> form_fields;

    WTF::Vector<WebCore::FormAssociatedElement*> control_elements = element->associatedElements();

    // A vector of bools that indicate whether each field in the form meets the
    // requirements and thus will be in the resulting |form|.
    std::vector<bool> fields_extracted(control_elements.size(), false);

    for (size_t i = 0; i < control_elements.size(); ++i) {
        if (!control_elements[i]->isFormControlElement())
            continue;

        HTMLFormControlElement* control_element = static_cast<HTMLFormControlElement*>(control_elements[i]);

        if(!IsAutofillableElement(*control_element))
            continue;

        HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*control_element);
        if (requirements & REQUIRE_AUTOCOMPLETE && IsTextInput(input_element) &&
                !input_element->autoComplete())
                continue;

        if (requirements & REQUIRE_ENABLED && !control_element->isEnabledFormControl())
            continue;

        // Create a new FormField, fill it out and map it to the field's name.
        FormField* field = new FormField;
        HTMLFormControlElementToFormField(control_element, extract_mask, field);
        form_fields.push_back(field);
        // TODO: A label element is mapped to a form control element's id.
        // field->name() will contain the id only if the name does not exist.  Add
        // an id() method to HTMLFormControlElement and use that here.
        name_map[field->name] = field;
        fields_extracted[i] = true;
    }

    // Don't extract field labels if we have no fields.
    if (form_fields.empty())
        return false;

    // Loop through the label elements inside the form element.  For each label
    // element, get the corresponding form control element, use the form control
    // element's name as a key into the <name, FormField> map to find the
    // previously created FormField and set the FormField's label to the
    // label.firstChild().nodeValue() of the label element.
    RefPtr<WebCore::NodeList> labels = element->getElementsByTagName("label");
    for (unsigned i = 0; i < labels->length(); ++i) {
        HTMLLabelElement* label = static_cast<WebCore::HTMLLabelElement*>(labels->item(i));
        HTMLFormControlElement* field_element = label->control();
        if (!field_element || field_element->type() == "hidden")
            continue;

        std::map<string16, FormField*>::iterator iter =
            name_map.find(nameForAutofill(*field_element));
        // Concatenate labels because some sites might have multiple label
        // candidates.
        if (iter != name_map.end())
            iter->second->label += FindChildText(label);
    }

    // Loop through the form control elements, extracting the label text from the
    // DOM.  We use the |fields_extracted| vector to make sure we assign the
    // extracted label to the correct field, as it's possible |form_fields| will
    // not contain all of the elements in |control_elements|.
    for (size_t i = 0, field_idx = 0; i < control_elements.size() && field_idx < form_fields.size(); ++i) {
        // This field didn't meet the requirements, so don't try to find a label for
        // it.
        if (!fields_extracted[i])
            continue;

        if (!control_elements[i]->isFormControlElement())
            continue;

        const HTMLFormControlElement* control_element = static_cast<HTMLFormControlElement*>(control_elements[i]);
        if (form_fields[field_idx]->label.empty())
            form_fields[field_idx]->label = InferLabelForElement(*control_element);

        ++field_idx;

    }
    // Copy the created FormFields into the resulting FormData object.
    for (ScopedVector<FormField>::const_iterator iter = form_fields.begin(); iter != form_fields.end(); ++iter)
        form->fields.push_back(**iter);

    return true;
}

void FormManager::ExtractForms(Frame* frame) {

    ResetFrame(frame);

    WTF::RefPtr<HTMLCollection> web_forms = frame->document()->forms();

    for (size_t i = 0; i < web_forms->length(); ++i) {
        // Owned by |form_elements|.
        FormElement* form_element = new FormElement;
        HTMLFormElement* html_form_element = static_cast<HTMLFormElement*>(web_forms->item(i));
        form_element->form_element = html_form_element;

        WTF::Vector<FormAssociatedElement*> control_elements = html_form_element->associatedElements();
        for (size_t j = 0; j < control_elements.size(); ++j) {
            if (!control_elements[j]->isFormControlElement())
                continue;

            HTMLFormControlElement* element = static_cast<HTMLFormControlElement*>(control_elements[j]);

            if (!IsAutofillableElement(*element))
                continue;

            form_element->control_elements.push_back(element);

            // Save original values of <select> elements so we can restore them
            // when |ClearFormWithNode()| is invoked.
            if (IsSelectElement(*element)) {
                HTMLSelectElement* select_element = static_cast<HTMLSelectElement*>(element);
                form_element->control_values.push_back(WTFStringToString16(select_element->value()));
            } else
                form_element->control_values.push_back(string16());
        }

        form_elements_.push_back(form_element);
    }
}

void FormManager::GetFormsInFrame(const Frame* frame, RequirementsMask requirements, std::vector<FormData>* forms) {
    DCHECK(frame);
    DCHECK(forms);

    size_t num_fields_seen = 0;
    for (FormElementList::const_iterator form_iter = form_elements_.begin(); form_iter != form_elements_.end(); ++form_iter) {
        FormElement* form_element = *form_iter;

        if (form_element->form_element->document()->frame() != frame)
            continue;

        // To avoid overly expensive computation, we impose both a minimum and a
        // maximum number of allowable fields.
        if (form_element->control_elements.size() < kRequiredAutofillFields ||
            form_element->control_elements.size() > kMaxParseableFields)
            continue;

        if (requirements & REQUIRE_AUTOCOMPLETE && !form_element->form_element->autoComplete())
            continue;

        FormData form;
        HTMLFormElementToFormData(form_element->form_element.get(), requirements, EXTRACT_VALUE, &form);

        num_fields_seen += form.fields.size();
        if (num_fields_seen > kMaxParseableFields)
            break;

        if (form.fields.size() >= kRequiredAutofillFields)
            forms->push_back(form);
    }
}

bool FormManager::FindFormWithFormControlElement(HTMLFormControlElement* element, RequirementsMask requirements, FormData* form) {
    DCHECK(form);

    const Frame* frame = element->document()->frame();
    if (!frame)
        return false;

    for (FormElementList::const_iterator iter = form_elements_.begin(); iter != form_elements_.end(); ++iter) {
        const FormElement* form_element = *iter;

        if (form_element->form_element->document()->frame() != frame)
            continue;

        for (std::vector<RefPtr<HTMLFormControlElement> >::const_iterator iter = form_element->control_elements.begin(); iter != form_element->control_elements.end(); ++iter) {
            HTMLFormControlElement* candidate = iter->get();
            if (nameForAutofill(*candidate) == nameForAutofill(*element)) {
                ExtractMask extract_mask = static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
                return HTMLFormElementToFormData(form_element->form_element.get(), requirements, extract_mask, form);
            }
        }
    }
    return false;
}

bool FormManager::FillForm(const FormData& form, Node* node) {
    FormElement* form_element = NULL;
    if (!FindCachedFormElement(form, &form_element))
        return false;

    RequirementsMask requirements = static_cast<RequirementsMask>(REQUIRE_AUTOCOMPLETE | REQUIRE_ENABLED | REQUIRE_EMPTY);
    ForEachMatchingFormField(form_element, node, requirements, form, NewCallback(this, &FormManager::FillFormField));

    return true;
}

bool FormManager::PreviewForm(const FormData& form, Node* node) {
    FormElement* form_element = NULL;
    if (!FindCachedFormElement(form, &form_element))
        return false;

    RequirementsMask requirements = static_cast<RequirementsMask>(REQUIRE_AUTOCOMPLETE | REQUIRE_ENABLED | REQUIRE_EMPTY);
    ForEachMatchingFormField(form_element, node, requirements, form, NewCallback(this, &FormManager::PreviewFormField));

    return true;
}

bool FormManager::ClearFormWithNode(Node* node) {
    FormElement* form_element = NULL;
    if (!FindCachedFormElementWithNode(node, &form_element))
        return false;

    for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
        HTMLFormControlElement* element = form_element->control_elements[i].get();
        HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*element);
        if (IsTextInput(input_element)) {

            // We don't modify the value of disabled fields.
            if (!input_element->isEnabledFormControl())
                continue;

            input_element->setValue("");
            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 (node == input_element) {
                 int length = input_element->value().length();
                 input_element->setSelectionRange(length, length);
             }
        } else {
            DCHECK(IsSelectElement(*element));
            HTMLSelectElement* select_element = static_cast<HTMLSelectElement*>(element);
            if (WTFStringToString16(select_element->value()) != form_element->control_values[i]) {
                select_element->setValue(form_element->control_values[i].c_str());
                select_element->dispatchFormControlChangeEvent();
            }
        }
    }

    return true;
}

bool FormManager::ClearPreviewedFormWithNode(Node* node, bool was_autofilled) {
    FormElement* form_element = NULL;
    if (!FindCachedFormElementWithNode(node, &form_element))
        return false;

    for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
        HTMLFormControlElement* element = form_element->control_elements[i].get();
        HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*element);

        // Only input elements can be previewed.
        if (!IsTextInput(input_element))
            continue;

        // If the input element has not been auto-filled, FormManager has not
        // previewed this field, so we have nothing to reset.
        if (!input_element->isAutofilled())
            continue;

        // There might be unrelated elements in this form which have already been
        // auto-filled. For example, the user might have already filled the address
        // part of a form and now be dealing with the credit card section. We only
        // want to reset the auto-filled status for fields that were previewed.
        if (input_element->suggestedValue().isEmpty())
            continue;

        // Clear the suggested value. For the initiating node, also restore the
        // original value.
        input_element->setSuggestedValue("");
        bool is_initiating_node = (node == input_element);
        if (is_initiating_node) {
            input_element->setAutofilled(was_autofilled);
        } else {
            input_element->setAutofilled(false);
        }

        // Clearing the suggested value in the focused node (above) can cause
        // selection to be lost. We force selection range to restore the text
        // cursor.
        if (is_initiating_node) {
            int length = input_element->value().length();
            input_element->setSelectionRange(length, length);
        }
    }

    return true;
}

void FormManager::Reset() {
    form_elements_.reset();
}

void FormManager::ResetFrame(const Frame* frame) {
    FormElementList::iterator iter = form_elements_.begin();
    while (iter != form_elements_.end()) {
        if ((*iter)->form_element->document()->frame() == frame)
            iter = form_elements_.erase(iter);
        else
            ++iter;
    }
}

bool FormManager::FormWithNodeIsAutofilled(Node* node) {
    FormElement* form_element = NULL;
    if (!FindCachedFormElementWithNode(node, &form_element))
        return false;

    for (size_t i = 0; i < form_element->control_elements.size(); ++i) {
        HTMLFormControlElement* element = form_element->control_elements[i].get();
        HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*element);
        if (!IsTextInput(input_element))
            continue;

        if (input_element->isAutofilled())
            return true;
    }

    return false;
}

bool FormManager::FindCachedFormElementWithNode(Node* node, FormElement** form_element) {
    for (FormElementList::const_iterator form_iter = form_elements_.begin(); form_iter != form_elements_.end(); ++form_iter) {
        for (std::vector<RefPtr<HTMLFormControlElement> >::const_iterator iter = (*form_iter)->control_elements.begin(); iter != (*form_iter)->control_elements.end(); ++iter) {
            if (iter->get() == node) {
                *form_element = *form_iter;
                return true;
            }
        }
    }

    return false;
}

bool FormManager::FindCachedFormElement(const FormData& form, FormElement** form_element) {
    for (FormElementList::iterator form_iter = form_elements_.begin(); form_iter != form_elements_.end(); ++form_iter) {
        // TODO: matching on form name here which is not guaranteed to
        // be unique for the page, nor is it guaranteed to be non-empty.  Need to
        // find a way to uniquely identify the form cross-process.  For now we'll
        // check form name and form action for identity.
        // http://crbug.com/37990 test file sample8.html.
        // Also note that WebString() == WebString(string16()) does not evaluate to
        // |true| -- WebKit distinguisges between a "null" string (lhs) and an
        // "empty" string (rhs). We don't want that distinction, so forcing to
        // string16.
        string16 element_name = GetFormIdentifier(*(*form_iter)->form_element);
        GURL action(WTFStringToString16((*form_iter)->form_element->document()->completeURL((*form_iter)->form_element->action()).string()));
        if (element_name == form.name && action == form.action) {
            *form_element = *form_iter;
            return true;
        }
    }

    return false;
}


void FormManager::ForEachMatchingFormField(FormElement* form, Node* node, RequirementsMask requirements, const FormData& data, Callback* callback) {
    // It's possible that the site has injected fields into the form after the
    // page has loaded, so we can't assert that the size of the cached control
    // elements is equal to the size of the fields in |form|.  Fortunately, the
    // one case in the wild where this happens, paypal.com signup form, the fields
    // are appended to the end of the form and are not visible.
    for (size_t i = 0, j = 0; i < form->control_elements.size() && j < data.fields.size(); ++i) {
        HTMLFormControlElement* element = form->control_elements[i].get();
        string16 element_name = nameForAutofill(*element);

        // Search forward in the |form| for a corresponding field.
        size_t k = j;
        while (k < data.fields.size() && element_name != data.fields[k].name)
               k++;

        if (k >= data.fields.size())
            continue;

        DCHECK_EQ(data.fields[k].name, element_name);

        bool is_initiating_node = false;

        HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*element);
        if (IsTextInput(input_element)) {
            // TODO: WebKit currently doesn't handle the autocomplete
            // attribute for select control elements, but it probably should.
            if (!input_element->autoComplete())
                continue;

            is_initiating_node = (input_element == node);

            // Only autofill empty fields and the firls that initiated the filling,
            // i.e. the field the user is currently editing and interacting with.
            if (!is_initiating_node && !input_element->value().isEmpty())
               continue;
        }

        if (!element->isEnabledFormControl() || element->isReadOnlyFormControl() || !element->isFocusable())
            continue;

        callback->Run(element, &data.fields[k], is_initiating_node);

        // We found a matching form field so move on to the next.
        ++j;
    }

    delete callback;
}

void FormManager::FillFormField(HTMLFormControlElement* field, const FormField* data, bool is_initiating_node) {
    // Nothing to fill.
    if (data->value.empty())
        return;

    HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*field);

    if (IsTextInput(input_element)) {
        // If the maxlength attribute contains a negative value, maxLength()
        // returns the default maxlength value.
        input_element->setValue(data->value.substr(0, input_element->maxLength()).c_str(), true);
        input_element->setAutofilled(true);
        if (is_initiating_node) {
            int length = input_element->value().length();
            input_element->setSelectionRange(length, length);
        }
    } else {
        DCHECK(IsSelectElement(*field));
        HTMLSelectElement* select_element = static_cast<HTMLSelectElement*>(field);
        if (WTFStringToString16(select_element->value()) != data->value) {
            select_element->setValue(data->value.c_str());
            select_element->dispatchFormControlChangeEvent();
        }
    }
}

void FormManager::PreviewFormField(HTMLFormControlElement* field, const FormField* data, bool is_initiating_node) {
    // Nothing to preview.
    if (data->value.empty())
        return;

    // Only preview input fields.
    HTMLInputElement* input_element = HTMLFormControlElementToHTMLInputElement(*field);
    if (!IsTextInput(input_element))
        return;

    // If the maxlength attribute contains a negative value, maxLength()
    // returns the default maxlength value.
    input_element->setSuggestedValue(data->value.substr(0, input_element->maxLength()).c_str());
    input_element->setAutofilled(true);
    if (is_initiating_node) {
        // Select the part of the text that the user didn't type.
        input_element->setSelectionRange(input_element->value().length(), input_element->suggestedValue().length());
    }
}

}