--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/html/HTMLFormElement.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,663 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * (C) 1999 Antti Koivisto (koivisto@kde.org)
+ * (C) 2001 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * (C) 2006 Alexey Proskuryakov (ap@nypop.com)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "config.h"
+#include "HTMLFormElement.h"
+
+#include "Attribute.h"
+#include "DOMFormData.h"
+#include "DOMWindow.h"
+#include "Document.h"
+#include "Event.h"
+#include "EventNames.h"
+#include "FileList.h"
+#include "FileSystem.h"
+#include "FormData.h"
+#include "FormDataList.h"
+#include "FormState.h"
+#include "FormSubmission.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameLoaderClient.h"
+#include "HTMLDocument.h"
+#include "HTMLFormCollection.h"
+#include "HTMLImageElement.h"
+#include "HTMLInputElement.h"
+#include "HTMLNames.h"
+#include "MIMETypeRegistry.h"
+#include "RenderTextControl.h"
+#include "ScriptEventListener.h"
+#include "ValidityState.h"
+#include <limits>
+#include <wtf/CurrentTime.h>
+#include <wtf/RandomNumber.h>
+
+#if PLATFORM(WX)
+#include <wx/defs.h>
+#include <wx/filename.h>
+#endif
+
+using namespace std;
+
+namespace WebCore {
+
+using namespace HTMLNames;
+
+static int64_t generateFormDataIdentifier()
+{
+ // Initialize to the current time to reduce the likelihood of generating
+ // identifiers that overlap with those from past/future browser sessions.
+ static int64_t nextIdentifier = static_cast<int64_t>(currentTime() * 1000000.0);
+ return ++nextIdentifier;
+}
+
+HTMLFormElement::HTMLFormElement(const QualifiedName& tagName, Document* document)
+ : HTMLElement(tagName, document)
+ , m_submissionTrigger(NotSubmittedByJavaScript)
+ , m_autocomplete(true)
+ , m_insubmit(false)
+ , m_doingsubmit(false)
+ , m_inreset(false)
+ , m_malformed(false)
+ , m_demoted(false)
+{
+ ASSERT(hasTagName(formTag));
+}
+
+PassRefPtr<HTMLFormElement> HTMLFormElement::create(Document* document)
+{
+ return adoptRef(new HTMLFormElement(formTag, document));
+}
+
+PassRefPtr<HTMLFormElement> HTMLFormElement::create(const QualifiedName& tagName, Document* document)
+{
+ return adoptRef(new HTMLFormElement(tagName, document));
+}
+
+HTMLFormElement::~HTMLFormElement()
+{
+ if (!m_autocomplete)
+ document()->unregisterForDocumentActivationCallbacks(this);
+
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i)
+ m_associatedElements[i]->formDestroyed();
+ for (unsigned i = 0; i < m_imageElements.size(); ++i)
+ m_imageElements[i]->m_form = 0;
+}
+
+bool HTMLFormElement::formWouldHaveSecureSubmission(const String& url)
+{
+ return document()->completeURL(url).protocolIs("https");
+}
+
+bool HTMLFormElement::rendererIsNeeded(RenderStyle* style)
+{
+ if (!isDemoted())
+ return HTMLElement::rendererIsNeeded(style);
+
+ Node* node = parentNode();
+ RenderObject* parentRenderer = node->renderer();
+ bool parentIsTableElementPart = (parentRenderer->isTable() && node->hasTagName(tableTag))
+ || (parentRenderer->isTableRow() && node->hasTagName(trTag))
+ || (parentRenderer->isTableSection() && node->hasTagName(tbodyTag))
+ || (parentRenderer->isTableCol() && node->hasTagName(colTag))
+ || (parentRenderer->isTableCell() && node->hasTagName(trTag));
+
+ if (!parentIsTableElementPart)
+ return true;
+
+ EDisplay display = style->display();
+ bool formIsTablePart = display == TABLE || display == INLINE_TABLE || display == TABLE_ROW_GROUP
+ || display == TABLE_HEADER_GROUP || display == TABLE_FOOTER_GROUP || display == TABLE_ROW
+ || display == TABLE_COLUMN_GROUP || display == TABLE_COLUMN || display == TABLE_CELL
+ || display == TABLE_CAPTION;
+
+ return formIsTablePart;
+}
+
+void HTMLFormElement::insertedIntoDocument()
+{
+ if (document()->isHTMLDocument())
+ static_cast<HTMLDocument*>(document())->addNamedItem(m_name);
+
+ HTMLElement::insertedIntoDocument();
+}
+
+void HTMLFormElement::removedFromDocument()
+{
+ if (document()->isHTMLDocument())
+ static_cast<HTMLDocument*>(document())->removeNamedItem(m_name);
+
+ HTMLElement::removedFromDocument();
+}
+
+void HTMLFormElement::handleLocalEvents(Event* event)
+{
+ Node* targetNode = event->target()->toNode();
+ if (event->eventPhase() != Event::CAPTURING_PHASE && targetNode && targetNode != this && (event->type() == eventNames().submitEvent || event->type() == eventNames().resetEvent)) {
+ event->stopPropagation();
+ return;
+ }
+ HTMLElement::handleLocalEvents(event);
+}
+
+unsigned HTMLFormElement::length() const
+{
+ unsigned len = 0;
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i)
+ if (m_associatedElements[i]->isEnumeratable())
+ ++len;
+ return len;
+}
+
+Node* HTMLFormElement::item(unsigned index)
+{
+ return elements()->item(index);
+}
+
+void HTMLFormElement::submitImplicitly(Event* event, bool fromImplicitSubmissionTrigger)
+{
+ int submissionTriggerCount = 0;
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
+ HTMLFormControlElement* formElement = m_associatedElements[i];
+ if (formElement->isSuccessfulSubmitButton()) {
+ if (formElement->renderer()) {
+ formElement->dispatchSimulatedClick(event);
+ return;
+ }
+ } else if (formElement->canTriggerImplicitSubmission())
+ ++submissionTriggerCount;
+ }
+ if (fromImplicitSubmissionTrigger && submissionTriggerCount == 1)
+ prepareSubmit(event);
+}
+
+static void appendMailtoPostFormDataToURL(KURL& url, const FormData& data, const String& encodingType)
+{
+ String body = data.flattenToString();
+
+ if (equalIgnoringCase(encodingType, "text/plain")) {
+ // Convention seems to be to decode, and s/&/\r\n/. Also, spaces are encoded as %20.
+ body = decodeURLEscapeSequences(body.replace('&', "\r\n").replace('+', ' ') + "\r\n");
+ }
+
+ Vector<char> bodyData;
+ bodyData.append("body=", 5);
+ FormDataBuilder::encodeStringAsFormData(bodyData, body.utf8());
+ body = String(bodyData.data(), bodyData.size()).replace('+', "%20");
+
+ String query = url.query();
+ if (!query.isEmpty())
+ query.append('&');
+ query.append(body);
+ url.setQuery(query);
+}
+
+PassRefPtr<FormSubmission> HTMLFormElement::prepareFormSubmission(Event* event, bool lockHistory, FormSubmissionTrigger trigger)
+{
+ KURL actionURL = document()->completeURL(m_formDataBuilder.action().isEmpty() ? document()->url().string() : m_formDataBuilder.action());
+ bool isMailtoForm = actionURL.protocolIs("mailto");
+
+ if (m_formDataBuilder.isPostMethod()) {
+ if (m_formDataBuilder.isMultiPartForm() && isMailtoForm) {
+ m_formDataBuilder.parseEncodingType("application/x-www-form-urlencoded");
+ ASSERT(!m_formDataBuilder.isMultiPartForm());
+ }
+ } else
+ m_formDataBuilder.setIsMultiPartForm(false);
+
+ TextEncoding dataEncoding = isMailtoForm ? UTF8Encoding() : m_formDataBuilder.dataEncoding(document());
+ RefPtr<DOMFormData> domFormData = DOMFormData::create(dataEncoding.encodingForFormSubmission());
+ Vector<pair<String, String> > formValues;
+
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
+ HTMLFormControlElement* control = m_associatedElements[i];
+ if (!control->disabled())
+ control->appendFormData(*domFormData, m_formDataBuilder.isMultiPartForm());
+ if (control->hasLocalName(inputTag)) {
+ HTMLInputElement* input = static_cast<HTMLInputElement*>(control);
+ if (input->isTextField()) {
+ formValues.append(pair<String, String>(input->name(), input->value()));
+ if (input->isSearchField())
+ input->addSearchResult();
+ }
+ }
+ }
+
+ RefPtr<FormData> formData;
+ String boundary;
+
+ if (m_formDataBuilder.isMultiPartForm()) {
+ formData = FormData::createMultiPart(domFormData->items(), domFormData->encoding(), document());
+ boundary = formData->boundary().data();
+ } else {
+ formData = FormData::create(domFormData->items(), domFormData->encoding());
+ if (m_formDataBuilder.isPostMethod() && isMailtoForm) {
+ // Convert the form data into a string that we put into the URL.
+ appendMailtoPostFormDataToURL(actionURL, *formData, m_formDataBuilder.encodingType());
+ formData = FormData::create();
+ }
+ }
+
+ formData->setIdentifier(generateFormDataIdentifier());
+ FormSubmission::Method method = m_formDataBuilder.isPostMethod() ? FormSubmission::PostMethod : FormSubmission::GetMethod;
+ String targetOrBaseTarget = m_formDataBuilder.target().isEmpty() ? document()->baseTarget() : m_formDataBuilder.target();
+ return FormSubmission::create(method, actionURL, targetOrBaseTarget, m_formDataBuilder.encodingType(), FormState::create(this, formValues, document()->frame(), trigger), formData.release(), boundary, lockHistory, event);
+}
+
+static inline HTMLFormControlElement* submitElementFromEvent(const Event* event)
+{
+ Node* targetNode = event->target()->toNode();
+ if (!targetNode || !targetNode->isElementNode())
+ return 0;
+ Element* targetElement = static_cast<Element*>(targetNode);
+ if (!targetElement->isFormControlElement())
+ return 0;
+ return static_cast<HTMLFormControlElement*>(targetElement);
+}
+
+bool HTMLFormElement::validateInteractively(Event* event)
+{
+ ASSERT(event);
+ if (!document()->inStrictMode() || noValidate())
+ return true;
+
+ HTMLFormControlElement* submitElement = submitElementFromEvent(event);
+ if (submitElement && submitElement->formNoValidate())
+ return true;
+
+ Vector<RefPtr<HTMLFormControlElement> > unhandledInvalidControls;
+ collectUnhandledInvalidControls(unhandledInvalidControls);
+ if (unhandledInvalidControls.isEmpty())
+ return true;
+ // If the form has invalid controls, abort submission.
+
+ RefPtr<HTMLFormElement> protector(this);
+ // Focus on the first focusable control.
+ for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
+ HTMLFormControlElement* unhandled = unhandledInvalidControls[i].get();
+ if (unhandled->isFocusable() && unhandled->inDocument()) {
+ RefPtr<Document> originalDocument(unhandled->document());
+ unhandled->scrollIntoViewIfNeeded(false);
+ // scrollIntoViewIfNeeded() dispatches events, so the state
+ // of 'unhandled' might be changed so it's no longer focusable or
+ // moved to another document.
+ if (unhandled->isFocusable() && unhandled->inDocument() && originalDocument == unhandled->document()) {
+ unhandled->focus();
+ break;
+ }
+ }
+ }
+ // Warn about all of unfocusable controls.
+ if (Frame* frame = document()->frame()) {
+ for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
+ HTMLFormControlElement* unhandled = unhandledInvalidControls[i].get();
+ if (unhandled->isFocusable() && unhandled->inDocument())
+ continue;
+ String message("An invalid form control with name='%name' is not focusable.");
+ message.replace("%name", unhandled->name());
+ frame->domWindow()->console()->addMessage(HTMLMessageSource, LogMessageType, ErrorMessageLevel, message, 0, document()->url().string());
+ }
+ }
+ m_insubmit = false;
+ return false;
+}
+
+bool HTMLFormElement::prepareSubmit(Event* event)
+{
+ Frame* frame = document()->frame();
+ if (m_insubmit || !frame)
+ return m_insubmit;
+
+ m_insubmit = true;
+ m_doingsubmit = false;
+
+ // Interactive validation must be done before dispatching the submit event.
+ if (!validateInteractively(event))
+ return false;
+
+ frame->loader()->client()->dispatchWillSendSubmitEvent(this);
+
+ if (dispatchEvent(Event::create(eventNames().submitEvent, true, true)) && !m_doingsubmit)
+ m_doingsubmit = true;
+
+ m_insubmit = false;
+
+ if (m_doingsubmit)
+ submit(event, true, false, NotSubmittedByJavaScript);
+
+ return m_doingsubmit;
+}
+
+void HTMLFormElement::submit(Frame* javaScriptActiveFrame)
+{
+ if (javaScriptActiveFrame)
+ submit(0, false, !javaScriptActiveFrame->script()->anyPageIsProcessingUserGesture(), SubmittedByJavaScript);
+ else
+ submit(0, false, false, NotSubmittedByJavaScript);
+}
+
+void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool lockHistory, FormSubmissionTrigger formSubmissionTrigger)
+{
+ FrameView* view = document()->view();
+ Frame* frame = document()->frame();
+ if (!view || !frame)
+ return;
+
+ if (m_insubmit) {
+ m_doingsubmit = true;
+ return;
+ }
+
+ m_insubmit = true;
+ m_submissionTrigger = formSubmissionTrigger;
+
+ HTMLFormControlElement* firstSuccessfulSubmitButton = 0;
+ bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?
+
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
+ HTMLFormControlElement* control = m_associatedElements[i];
+ if (needButtonActivation) {
+ if (control->isActivatedSubmit())
+ needButtonActivation = false;
+ else if (firstSuccessfulSubmitButton == 0 && control->isSuccessfulSubmitButton())
+ firstSuccessfulSubmitButton = control;
+ }
+ }
+
+ if (needButtonActivation && firstSuccessfulSubmitButton)
+ firstSuccessfulSubmitButton->setActivatedSubmit(true);
+
+ frame->loader()->submitForm(prepareFormSubmission(event, lockHistory, formSubmissionTrigger));
+
+ if (needButtonActivation && firstSuccessfulSubmitButton)
+ firstSuccessfulSubmitButton->setActivatedSubmit(false);
+
+ m_doingsubmit = m_insubmit = false;
+}
+
+void HTMLFormElement::reset()
+{
+ Frame* frame = document()->frame();
+ if (m_inreset || !frame)
+ return;
+
+ m_inreset = true;
+
+ // ### DOM2 labels this event as not cancelable, however
+ // common browsers( sick! ) allow it be cancelled.
+ if (!dispatchEvent(Event::create(eventNames().resetEvent, true, true))) {
+ m_inreset = false;
+ return;
+ }
+
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i)
+ m_associatedElements[i]->reset();
+
+ m_inreset = false;
+}
+
+void HTMLFormElement::parseMappedAttribute(Attribute* attr)
+{
+ if (attr->name() == actionAttr)
+ m_formDataBuilder.parseAction(attr->value());
+ else if (attr->name() == targetAttr)
+ m_formDataBuilder.setTarget(attr->value());
+ else if (attr->name() == methodAttr)
+ m_formDataBuilder.parseMethodType(attr->value());
+ else if (attr->name() == enctypeAttr)
+ m_formDataBuilder.parseEncodingType(attr->value());
+ else if (attr->name() == accept_charsetAttr)
+ // space separated list of charsets the server
+ // accepts - see rfc2045
+ m_formDataBuilder.setAcceptCharset(attr->value());
+ else if (attr->name() == acceptAttr) {
+ // ignore this one for the moment...
+ } else if (attr->name() == autocompleteAttr) {
+ m_autocomplete = !equalIgnoringCase(attr->value(), "off");
+ if (!m_autocomplete)
+ document()->registerForDocumentActivationCallbacks(this);
+ else
+ document()->unregisterForDocumentActivationCallbacks(this);
+ } else if (attr->name() == onsubmitAttr)
+ setAttributeEventListener(eventNames().submitEvent, createAttributeEventListener(this, attr));
+ else if (attr->name() == onresetAttr)
+ setAttributeEventListener(eventNames().resetEvent, createAttributeEventListener(this, attr));
+ else if (attr->name() == nameAttr) {
+ const AtomicString& newName = attr->value();
+ if (inDocument() && document()->isHTMLDocument()) {
+ HTMLDocument* document = static_cast<HTMLDocument*>(this->document());
+ document->removeNamedItem(m_name);
+ document->addNamedItem(newName);
+ }
+ m_name = newName;
+ } else
+ HTMLElement::parseMappedAttribute(attr);
+}
+
+template<class T, size_t n> static void removeFromVector(Vector<T*, n> & vec, T* item)
+{
+ size_t size = vec.size();
+ for (size_t i = 0; i != size; ++i)
+ if (vec[i] == item) {
+ vec.remove(i);
+ break;
+ }
+}
+
+unsigned HTMLFormElement::formElementIndex(HTMLFormControlElement* e)
+{
+ // Check for the special case where this element is the very last thing in
+ // the form's tree of children; we don't want to walk the entire tree in that
+ // common case that occurs during parsing; instead we'll just return a value
+ // that says "add this form element to the end of the array".
+ if (e->traverseNextNode(this)) {
+ unsigned i = 0;
+ for (Node* node = this; node; node = node->traverseNextNode(this)) {
+ if (node == e)
+ return i;
+ if (node->isHTMLElement()
+ && static_cast<Element*>(node)->isFormControlElement()
+ && static_cast<HTMLFormControlElement*>(node)->form() == this)
+ ++i;
+ }
+ }
+ return m_associatedElements.size();
+}
+
+void HTMLFormElement::registerFormElement(HTMLFormControlElement* e)
+{
+ document()->checkedRadioButtons().removeButton(e);
+ m_checkedRadioButtons.addButton(e);
+ m_associatedElements.insert(formElementIndex(e), e);
+}
+
+void HTMLFormElement::removeFormElement(HTMLFormControlElement* e)
+{
+ m_checkedRadioButtons.removeButton(e);
+ removeFromVector(m_associatedElements, e);
+}
+
+bool HTMLFormElement::isURLAttribute(Attribute* attr) const
+{
+ return attr->name() == actionAttr;
+}
+
+void HTMLFormElement::registerImgElement(HTMLImageElement* e)
+{
+ ASSERT(m_imageElements.find(e) == notFound);
+ m_imageElements.append(e);
+}
+
+void HTMLFormElement::removeImgElement(HTMLImageElement* e)
+{
+ ASSERT(m_imageElements.find(e) != notFound);
+ removeFromVector(m_imageElements, e);
+}
+
+PassRefPtr<HTMLCollection> HTMLFormElement::elements()
+{
+ return HTMLFormCollection::create(this);
+}
+
+String HTMLFormElement::name() const
+{
+ return getAttribute(nameAttr);
+}
+
+bool HTMLFormElement::noValidate() const
+{
+ return !getAttribute(novalidateAttr).isNull();
+}
+
+String HTMLFormElement::action() const
+{
+ return getAttribute(actionAttr);
+}
+
+void HTMLFormElement::setAction(const String &value)
+{
+ setAttribute(actionAttr, value);
+}
+
+void HTMLFormElement::setEnctype(const String &value)
+{
+ setAttribute(enctypeAttr, value);
+}
+
+String HTMLFormElement::method() const
+{
+ return getAttribute(methodAttr);
+}
+
+void HTMLFormElement::setMethod(const String &value)
+{
+ setAttribute(methodAttr, value);
+}
+
+String HTMLFormElement::target() const
+{
+ return getAttribute(targetAttr);
+}
+
+FormSubmissionTrigger HTMLFormElement::submissionTrigger() const
+{
+ return m_submissionTrigger;
+}
+
+HTMLFormControlElement* HTMLFormElement::defaultButton() const
+{
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
+ HTMLFormControlElement* control = m_associatedElements[i];
+ if (control->isSuccessfulSubmitButton())
+ return control;
+ }
+
+ return 0;
+}
+
+bool HTMLFormElement::checkValidity()
+{
+ Vector<RefPtr<HTMLFormControlElement> > controls;
+ collectUnhandledInvalidControls(controls);
+ return controls.isEmpty();
+}
+
+void HTMLFormElement::collectUnhandledInvalidControls(Vector<RefPtr<HTMLFormControlElement> >& unhandledInvalidControls)
+{
+ RefPtr<HTMLFormElement> protector(this);
+ // Copy m_associatedElements because event handlers called from
+ // HTMLFormControlElement::checkValidity() might change m_associatedElements.
+ Vector<RefPtr<HTMLFormControlElement> > elements;
+ elements.reserveCapacity(m_associatedElements.size());
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i)
+ elements.append(m_associatedElements[i]);
+ for (unsigned i = 0; i < elements.size(); ++i) {
+ if (elements[i]->form() == this)
+ elements[i]->checkValidity(&unhandledInvalidControls);
+ }
+}
+
+PassRefPtr<HTMLFormControlElement> HTMLFormElement::elementForAlias(const AtomicString& alias)
+{
+ if (alias.isEmpty() || !m_elementAliases)
+ return 0;
+ return m_elementAliases->get(alias.impl());
+}
+
+void HTMLFormElement::addElementAlias(HTMLFormControlElement* element, const AtomicString& alias)
+{
+ if (alias.isEmpty())
+ return;
+ if (!m_elementAliases)
+ m_elementAliases.set(new AliasMap);
+ m_elementAliases->set(alias.impl(), element);
+}
+
+void HTMLFormElement::getNamedElements(const AtomicString& name, Vector<RefPtr<Node> >& namedItems)
+{
+ elements()->namedItems(name, namedItems);
+
+ // see if we have seen something with this name before
+ RefPtr<HTMLFormControlElement> aliasElem;
+ if ((aliasElem = elementForAlias(name))) {
+ bool found = false;
+ for (unsigned n = 0; n < namedItems.size(); n++) {
+ if (namedItems[n] == aliasElem.get()) {
+ found = true;
+ break;
+ }
+ }
+ if (!found)
+ // we have seen it before but it is gone now. still, we need to return it.
+ namedItems.append(aliasElem.get());
+ }
+ // name has been accessed, remember it
+ if (namedItems.size() && aliasElem != namedItems.first())
+ addElementAlias(static_cast<HTMLFormControlElement*>(namedItems.first().get()), name);
+}
+
+void HTMLFormElement::documentDidBecomeActive()
+{
+ ASSERT(!m_autocomplete);
+
+ for (unsigned i = 0; i < m_associatedElements.size(); ++i)
+ m_associatedElements[i]->reset();
+}
+
+void HTMLFormElement::willMoveToNewOwnerDocument()
+{
+ if (!m_autocomplete)
+ document()->unregisterForDocumentActivationCallbacks(this);
+ HTMLElement::willMoveToNewOwnerDocument();
+}
+
+void HTMLFormElement::didMoveToNewOwnerDocument()
+{
+ if (!m_autocomplete)
+ document()->registerForDocumentActivationCallbacks(this);
+ HTMLElement::didMoveToNewOwnerDocument();
+}
+
+} // namespace