8df47769f163c2c77772152cdbb55d480fc6138f
[WebKit-https.git] / Source / WebCore / html / HTMLFormElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "HTMLFormElement.h"
27
28 #include "Attribute.h"
29 #include "Console.h"
30 #include "DOMFormData.h"
31 #include "DOMWindow.h"
32 #include "Document.h"
33 #include "Event.h"
34 #include "EventNames.h"
35 #include "FileList.h"
36 #include "FileSystem.h"
37 #include "FormData.h"
38 #include "FormDataList.h"
39 #include "FormState.h"
40 #include "Frame.h"
41 #include "FrameLoader.h"
42 #include "FrameLoaderClient.h"
43 #include "HTMLDocument.h"
44 #include "HTMLFormCollection.h"
45 #include "HTMLImageElement.h"
46 #include "HTMLInputElement.h"
47 #include "HTMLNames.h"
48 #include "MIMETypeRegistry.h"
49 #include "NodeRenderingContext.h"
50 #include "Page.h"
51 #include "RenderTextControl.h"
52 #include "ScriptEventListener.h"
53 #include "Settings.h"
54 #include "ValidityState.h"
55 #include <limits>
56
57 #if PLATFORM(WX)
58 #include <wx/defs.h>
59 #include <wx/filename.h>
60 #endif
61
62 using namespace std;
63
64 namespace WebCore {
65
66 using namespace HTMLNames;
67
68 HTMLFormElement::HTMLFormElement(const QualifiedName& tagName, Document* document)
69     : HTMLElement(tagName, document)
70     , m_associatedElementsBeforeIndex(0)
71     , m_associatedElementsAfterIndex(0)
72     , m_wasUserSubmitted(false)
73     , m_isSubmittingOrPreparingForSubmission(false)
74     , m_shouldSubmit(false)
75     , m_isInResetFunction(false)
76     , m_wasMalformed(false)
77     , m_wasDemoted(false)
78 {
79     ASSERT(hasTagName(formTag));
80 }
81
82 PassRefPtr<HTMLFormElement> HTMLFormElement::create(Document* document)
83 {
84     return adoptRef(new HTMLFormElement(formTag, document));
85 }
86
87 PassRefPtr<HTMLFormElement> HTMLFormElement::create(const QualifiedName& tagName, Document* document)
88 {
89     return adoptRef(new HTMLFormElement(tagName, document));
90 }
91
92 HTMLFormElement::~HTMLFormElement()
93 {
94     if (!autoComplete())
95         document()->unregisterForDocumentActivationCallbacks(this);
96
97     for (unsigned i = 0; i < m_associatedElements.size(); ++i)
98         m_associatedElements[i]->formDestroyed();
99     for (unsigned i = 0; i < m_imageElements.size(); ++i)
100         m_imageElements[i]->m_form = 0;
101 }
102
103 bool HTMLFormElement::formWouldHaveSecureSubmission(const String& url)
104 {
105     return document()->completeURL(url).protocolIs("https");
106 }
107
108 bool HTMLFormElement::rendererIsNeeded(const NodeRenderingContext& context)
109 {
110     if (!m_wasDemoted)
111         return HTMLElement::rendererIsNeeded(context);
112
113     ContainerNode* node = parentNode();
114     RenderObject* parentRenderer = node->renderer();
115     bool parentIsTableElementPart = (parentRenderer->isTable() && node->hasTagName(tableTag))
116         || (parentRenderer->isTableRow() && node->hasTagName(trTag))
117         || (parentRenderer->isTableSection() && node->hasTagName(tbodyTag))
118         || (parentRenderer->isTableCol() && node->hasTagName(colTag))
119         || (parentRenderer->isTableCell() && node->hasTagName(trTag));
120
121     if (!parentIsTableElementPart)
122         return true;
123
124     EDisplay display = context.style()->display();
125     bool formIsTablePart = display == TABLE || display == INLINE_TABLE || display == TABLE_ROW_GROUP
126         || display == TABLE_HEADER_GROUP || display == TABLE_FOOTER_GROUP || display == TABLE_ROW
127         || display == TABLE_COLUMN_GROUP || display == TABLE_COLUMN || display == TABLE_CELL
128         || display == TABLE_CAPTION;
129
130     return formIsTablePart;
131 }
132
133 void HTMLFormElement::insertedIntoDocument()
134 {
135     if (document()->isHTMLDocument())
136         static_cast<HTMLDocument*>(document())->addNamedItem(m_name);
137
138     HTMLElement::insertedIntoDocument();
139
140     if (hasID())
141         document()->resetFormElementsOwner(this);
142 }
143
144 void HTMLFormElement::removedFromDocument()
145 {
146     if (document()->isHTMLDocument())
147         static_cast<HTMLDocument*>(document())->removeNamedItem(m_name);
148
149     HTMLElement::removedFromDocument();
150
151     if (hasID())
152         document()->resetFormElementsOwner(0);
153 }
154
155 void HTMLFormElement::handleLocalEvents(Event* event)
156 {
157     Node* targetNode = event->target()->toNode();
158     if (event->eventPhase() != Event::CAPTURING_PHASE && targetNode && targetNode != this && (event->type() == eventNames().submitEvent || event->type() == eventNames().resetEvent)) {
159         event->stopPropagation();
160         return;
161     }
162     HTMLElement::handleLocalEvents(event);
163 }
164
165 unsigned HTMLFormElement::length() const
166 {
167     unsigned len = 0;
168     for (unsigned i = 0; i < m_associatedElements.size(); ++i)
169         if (m_associatedElements[i]->isEnumeratable())
170             ++len;
171     return len;
172 }
173
174 Node* HTMLFormElement::item(unsigned index)
175 {
176     return elements()->item(index);
177 }
178
179 void HTMLFormElement::submitImplicitly(Event* event, bool fromImplicitSubmissionTrigger)
180 {
181     int submissionTriggerCount = 0;
182     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
183         FormAssociatedElement* formAssociatedElement = m_associatedElements[i];
184         if (!formAssociatedElement->isFormControlElement())
185             continue;
186         HTMLFormControlElement* formElement = static_cast<HTMLFormControlElement*>(formAssociatedElement);
187         if (formElement->isSuccessfulSubmitButton()) {
188             if (formElement->renderer()) {
189                 formElement->dispatchSimulatedClick(event);
190                 return;
191             }
192         } else if (formElement->canTriggerImplicitSubmission())
193             ++submissionTriggerCount;
194     }
195     if (fromImplicitSubmissionTrigger && submissionTriggerCount == 1)
196         prepareForSubmission(event);
197 }
198
199 static inline HTMLFormControlElement* submitElementFromEvent(const Event* event)
200 {
201     Node* targetNode = event->target()->toNode();
202     if (!targetNode || !targetNode->isElementNode())
203         return 0;
204     Element* targetElement = static_cast<Element*>(targetNode);
205     if (!targetElement->isFormControlElement())
206         return 0;
207     return static_cast<HTMLFormControlElement*>(targetElement);
208 }
209
210 bool HTMLFormElement::validateInteractively(Event* event)
211 {
212     ASSERT(event);
213     if (!document()->page() || !document()->page()->settings()->interactiveFormValidationEnabled() || noValidate())
214         return true;
215
216     HTMLFormControlElement* submitElement = submitElementFromEvent(event);
217     if (submitElement && submitElement->formNoValidate())
218         return true;
219
220     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
221         if (m_associatedElements[i]->isFormControlElement())
222             static_cast<HTMLFormControlElement*>(m_associatedElements[i])->hideVisibleValidationMessage();
223     }
224
225     Vector<RefPtr<FormAssociatedElement> > unhandledInvalidControls;
226     if (!checkInvalidControlsAndCollectUnhandled(unhandledInvalidControls))
227         return true;
228     // Because the form has invalid controls, we abort the form submission and
229     // show a validation message on a focusable form control.
230
231     // Needs to update layout now because we'd like to call isFocusable(), which
232     // has !renderer()->needsLayout() assertion.
233     document()->updateLayoutIgnorePendingStylesheets();
234
235     RefPtr<HTMLFormElement> protector(this);
236     // Focus on the first focusable control and show a validation message.
237     for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
238         FormAssociatedElement* unhandledAssociatedElement = unhandledInvalidControls[i].get();
239         HTMLElement* unhandled = toHTMLElement(unhandledAssociatedElement);
240         if (unhandled->isFocusable() && unhandled->inDocument()) {
241             unhandled->scrollIntoViewIfNeeded(false);
242             unhandled->focus();
243             if (unhandled->isFormControlElement())
244                 static_cast<HTMLFormControlElement*>(unhandled)->updateVisibleValidationMessage();
245             break;
246         }
247     }
248     // Warn about all of unfocusable controls.
249     if (Frame* frame = document()->frame()) {
250         for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
251             FormAssociatedElement* unhandledAssociatedElement = unhandledInvalidControls[i].get();
252             HTMLElement* unhandled = toHTMLElement(unhandledAssociatedElement);
253             if (unhandled->isFocusable() && unhandled->inDocument())
254                 continue;
255             String message("An invalid form control with name='%name' is not focusable.");
256             message.replace("%name", unhandledAssociatedElement->name());
257             frame->domWindow()->console()->addMessage(HTMLMessageSource, LogMessageType, ErrorMessageLevel, message, 0, document()->url().string());
258         }
259     }
260     return false;
261 }
262
263 bool HTMLFormElement::prepareForSubmission(Event* event)
264 {
265     Frame* frame = document()->frame();
266     if (m_isSubmittingOrPreparingForSubmission || !frame)
267         return m_isSubmittingOrPreparingForSubmission;
268
269     m_isSubmittingOrPreparingForSubmission = true;
270     m_shouldSubmit = false;
271
272     // Interactive validation must be done before dispatching the submit event.
273     if (!validateInteractively(event)) {
274         m_isSubmittingOrPreparingForSubmission = false;
275         return false;
276     }
277
278     frame->loader()->client()->dispatchWillSendSubmitEvent(this);
279
280     if (dispatchEvent(Event::create(eventNames().submitEvent, true, true)))
281         m_shouldSubmit = true;
282
283     m_isSubmittingOrPreparingForSubmission = false;
284
285     if (m_shouldSubmit)
286         submit(event, true, true, NotSubmittedByJavaScript);
287
288     return m_shouldSubmit;
289 }
290
291 void HTMLFormElement::submit()
292 {
293     submit(0, false, true, NotSubmittedByJavaScript);
294 }
295
296 void HTMLFormElement::submitFromJavaScript()
297 {
298     submit(0, false, ScriptController::processingUserGesture(), SubmittedByJavaScript);
299 }
300
301 void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool processingUserGesture, FormSubmissionTrigger formSubmissionTrigger)
302 {
303     FrameView* view = document()->view();
304     Frame* frame = document()->frame();
305     if (!view || !frame)
306         return;
307
308     if (m_isSubmittingOrPreparingForSubmission) {
309         m_shouldSubmit = true;
310         return;
311     }
312
313     m_isSubmittingOrPreparingForSubmission = true;
314     m_wasUserSubmitted = processingUserGesture;
315
316     HTMLFormControlElement* firstSuccessfulSubmitButton = 0;
317     bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?
318
319     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
320         FormAssociatedElement* associatedElement = m_associatedElements[i];
321         if (!associatedElement->isFormControlElement())
322             continue;
323         if (needButtonActivation) {
324             HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(associatedElement);
325             if (control->isActivatedSubmit())
326                 needButtonActivation = false;
327             else if (firstSuccessfulSubmitButton == 0 && control->isSuccessfulSubmitButton())
328                 firstSuccessfulSubmitButton = control;
329         }
330     }
331
332     if (needButtonActivation && firstSuccessfulSubmitButton)
333         firstSuccessfulSubmitButton->setActivatedSubmit(true);
334
335     bool lockHistory = !processingUserGesture;
336     frame->loader()->submitForm(FormSubmission::create(this, m_attributes, event, lockHistory, formSubmissionTrigger));
337
338     if (needButtonActivation && firstSuccessfulSubmitButton)
339         firstSuccessfulSubmitButton->setActivatedSubmit(false);
340
341     m_shouldSubmit = false;
342     m_isSubmittingOrPreparingForSubmission = false;
343 }
344
345 void HTMLFormElement::reset()
346 {
347     Frame* frame = document()->frame();
348     if (m_isInResetFunction || !frame)
349         return;
350
351     m_isInResetFunction = true;
352
353     if (!dispatchEvent(Event::create(eventNames().resetEvent, true, true))) {
354         m_isInResetFunction = false;
355         return;
356     }
357
358     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
359         if (m_associatedElements[i]->isFormControlElement())
360             static_cast<HTMLFormControlElement*>(m_associatedElements[i])->reset();
361     }
362
363     m_isInResetFunction = false;
364 }
365
366 void HTMLFormElement::parseMappedAttribute(Attribute* attr)
367 {
368     if (attr->name() == actionAttr)
369         m_attributes.parseAction(attr->value());
370     else if (attr->name() == targetAttr)
371         m_attributes.setTarget(attr->value());
372     else if (attr->name() == methodAttr)
373         m_attributes.parseMethodType(attr->value());
374     else if (attr->name() == enctypeAttr)
375         m_attributes.parseEncodingType(attr->value());
376     else if (attr->name() == accept_charsetAttr)
377         m_attributes.setAcceptCharset(attr->value());
378     else if (attr->name() == autocompleteAttr) {
379         if (!autoComplete())
380             document()->registerForDocumentActivationCallbacks(this);
381         else
382             document()->unregisterForDocumentActivationCallbacks(this);
383     } else if (attr->name() == onsubmitAttr)
384         setAttributeEventListener(eventNames().submitEvent, createAttributeEventListener(this, attr));
385     else if (attr->name() == onresetAttr)
386         setAttributeEventListener(eventNames().resetEvent, createAttributeEventListener(this, attr));
387     else if (attr->name() == nameAttr) {
388         const AtomicString& newName = attr->value();
389         if (inDocument() && document()->isHTMLDocument()) {
390             HTMLDocument* document = static_cast<HTMLDocument*>(this->document());
391             document->removeNamedItem(m_name);
392             document->addNamedItem(newName);
393         }
394         m_name = newName;
395     } else
396         HTMLElement::parseMappedAttribute(attr);
397 }
398
399 template<class T, size_t n> static void removeFromVector(Vector<T*, n> & vec, T* item)
400 {
401     size_t size = vec.size();
402     for (size_t i = 0; i != size; ++i)
403         if (vec[i] == item) {
404             vec.remove(i);
405             break;
406         }
407 }
408
409 unsigned HTMLFormElement::formElementIndexWithFormAttribute(Element* element)
410 {
411     // Compares the position of the form element and the inserted element.
412     // Updates the indeces in order to the relation of the position:
413     unsigned short position = compareDocumentPosition(element);
414     if (position & (DOCUMENT_POSITION_CONTAINS | DOCUMENT_POSITION_CONTAINED_BY))
415         ++m_associatedElementsAfterIndex;
416     else if (position & DOCUMENT_POSITION_PRECEDING) {
417         ++m_associatedElementsBeforeIndex;
418         ++m_associatedElementsAfterIndex;
419     }
420
421     if (m_associatedElements.isEmpty())
422         return 0;
423
424     // Does binary search on m_associatedElements in order to find the index
425     // to be inserted.
426     unsigned left = 0, right = m_associatedElements.size() - 1;
427     while (left != right) {
428         unsigned middle = left + ((right - left) / 2);
429         position = element->compareDocumentPosition(toHTMLElement(m_associatedElements[middle]));
430         if (position & DOCUMENT_POSITION_FOLLOWING)
431             right = middle;
432         else
433             left = middle + 1;
434     }
435
436     position = element->compareDocumentPosition(toHTMLElement(m_associatedElements[left]));
437     if (position & DOCUMENT_POSITION_FOLLOWING)
438         return left;
439     return left + 1;
440 }
441
442 unsigned HTMLFormElement::formElementIndex(FormAssociatedElement* associatedElement)
443 {
444     HTMLElement* element = toHTMLElement(associatedElement);
445     // Treats separately the case where this element has the form attribute
446     // for performance consideration.
447     if (element->fastHasAttribute(formAttr))
448         return formElementIndexWithFormAttribute(element);
449
450     // Check for the special case where this element is the very last thing in
451     // the form's tree of children; we don't want to walk the entire tree in that
452     // common case that occurs during parsing; instead we'll just return a value
453     // that says "add this form element to the end of the array".
454     if (element->traverseNextNode(this)) {
455         unsigned i = m_associatedElementsBeforeIndex;
456         for (Node* node = this; node; node = node->traverseNextNode(this)) {
457             if (node == element) {
458                 ++m_associatedElementsAfterIndex;
459                 return i;
460             }
461             if (node->isHTMLElement()
462                     && (static_cast<Element*>(node)->isFormControlElement()
463                         || node->hasTagName(objectTag))
464                     && toHTMLElement(node)->form() == this)
465                 ++i;
466         }
467     }
468     return m_associatedElementsAfterIndex++;
469 }
470
471 void HTMLFormElement::registerFormElement(FormAssociatedElement* e)
472 {
473     if (e->isFormControlElement()) {
474         HTMLFormControlElement* element = static_cast<HTMLFormControlElement*>(e);
475         document()->checkedRadioButtons().removeButton(element);
476         m_checkedRadioButtons.addButton(element);
477     }
478     m_associatedElements.insert(formElementIndex(e), e);
479 }
480
481 void HTMLFormElement::removeFormElement(FormAssociatedElement* e)
482 {
483     if (e->isFormControlElement())
484         m_checkedRadioButtons.removeButton(static_cast<HTMLFormControlElement*>(e));
485     unsigned index;
486     for (index = 0; index < m_associatedElements.size(); ++index) {
487         if (m_associatedElements[index] == e)
488             break;
489     }
490     ASSERT(index < m_associatedElements.size());
491     if (index < m_associatedElementsBeforeIndex)
492         --m_associatedElementsBeforeIndex;
493     if (index < m_associatedElementsAfterIndex)
494         --m_associatedElementsAfterIndex;
495     removeFromVector(m_associatedElements, e);
496 }
497
498 bool HTMLFormElement::isURLAttribute(Attribute* attr) const
499 {
500     return attr->name() == actionAttr;
501 }
502
503 void HTMLFormElement::registerImgElement(HTMLImageElement* e)
504 {
505     ASSERT(m_imageElements.find(e) == notFound);
506     m_imageElements.append(e);
507 }
508
509 void HTMLFormElement::removeImgElement(HTMLImageElement* e)
510 {
511     ASSERT(m_imageElements.find(e) != notFound);
512     removeFromVector(m_imageElements, e);
513 }
514
515 PassRefPtr<HTMLCollection> HTMLFormElement::elements()
516 {
517     return HTMLFormCollection::create(this);
518 }
519
520 String HTMLFormElement::name() const
521 {
522     return getAttribute(nameAttr);
523 }
524
525 bool HTMLFormElement::noValidate() const
526 {
527     return fastHasAttribute(novalidateAttr);
528 }
529
530 // FIXME: This function should be removed because it does not do the same thing as the
531 // JavaScript binding for action, which treats action as a URL attribute. Last time I
532 // (Darin Adler) removed this, someone added it back, so I am leaving it in for now.
533 String HTMLFormElement::action() const
534 {
535     return getAttribute(actionAttr);
536 }
537
538 void HTMLFormElement::setAction(const String &value)
539 {
540     setAttribute(actionAttr, value);
541 }
542
543 void HTMLFormElement::setEnctype(const String &value)
544 {
545     setAttribute(enctypeAttr, value);
546 }
547
548 String HTMLFormElement::method() const
549 {
550     return getAttribute(methodAttr);
551 }
552
553 void HTMLFormElement::setMethod(const String &value)
554 {
555     setAttribute(methodAttr, value);
556 }
557
558 String HTMLFormElement::target() const
559 {
560     return getAttribute(targetAttr);
561 }
562
563 bool HTMLFormElement::wasUserSubmitted() const
564 {
565     return m_wasUserSubmitted;
566 }
567
568 HTMLFormControlElement* HTMLFormElement::defaultButton() const
569 {
570     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
571         if (!m_associatedElements[i]->isFormControlElement())
572             continue;
573         HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(m_associatedElements[i]);
574         if (control->isSuccessfulSubmitButton())
575             return control;
576     }
577
578     return 0;
579 }
580
581 bool HTMLFormElement::checkValidity()
582 {
583     Vector<RefPtr<FormAssociatedElement> > controls;
584     return !checkInvalidControlsAndCollectUnhandled(controls);
585 }
586
587 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(Vector<RefPtr<FormAssociatedElement> >& unhandledInvalidControls)
588 {
589     RefPtr<HTMLFormElement> protector(this);
590     // Copy m_associatedElements because event handlers called from
591     // HTMLFormControlElement::checkValidity() might change m_associatedElements.
592     Vector<RefPtr<FormAssociatedElement> > elements;
593     elements.reserveCapacity(m_associatedElements.size());
594     for (unsigned i = 0; i < m_associatedElements.size(); ++i)
595         elements.append(m_associatedElements[i]);
596     bool hasInvalidControls = false;
597     for (unsigned i = 0; i < elements.size(); ++i) {
598         if (elements[i]->form() == this && elements[i]->isFormControlElement()) {
599             HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(elements[i].get());
600             if (!control->checkValidity(&unhandledInvalidControls) && control->form() == this)
601                 hasInvalidControls = true;
602         }
603     }
604     return hasInvalidControls;
605 }
606
607 HTMLFormControlElement* HTMLFormElement::elementForAlias(const AtomicString& alias)
608 {
609     if (alias.isEmpty() || !m_elementAliases)
610         return 0;
611     return m_elementAliases->get(alias.impl()).get();
612 }
613
614 void HTMLFormElement::addElementAlias(HTMLFormControlElement* element, const AtomicString& alias)
615 {
616     if (alias.isEmpty())
617         return;
618     if (!m_elementAliases)
619         m_elementAliases = adoptPtr(new AliasMap);
620     m_elementAliases->set(alias.impl(), element);
621 }
622
623 void HTMLFormElement::getNamedElements(const AtomicString& name, Vector<RefPtr<Node> >& namedItems)
624 {
625     elements()->namedItems(name, namedItems);
626
627     HTMLFormControlElement* aliasElement = elementForAlias(name);
628     if (aliasElement) {
629         if (namedItems.find(aliasElement) == notFound) {
630             // We have seen it before but it is gone now. Still, we need to return it.
631             // FIXME: The above comment is not clear enough; it does not say why we need to do this.
632             namedItems.append(aliasElement);
633         }
634     }
635     if (namedItems.size() && namedItems.first() != aliasElement)
636         addElementAlias(static_cast<HTMLFormControlElement*>(namedItems.first().get()), name);
637 }
638
639 void HTMLFormElement::documentDidBecomeActive()
640 {
641     ASSERT(!autoComplete());
642
643     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
644         if (m_associatedElements[i]->isFormControlElement())
645             static_cast<HTMLFormControlElement*>(m_associatedElements[i])->reset();
646     }
647 }
648
649 void HTMLFormElement::willMoveToNewOwnerDocument()
650 {
651     if (!autoComplete())
652         document()->unregisterForDocumentActivationCallbacks(this);
653     HTMLElement::willMoveToNewOwnerDocument();
654 }
655
656 void HTMLFormElement::didMoveToNewOwnerDocument()
657 {
658     if (!autoComplete())
659         document()->registerForDocumentActivationCallbacks(this);
660     HTMLElement::didMoveToNewOwnerDocument();
661 }
662
663 bool HTMLFormElement::autoComplete() const
664 {
665     return !equalIgnoringCase(fastGetAttribute(autocompleteAttr), "off");
666 }
667
668 } // namespace