REGRESSION(r94274): FormManagerTest.PreviewForm and FillFormNonEmptyField fail on...
[WebKit-https.git] / Source / WebCore / html / HTMLInputElement.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, 2010, 2011 Apple Inc. All rights reserved.
6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
7  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
8  * Copyright (C) 2010 Google Inc. All rights reserved.
9  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  *
26  */
27
28 #include "config.h"
29 #include "HTMLInputElement.h"
30
31 #include "AXObjectCache.h"
32 #include "BeforeTextInsertedEvent.h"
33 #include "CSSPropertyNames.h"
34 #include "CSSValueKeywords.h"
35 #include "Document.h"
36 #include "EventNames.h"
37 #include "ExceptionCode.h"
38 #include "FileList.h"
39 #include "Frame.h"
40 #include "HTMLCollection.h"
41 #include "HTMLDataListElement.h"
42 #include "HTMLFormElement.h"
43 #include "HTMLNames.h"
44 #include "HTMLOptionElement.h"
45 #include "HTMLParserIdioms.h"
46 #include "InputType.h"
47 #include "KeyboardEvent.h"
48 #include "LocalizedStrings.h"
49 #include "MouseEvent.h"
50 #include "NumberInputType.h"
51 #include "RenderTextControlSingleLine.h"
52 #include "RenderTheme.h"
53 #include "SearchInputType.h"
54 #include "ScriptEventListener.h"
55 #include "WheelEvent.h"
56 #include <wtf/MathExtras.h>
57 #include <wtf/StdLibExtras.h>
58
59 #if ENABLE(INPUT_COLOR)
60 #include "ColorChooser.h"
61 #include "ColorInputType.h"
62 #endif
63
64 #if ENABLE(INPUT_SPEECH)
65 #include "RuntimeEnabledFeatures.h"
66 #endif
67
68 using namespace std;
69
70 namespace WebCore {
71
72 using namespace HTMLNames;
73
74 // FIXME: According to HTML4, the length attribute's value can be arbitrarily
75 // large. However, due to https://bugs.webkit.org/show_bug.cgi?id=14536 things
76 // get rather sluggish when a text field has a larger number of characters than
77 // this, even when just clicking in the text field.
78 const int HTMLInputElement::maximumLength = 524288;
79 const int defaultSize = 20;
80 const int maxSavedResults = 256;
81
82 HTMLInputElement::HTMLInputElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
83     : HTMLTextFormControlElement(tagName, document, form)
84     , m_size(defaultSize)
85     , m_maxLength(maximumLength)
86 #if ENABLE(WCSS)
87     , m_inputFormatMask("*m")
88     , m_maxInputCharsAllowed(maximumLength)
89 #endif
90     , m_maxResults(-1)
91     , m_isChecked(false)
92     , m_reflectsCheckedAttribute(true)
93     , m_isIndeterminate(false)
94     , m_hasType(false)
95     , m_isActivatedSubmit(false)
96     , m_autocomplete(Uninitialized)
97     , m_isAutofilled(false)
98     , m_stateRestored(false)
99     , m_parsingInProgress(createdByParser)
100     , m_wasModifiedByUser(false)
101     , m_inputType(InputType::createText(this))
102 {
103     ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));
104 }
105
106 PassRefPtr<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
107 {
108     RefPtr<HTMLInputElement> inputElement = adoptRef(new HTMLInputElement(tagName, document, form, createdByParser));
109     inputElement->createShadowSubtree();
110     return inputElement.release();
111 }
112
113 void HTMLInputElement::createShadowSubtree()
114 {
115     m_inputType->createShadowSubtree();
116 }
117
118 HTMLInputElement::~HTMLInputElement()
119 {
120     if (needsActivationCallback())
121         document()->unregisterForDocumentActivationCallbacks(this);
122
123     document()->checkedRadioButtons().removeButton(this);
124
125     // Need to remove this from the form while it is still an HTMLInputElement,
126     // so can't wait for the base class's destructor to do it.
127     removeFromForm();
128 }
129
130 const AtomicString& HTMLInputElement::formControlName() const
131 {
132     return m_name.isNull() ? emptyAtom : m_name;
133 }
134
135 HTMLElement* HTMLInputElement::containerElement() const
136 {
137     return m_inputType->containerElement();
138 }
139
140 HTMLElement* HTMLInputElement::innerTextElement() const
141 {
142     return m_inputType->innerTextElement();
143 }
144
145 HTMLElement* HTMLInputElement::innerBlockElement() const
146 {
147     return m_inputType->innerBlockElement();
148 }
149
150 HTMLElement* HTMLInputElement::innerSpinButtonElement() const
151 {
152     return m_inputType->innerSpinButtonElement();
153 }
154
155 HTMLElement* HTMLInputElement::resultsButtonElement() const
156 {
157     return m_inputType->resultsButtonElement();
158 }
159
160 HTMLElement* HTMLInputElement::cancelButtonElement() const
161 {
162     return m_inputType->cancelButtonElement();
163 }
164
165 #if ENABLE(INPUT_SPEECH)
166 HTMLElement* HTMLInputElement::speechButtonElement() const
167 {
168     return m_inputType->speechButtonElement();
169 }
170 #endif
171
172 HTMLElement* HTMLInputElement::placeholderElement() const
173 {
174     return m_inputType->placeholderElement();
175 }
176
177 bool HTMLInputElement::shouldAutocomplete() const
178 {
179     if (m_autocomplete != Uninitialized)
180         return m_autocomplete == On;
181     return HTMLTextFormControlElement::shouldAutocomplete();
182 }
183
184 void HTMLInputElement::updateCheckedRadioButtons()
185 {
186     if (attached() && checked())
187         checkedRadioButtons().addButton(this);
188
189     if (form()) {
190         const Vector<FormAssociatedElement*>& controls = form()->associatedElements();
191         for (unsigned i = 0; i < controls.size(); ++i) {
192             if (!controls[i]->isFormControlElement())
193                 continue;
194             HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(controls[i]);
195             if (control->name() != name())
196                 continue;
197             if (control->type() != type())
198                 continue;
199             control->setNeedsValidityCheck();
200         }
201     } else {
202         typedef Document::FormElementListHashSet::const_iterator Iterator;
203         Iterator end = document()->getFormElements()->end();
204         for (Iterator it = document()->getFormElements()->begin(); it != end; ++it) {
205             Element* element = *it;
206             if (element->formControlName() != name())
207                 continue;
208             if (element->formControlType() != type())
209                 continue;
210             HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(element);
211             if (control->form())
212                 continue;
213             control->setNeedsValidityCheck();
214         }
215     }
216 }
217
218 bool HTMLInputElement::isValidValue(const String& value) const
219 {
220     if (!m_inputType->canSetStringValue()) {
221         ASSERT_NOT_REACHED();
222         return false;
223     }
224     return !m_inputType->typeMismatchFor(value)
225         && !stepMismatch(value)
226         && !rangeUnderflow(value)
227         && !rangeOverflow(value)
228         && !tooLong(value, IgnoreDirtyFlag)
229         && !patternMismatch(value)
230         && !valueMissing(value);
231 }
232
233 bool HTMLInputElement::typeMismatch() const
234 {
235     return m_inputType->typeMismatch();
236 }
237
238 bool HTMLInputElement::valueMissing(const String& value) const
239 {
240     if (!isRequiredFormControl() || readOnly() || disabled())
241         return false;
242     return m_inputType->valueMissing(value);
243 }
244
245 bool HTMLInputElement::patternMismatch(const String& value) const
246 {
247     return m_inputType->patternMismatch(value);
248 }
249
250 bool HTMLInputElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const
251 {
252     // We use isTextType() instead of supportsMaxLength() because of the
253     // 'virtual' overhead.
254     if (!isTextType())
255         return false;
256     int max = maxLength();
257     if (max < 0)
258         return false;
259     if (check == CheckDirtyFlag) {
260         // Return false for the default value or a value set by a script even if
261         // it is longer than maxLength.
262         if (!hasDirtyValue() || !m_wasModifiedByUser)
263             return false;
264     }
265     return numGraphemeClusters(value) > static_cast<unsigned>(max);
266 }
267
268 bool HTMLInputElement::rangeUnderflow(const String& value) const
269 {
270     return m_inputType->rangeUnderflow(value);
271 }
272
273 bool HTMLInputElement::rangeOverflow(const String& value) const
274 {
275     return m_inputType->rangeOverflow(value);
276 }
277
278 double HTMLInputElement::minimum() const
279 {
280     return m_inputType->minimum();
281 }
282
283 double HTMLInputElement::maximum() const
284 {
285     return m_inputType->maximum();
286 }
287
288 bool HTMLInputElement::stepMismatch(const String& value) const
289 {
290     double step;
291     if (!getAllowedValueStep(&step))
292         return false;
293     return m_inputType->stepMismatch(value, step);
294 }
295
296 String HTMLInputElement::minimumString() const
297 {
298     return m_inputType->serialize(minimum());
299 }
300
301 String HTMLInputElement::maximumString() const
302 {
303     return m_inputType->serialize(maximum());
304 }
305
306 String HTMLInputElement::stepBaseString() const
307 {
308     return m_inputType->serialize(m_inputType->stepBase());
309 }
310
311 String HTMLInputElement::stepString() const
312 {
313     double step;
314     if (!getAllowedValueStep(&step)) {
315         // stepString() should be called only if stepMismatch() can be true.
316         ASSERT_NOT_REACHED();
317         return String();
318     }
319     return serializeForNumberType(step / m_inputType->stepScaleFactor());
320 }
321
322 String HTMLInputElement::typeMismatchText() const
323 {
324     return m_inputType->typeMismatchText();
325 }
326
327 String HTMLInputElement::valueMissingText() const
328 {
329     return m_inputType->valueMissingText();
330 }
331
332 bool HTMLInputElement::getAllowedValueStep(double* step) const
333 {
334     return getAllowedValueStepWithDecimalPlaces(RejectAny, step, 0);
335 }
336
337 bool HTMLInputElement::getAllowedValueStepWithDecimalPlaces(AnyStepHandling anyStepHandling, double* step, unsigned* decimalPlaces) const
338 {
339     ASSERT(step);
340     double defaultStep = m_inputType->defaultStep();
341     double stepScaleFactor = m_inputType->stepScaleFactor();
342     if (!isfinite(defaultStep) || !isfinite(stepScaleFactor))
343         return false;
344     const AtomicString& stepString = fastGetAttribute(stepAttr);
345     if (stepString.isEmpty()) {
346         *step = defaultStep * stepScaleFactor;
347         if (decimalPlaces)
348             *decimalPlaces = 0;
349         return true;
350     }
351
352     if (equalIgnoringCase(stepString, "any")) {
353         switch (anyStepHandling) {
354         case RejectAny:
355             return false;
356         case AnyIsDefaultStep:
357             *step = defaultStep * stepScaleFactor;
358             if (decimalPlaces)
359                 *decimalPlaces = 0;
360             return true;
361         default:
362             ASSERT_NOT_REACHED();
363         }
364     }
365
366     double parsed;
367     if (!decimalPlaces) {
368         if (!parseToDoubleForNumberType(stepString, &parsed) || parsed <= 0.0) {
369             *step = defaultStep * stepScaleFactor;
370             return true;
371         }
372     } else {
373         if (!parseToDoubleForNumberTypeWithDecimalPlaces(stepString, &parsed, decimalPlaces) || parsed <= 0.0) {
374             *step = defaultStep * stepScaleFactor;
375             *decimalPlaces = 0;
376             return true;
377         }
378     }
379     // For date, month, week, the parsed value should be an integer for some types.
380     if (m_inputType->parsedStepValueShouldBeInteger())
381         parsed = max(round(parsed), 1.0);
382     double result = parsed * stepScaleFactor;
383     // For datetime, datetime-local, time, the result should be an integer.
384     if (m_inputType->scaledStepValueShouldBeInteger())
385         result = max(round(result), 1.0);
386     ASSERT(result > 0);
387     *step = result;
388     return true;
389 }
390
391 void HTMLInputElement::applyStep(double count, AnyStepHandling anyStepHandling, ExceptionCode& ec)
392 {
393     double step;
394     unsigned stepDecimalPlaces, currentDecimalPlaces;
395     if (!getAllowedValueStepWithDecimalPlaces(anyStepHandling, &step, &stepDecimalPlaces)) {
396         ec = INVALID_STATE_ERR;
397         return;
398     }
399
400     const double nan = numeric_limits<double>::quiet_NaN();
401     double current = m_inputType->parseToDoubleWithDecimalPlaces(value(), nan, &currentDecimalPlaces);
402     if (!isfinite(current)) {
403         ec = INVALID_STATE_ERR;
404         return;
405     }
406     double newValue = current + step * count;
407     if (isinf(newValue)) {
408         ec = INVALID_STATE_ERR;
409         return;
410     }
411
412     double acceptableError = m_inputType->acceptableError(step);
413     if (newValue - m_inputType->minimum() < -acceptableError) {
414         ec = INVALID_STATE_ERR;
415         return;
416     }
417     if (newValue < m_inputType->minimum())
418         newValue = m_inputType->minimum();
419
420     const AtomicString& stepString = fastGetAttribute(stepAttr);
421     if (!equalIgnoringCase(stepString, "any"))
422         newValue = alignValueForStep(newValue, step, currentDecimalPlaces, stepDecimalPlaces);
423
424     if (newValue - m_inputType->maximum() > acceptableError) {
425         ec = INVALID_STATE_ERR;
426         return;
427     }
428     if (newValue > m_inputType->maximum())
429         newValue = m_inputType->maximum();
430
431     setValueAsNumber(newValue, ec);
432
433     if (AXObjectCache::accessibilityEnabled())
434          document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXValueChanged, true);
435 }
436
437 double HTMLInputElement::alignValueForStep(double newValue, double step, unsigned currentDecimalPlaces, unsigned stepDecimalPlaces)
438 {
439     if (newValue >= pow(10.0, 21.0))
440         return newValue;
441
442     unsigned baseDecimalPlaces;
443     double base = m_inputType->stepBaseWithDecimalPlaces(&baseDecimalPlaces);
444     baseDecimalPlaces = min(baseDecimalPlaces, 16u);
445     if (stepMismatch(value())) {
446         double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, currentDecimalPlaces)));
447         newValue = round(newValue * scale) / scale;
448     } else {
449         double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, baseDecimalPlaces)));
450         newValue = round((base + round((newValue - base) / step) * step) * scale) / scale;
451     }
452
453     return newValue;
454 }
455
456 void HTMLInputElement::stepUp(int n, ExceptionCode& ec)
457 {
458     applyStep(n, RejectAny, ec);
459 }
460
461 void HTMLInputElement::stepDown(int n, ExceptionCode& ec)
462 {
463     applyStep(-n, RejectAny, ec);
464 }
465
466 bool HTMLInputElement::isKeyboardFocusable(KeyboardEvent* event) const
467 {
468     if (isTextField())
469         return HTMLTextFormControlElement::isFocusable();
470     return HTMLTextFormControlElement::isKeyboardFocusable(event) && m_inputType->isKeyboardFocusable();
471 }
472
473 bool HTMLInputElement::isMouseFocusable() const
474 {
475     if (isTextField())
476         return HTMLTextFormControlElement::isFocusable();
477     return HTMLTextFormControlElement::isMouseFocusable();
478 }
479
480 void HTMLInputElement::updateFocusAppearance(bool restorePreviousSelection)
481 {
482     if (isTextField()) {
483         if (!restorePreviousSelection || !hasCachedSelection())
484             select();
485         else
486             restoreCachedSelection();
487         if (document()->frame())
488             document()->frame()->selection()->revealSelection();
489     } else
490         HTMLTextFormControlElement::updateFocusAppearance(restorePreviousSelection);
491 }
492
493 void HTMLInputElement::aboutToUnload()
494 {
495     if (!isTextField() || !focused())
496         return;
497
498     Frame* frame = document()->frame();
499     if (!frame)
500         return;
501
502     frame->editor()->textFieldDidEndEditing(this);
503 }
504
505 bool HTMLInputElement::shouldUseInputMethod()
506 {
507     return m_inputType->shouldUseInputMethod();
508 }
509
510 void HTMLInputElement::handleFocusEvent()
511 {
512     if (!isTextField())
513         return;
514     if (isPasswordField() && document()->frame())
515         document()->setUseSecureKeyboardEntryWhenActive(true);
516 }
517
518 void HTMLInputElement::willBlur()
519 {
520     m_inputType->willBlur();
521     HTMLTextFormControlElement::willBlur();
522 }
523
524 void HTMLInputElement::handleBlurEvent()
525 {
526     if (!isTextField())
527         return;
528     Frame* frame = document()->frame();
529     if (!frame)
530         return;
531     if (isPasswordField())
532         document()->setUseSecureKeyboardEntryWhenActive(false);
533     frame->editor()->textFieldDidEndEditing(this);
534 }
535
536 void HTMLInputElement::setType(const String& type)
537 {
538     // FIXME: This should just call setAttribute. No reason to handle the empty string specially.
539     // We should write a test case to show that setting to the empty string does not remove the
540     // attribute in other browsers and then fix this. Note that setting to null *does* remove
541     // the attribute and setAttribute implements that.
542     if (type.isEmpty()) {
543         ExceptionCode ec;
544         removeAttribute(typeAttr, ec);
545     } else
546         setAttribute(typeAttr, type);
547 }
548
549 void HTMLInputElement::updateType()
550 {
551     OwnPtr<InputType> newType = InputType::create(this, fastGetAttribute(typeAttr));
552     bool hadType = m_hasType;
553     m_hasType = true;
554     if (m_inputType->formControlType() == newType->formControlType())
555         return;
556
557     if (hadType && !newType->canChangeFromAnotherType()) {
558         // Set the attribute back to the old value.
559         // Useful in case we were called from inside parseMappedAttribute.
560         setAttribute(typeAttr, type());
561         return;
562     }
563
564     checkedRadioButtons().removeButton(this);
565
566     bool wasAttached = attached();
567     if (wasAttached)
568         detach();
569
570     bool didStoreValue = m_inputType->storesValueSeparateFromAttribute();
571     bool neededActivationCallback = needsActivationCallback();
572     bool didRespectHeightAndWidth = m_inputType->shouldRespectHeightAndWidthAttributes();
573
574     m_inputType->destroyShadowSubtree();
575     m_inputType = newType.release();
576     m_inputType->createShadowSubtree();
577
578     setNeedsWillValidateCheck();
579
580     bool willStoreValue = m_inputType->storesValueSeparateFromAttribute();
581
582     if (didStoreValue && !willStoreValue && hasDirtyValue()) {
583         setAttribute(valueAttr, m_valueIfDirty);
584         m_valueIfDirty = String();
585     }
586     if (!didStoreValue && willStoreValue)
587         m_valueIfDirty = sanitizeValue(fastGetAttribute(valueAttr));
588     else
589         updateValueIfNeeded();
590
591     setFormControlValueMatchesRenderer(false);
592     updateInnerTextValue();
593
594     m_wasModifiedByUser = false;
595
596     if (neededActivationCallback)
597         unregisterForActivationCallbackIfNeeded();
598     else
599         registerForActivationCallbackIfNeeded();
600
601     if (didRespectHeightAndWidth != m_inputType->shouldRespectHeightAndWidthAttributes()) {
602         NamedNodeMap* map = attributeMap();
603         ASSERT(map);
604         if (Attribute* height = map->getAttributeItem(heightAttr))
605             attributeChanged(height, false);
606         if (Attribute* width = map->getAttributeItem(widthAttr))
607             attributeChanged(width, false);
608         if (Attribute* align = map->getAttributeItem(alignAttr))
609             attributeChanged(align, false);
610     }
611
612     if (wasAttached) {
613         attach();
614         if (document()->focusedNode() == this)
615             updateFocusAppearance(true);
616     }
617
618     setChangedSinceLastFormControlChangeEvent(false);
619
620     checkedRadioButtons().addButton(this);
621
622     setNeedsValidityCheck();
623     notifyFormStateChanged();
624 }
625
626 void HTMLInputElement::updateInnerTextValue()
627 {
628     if (!isTextField())
629         return;
630
631     if (!suggestedValue().isNull())
632         setInnerTextValue(suggestedValue());
633     else if (!formControlValueMatchesRenderer()) {
634         // Update the renderer value if the formControlValueMatchesRenderer() flag is false.
635         // It protects an unacceptable renderer value from being overwritten with the DOM value.
636         setInnerTextValue(visibleValue());
637     }
638 }
639
640 void HTMLInputElement::subtreeHasChanged()
641 {
642     ASSERT(isTextField());
643     ASSERT(renderer());
644     RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(renderer());
645
646     bool wasChanged = wasChangedSinceLastFormControlChangeEvent();
647     setChangedSinceLastFormControlChangeEvent(true);
648
649     // We don't need to call sanitizeUserInputValue() function here because
650     // HTMLInputElement::handleBeforeTextInsertedEvent() has already called
651     // sanitizeUserInputValue().
652     // sanitizeValue() is needed because IME input doesn't dispatch BeforeTextInsertedEvent.
653     String value = innerTextValue();
654     if (isAcceptableValue(value))
655         setValueFromRenderer(sanitizeValue(convertFromVisibleValue(value)));
656     // Recalc for :invalid and hasUnacceptableValue() change.
657     setNeedsStyleRecalc();
658
659     if (cancelButtonElement())
660         renderTextControl->updateCancelButtonVisibility();
661
662     // If the incremental attribute is set, then dispatch the search event
663     if (searchEventsShouldBeDispatched() && isSearchField() && m_inputType)
664         static_cast<SearchInputType*>(m_inputType.get())->startSearchEventTimer();
665
666     if (!wasChanged && focused()) {
667         if (Frame* frame = document()->frame())
668             frame->editor()->textFieldDidBeginEditing(this);
669     }
670
671     if (focused()) {
672         if (Frame* frame = document()->frame())
673             frame->editor()->textDidChangeInTextField(this);
674     }
675     // When typing in an input field, childrenChanged is not called, so we need to force the directionality check.
676     if (isTextField())
677         calculateAndAdjustDirectionality();
678 }
679
680 const AtomicString& HTMLInputElement::formControlType() const
681 {
682     return m_inputType->formControlType();
683 }
684
685 bool HTMLInputElement::saveFormControlState(String& result) const
686 {
687     return m_inputType->saveFormControlState(result);
688 }
689
690 void HTMLInputElement::restoreFormControlState(const String& state)
691 {
692     m_inputType->restoreFormControlState(state);
693     m_stateRestored = true;
694 }
695
696 bool HTMLInputElement::canStartSelection() const
697 {
698     if (!isTextField())
699         return false;
700     return HTMLTextFormControlElement::canStartSelection();
701 }
702
703 bool HTMLInputElement::canHaveSelection() const
704 {
705     return isTextField();
706 }
707
708 void HTMLInputElement::accessKeyAction(bool sendToAnyElement)
709 {
710     m_inputType->accessKeyAction(sendToAnyElement);
711 }
712
713 bool HTMLInputElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
714 {
715     if (((attrName == heightAttr || attrName == widthAttr) && m_inputType->shouldRespectHeightAndWidthAttributes())
716         || attrName == vspaceAttr
717         || attrName == hspaceAttr) {
718         result = eUniversal;
719         return false;
720     }
721
722     if (attrName == alignAttr && m_inputType->shouldRespectAlignAttribute()) {
723         // Share with <img> since the alignment behavior is the same.
724         result = eReplaced;
725         return false;
726     }
727
728     return HTMLElement::mapToEntry(attrName, result);
729 }
730
731 void HTMLInputElement::parseMappedAttribute(Attribute* attr)
732 {
733     if (attr->name() == nameAttr) {
734         checkedRadioButtons().removeButton(this);
735         m_name = attr->value();
736         checkedRadioButtons().addButton(this);
737         HTMLTextFormControlElement::parseMappedAttribute(attr);
738     } else if (attr->name() == autocompleteAttr) {
739         if (equalIgnoringCase(attr->value(), "off")) {
740             m_autocomplete = Off;
741             registerForActivationCallbackIfNeeded();
742         } else {
743             bool needsToUnregister = m_autocomplete == Off;
744
745             if (attr->isEmpty())
746                 m_autocomplete = Uninitialized;
747             else
748                 m_autocomplete = On;
749
750             if (needsToUnregister)
751                 unregisterForActivationCallbackIfNeeded();
752         }
753     } else if (attr->name() == typeAttr) {
754         updateType();
755     } else if (attr->name() == valueAttr) {
756         // We only need to setChanged if the form is looking at the default value right now.
757         if (!hasDirtyValue())
758             setNeedsStyleRecalc();
759         setFormControlValueMatchesRenderer(false);
760         setNeedsValidityCheck();
761     } else if (attr->name() == checkedAttr) {
762         // Another radio button in the same group might be checked by state
763         // restore. We shouldn't call setChecked() even if this has the checked
764         // attribute. So, delay the setChecked() call until
765         // finishParsingChildren() is called if parsing is in progress.
766         if (!m_parsingInProgress && m_reflectsCheckedAttribute) {
767             setChecked(!attr->isNull());
768             m_reflectsCheckedAttribute = true;
769         }
770     } else if (attr->name() == maxlengthAttr)
771         parseMaxLengthAttribute(attr);
772     else if (attr->name() == sizeAttr) {
773         m_size = attr->isNull() ? defaultSize : attr->value().toInt();
774         if (renderer())
775             renderer()->setNeedsLayoutAndPrefWidthsRecalc();
776     } else if (attr->name() == altAttr)
777         m_inputType->altAttributeChanged();
778     else if (attr->name() == srcAttr)
779         m_inputType->srcAttributeChanged();
780     else if (attr->name() == usemapAttr || attr->name() == accesskeyAttr) {
781         // FIXME: ignore for the moment
782     } else if (attr->name() == vspaceAttr) {
783         addCSSLength(attr, CSSPropertyMarginTop, attr->value());
784         addCSSLength(attr, CSSPropertyMarginBottom, attr->value());
785     } else if (attr->name() == hspaceAttr) {
786         addCSSLength(attr, CSSPropertyMarginLeft, attr->value());
787         addCSSLength(attr, CSSPropertyMarginRight, attr->value());
788     } else if (attr->name() == alignAttr) {
789         if (m_inputType->shouldRespectAlignAttribute())
790             addHTMLAlignment(attr);
791     } else if (attr->name() == widthAttr) {
792         if (m_inputType->shouldRespectHeightAndWidthAttributes())
793             addCSSLength(attr, CSSPropertyWidth, attr->value());
794     } else if (attr->name() == heightAttr) {
795         if (m_inputType->shouldRespectHeightAndWidthAttributes())
796             addCSSLength(attr, CSSPropertyHeight, attr->value());
797     } else if (attr->name() == borderAttr && isImageButton()) {
798         applyBorderAttribute(attr);
799     } else if (attr->name() == onsearchAttr) {
800         // Search field and slider attributes all just cause updateFromElement to be called through style recalcing.
801         setAttributeEventListener(eventNames().searchEvent, createAttributeEventListener(this, attr));
802     } else if (attr->name() == resultsAttr) {
803         int oldResults = m_maxResults;
804         m_maxResults = !attr->isNull() ? std::min(attr->value().toInt(), maxSavedResults) : -1;
805         // FIXME: Detaching just for maxResults change is not ideal.  We should figure out the right
806         // time to relayout for this change.
807         if (m_maxResults != oldResults && (m_maxResults <= 0 || oldResults <= 0))
808             reattachIfAttached();
809         setNeedsStyleRecalc();
810     } else if (attr->name() == autosaveAttr || attr->name() == incrementalAttr)
811         setNeedsStyleRecalc();
812     else if (attr->name() == minAttr || attr->name() == maxAttr) {
813         m_inputType->minOrMaxAttributeChanged();
814         setNeedsValidityCheck();
815     } else if (attr->name() == multipleAttr) {
816         m_inputType->multipleAttributeChanged();
817         setNeedsValidityCheck();
818     } else if (attr->name() == stepAttr) {
819         m_inputType->stepAttributeChanged();
820         setNeedsValidityCheck();
821     } else if (attr->name() == patternAttr || attr->name() == precisionAttr)
822         setNeedsValidityCheck();
823     else if (attr->name() == disabledAttr) {
824         m_inputType->disabledAttributeChanged();
825         HTMLTextFormControlElement::parseMappedAttribute(attr);
826     } else if (attr->name() == readonlyAttr) {
827         m_inputType->readonlyAttributeChanged();
828         HTMLTextFormControlElement::parseMappedAttribute(attr);
829     }
830 #if ENABLE(DATALIST)
831     else if (attr->name() == listAttr)
832         m_hasNonEmptyList = !attr->isEmpty();
833         // FIXME: we need to tell this change to a renderer if the attribute affects the appearance.
834 #endif
835 #if ENABLE(INPUT_SPEECH)
836     else if (attr->name() == webkitspeechAttr) {
837         if (renderer()) {
838             // This renderer and its children have quite different layouts and styles depending on
839             // whether the speech button is visible or not. So we reset the whole thing and recreate
840             // to get the right styles and layout.
841             detach();
842             m_inputType->destroyShadowSubtree();
843             m_inputType->createShadowSubtree();
844             attach();
845         } else {
846             m_inputType->destroyShadowSubtree();
847             m_inputType->createShadowSubtree();
848         }
849         setFormControlValueMatchesRenderer(false);
850         setNeedsStyleRecalc();
851     } else if (attr->name() == onwebkitspeechchangeAttr)
852         setAttributeEventListener(eventNames().webkitspeechchangeEvent, createAttributeEventListener(this, attr));
853 #endif
854     else
855         HTMLTextFormControlElement::parseMappedAttribute(attr);
856     updateInnerTextValue();
857 }
858
859 void HTMLInputElement::finishParsingChildren()
860 {
861     m_parsingInProgress = false;
862     HTMLTextFormControlElement::finishParsingChildren();
863     if (!m_stateRestored) {
864         bool checked = hasAttribute(checkedAttr);
865         if (checked)
866             setChecked(checked);
867         m_reflectsCheckedAttribute = true;
868     }
869 }
870
871 bool HTMLInputElement::rendererIsNeeded(const NodeRenderingContext& context)
872 {
873     return m_inputType->rendererIsNeeded() && HTMLTextFormControlElement::rendererIsNeeded(context);
874 }
875
876 RenderObject* HTMLInputElement::createRenderer(RenderArena* arena, RenderStyle* style)
877 {
878     return m_inputType->createRenderer(arena, style);
879 }
880
881 void HTMLInputElement::attach()
882 {
883     suspendPostAttachCallbacks();
884
885     if (!m_hasType)
886         updateType();
887
888     HTMLTextFormControlElement::attach();
889
890     m_inputType->attach();
891
892     if (document()->focusedNode() == this)
893         document()->updateFocusAppearanceSoon(true /* restore selection */);
894
895     resumePostAttachCallbacks();
896 }
897
898 void HTMLInputElement::detach()
899 {
900     HTMLTextFormControlElement::detach();
901     setFormControlValueMatchesRenderer(false);
902     m_inputType->detach();
903 }
904
905 String HTMLInputElement::altText() const
906 {
907     // http://www.w3.org/TR/1998/REC-html40-19980424/appendix/notes.html#altgen
908     // also heavily discussed by Hixie on bugzilla
909     // note this is intentionally different to HTMLImageElement::altText()
910     String alt = fastGetAttribute(altAttr);
911     // fall back to title attribute
912     if (alt.isNull())
913         alt = getAttribute(titleAttr);
914     if (alt.isNull())
915         alt = getAttribute(valueAttr);
916     if (alt.isEmpty())
917         alt = inputElementAltText();
918     return alt;
919 }
920
921 bool HTMLInputElement::isSuccessfulSubmitButton() const
922 {
923     // HTML spec says that buttons must have names to be considered successful.
924     // However, other browsers do not impose this constraint. So we do not.
925     return !disabled() && m_inputType->canBeSuccessfulSubmitButton();
926 }
927
928 bool HTMLInputElement::isActivatedSubmit() const
929 {
930     return m_isActivatedSubmit;
931 }
932
933 void HTMLInputElement::setActivatedSubmit(bool flag)
934 {
935     m_isActivatedSubmit = flag;
936 }
937
938 bool HTMLInputElement::appendFormData(FormDataList& encoding, bool multipart)
939 {
940     return m_inputType->isFormDataAppendable() && m_inputType->appendFormData(encoding, multipart);
941 }
942
943 void HTMLInputElement::reset()
944 {
945     if (m_inputType->storesValueSeparateFromAttribute())
946         setValue(String());
947
948     setAutofilled(false);
949     setChecked(hasAttribute(checkedAttr));
950     m_reflectsCheckedAttribute = true;
951 }
952
953 bool HTMLInputElement::isTextField() const
954 {
955     return m_inputType->isTextField();
956 }
957
958 bool HTMLInputElement::isTextType() const
959 {
960     return m_inputType->isTextType();
961 }
962
963 void HTMLInputElement::setChecked(bool nowChecked, bool sendChangeEvent)
964 {
965     if (checked() == nowChecked)
966         return;
967
968     checkedRadioButtons().removeButton(this);
969
970     m_reflectsCheckedAttribute = false;
971     m_isChecked = nowChecked;
972     setNeedsStyleRecalc();
973     if (isRadioButton())
974         updateCheckedRadioButtons();
975     if (renderer() && renderer()->style()->hasAppearance())
976         renderer()->theme()->stateChanged(renderer(), CheckedState);
977     setNeedsValidityCheck();
978
979     // Ideally we'd do this from the render tree (matching
980     // RenderTextView), but it's not possible to do it at the moment
981     // because of the way the code is structured.
982     if (renderer() && AXObjectCache::accessibilityEnabled())
983         renderer()->document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXCheckedStateChanged, true);
984
985     // Only send a change event for items in the document (avoid firing during
986     // parsing) and don't send a change event for a radio button that's getting
987     // unchecked to match other browsers. DOM is not a useful standard for this
988     // because it says only to fire change events at "lose focus" time, which is
989     // definitely wrong in practice for these types of elements.
990     if (sendChangeEvent && inDocument() && m_inputType->shouldSendChangeEventAfterCheckedChanged()) {
991         setTextAsOfLastFormControlChangeEvent(String());
992         dispatchFormControlChangeEvent();
993     }
994 }
995
996 void HTMLInputElement::setIndeterminate(bool newValue)
997 {
998     if (!m_inputType->isCheckable() || indeterminate() == newValue)
999         return;
1000
1001     m_isIndeterminate = newValue;
1002
1003     setNeedsStyleRecalc();
1004
1005     if (renderer() && renderer()->style()->hasAppearance())
1006         renderer()->theme()->stateChanged(renderer(), CheckedState);
1007 }
1008
1009 int HTMLInputElement::size() const
1010 {
1011     return m_size;
1012 }
1013
1014 bool HTMLInputElement::sizeShouldIncludeDecoration(int& preferredSize) const
1015 {
1016     return m_inputType->sizeShouldIncludeDecoration(defaultSize, preferredSize);
1017 }
1018
1019 void HTMLInputElement::copyNonAttributeProperties(const Element* source)
1020 {
1021     const HTMLInputElement* sourceElement = static_cast<const HTMLInputElement*>(source);
1022
1023     m_valueIfDirty = sourceElement->m_valueIfDirty;
1024     m_wasModifiedByUser = false;
1025     setChecked(sourceElement->m_isChecked);
1026     m_reflectsCheckedAttribute = sourceElement->m_reflectsCheckedAttribute;
1027     m_isIndeterminate = sourceElement->m_isIndeterminate;
1028
1029     HTMLTextFormControlElement::copyNonAttributeProperties(source);
1030 }
1031
1032 String HTMLInputElement::value() const
1033 {
1034     String value;
1035     if (m_inputType->getTypeSpecificValue(value))
1036         return value;
1037
1038     value = m_valueIfDirty;
1039     if (!value.isNull())
1040         return value;
1041
1042     value = sanitizeValue(fastGetAttribute(valueAttr));
1043     if (!value.isNull())
1044         return value;
1045
1046     return m_inputType->fallbackValue();
1047 }
1048
1049 String HTMLInputElement::valueWithDefault() const
1050 {
1051     String value = this->value();
1052     if (!value.isNull())
1053         return value;
1054
1055     return m_inputType->defaultValue();
1056 }
1057
1058 void HTMLInputElement::setValueForUser(const String& value)
1059 {
1060     // Call setValue and make it send a change event.
1061     setValue(value, true);
1062 }
1063
1064 const String& HTMLInputElement::suggestedValue() const
1065 {
1066     return m_suggestedValue;
1067 }
1068
1069 void HTMLInputElement::setSuggestedValue(const String& value)
1070 {
1071     if (!m_inputType->canSetSuggestedValue())
1072         return;
1073     setFormControlValueMatchesRenderer(false);
1074     m_suggestedValue = sanitizeValue(value);
1075     updatePlaceholderVisibility(false);
1076     setNeedsStyleRecalc();
1077     updateInnerTextValue();
1078 }
1079
1080 void HTMLInputElement::setValue(const String& value, bool sendChangeEvent)
1081 {
1082     if (!m_inputType->canSetValue(value))
1083         return;
1084
1085     String sanitizedValue = sanitizeValue(value);
1086     bool valueChanged = sanitizedValue != this->value();
1087
1088     setLastChangeWasNotUserEdit();
1089     setFormControlValueMatchesRenderer(false);
1090     if (m_inputType->storesValueSeparateFromAttribute()) {
1091         if (files())
1092             files()->clear();
1093         else {
1094             m_valueIfDirty = sanitizedValue;
1095             m_wasModifiedByUser = sendChangeEvent;
1096             if (isTextField())
1097                 updatePlaceholderVisibility(false);
1098         }
1099         setNeedsStyleRecalc();
1100     } else
1101         setAttribute(valueAttr, sanitizedValue);
1102
1103     setNeedsValidityCheck();
1104
1105     if (valueChanged)
1106         updateInnerTextValue();
1107
1108     if (isTextField()) {
1109         unsigned max = visibleValue().length();
1110         if (document()->focusedNode() == this)
1111             setSelectionRange(max, max);
1112         else
1113             cacheSelection(max, max, SelectionHasNoDirection);
1114         m_suggestedValue = String();
1115     }
1116
1117     if (!valueChanged)
1118         return;
1119     
1120     m_inputType->valueChanged();
1121
1122     if (sendChangeEvent) {
1123         // If the user is still editing this field, dispatch an input event rather than a change event.
1124         // The change event will be dispatched when editing finishes.
1125         if (isTextField() && focused())
1126             dispatchFormControlInputEvent();
1127         else
1128             dispatchFormControlChangeEvent();
1129     }
1130
1131     if (isText() && (!focused() || !sendChangeEvent))
1132         setTextAsOfLastFormControlChangeEvent(value);
1133
1134     notifyFormStateChanged();
1135 }
1136
1137 double HTMLInputElement::valueAsDate() const
1138 {
1139     return m_inputType->valueAsDate();
1140 }
1141
1142 void HTMLInputElement::setValueAsDate(double value, ExceptionCode& ec)
1143 {
1144     m_inputType->setValueAsDate(value, ec);
1145 }
1146
1147 double HTMLInputElement::valueAsNumber() const
1148 {
1149     return m_inputType->valueAsNumber();
1150 }
1151
1152 void HTMLInputElement::setValueAsNumber(double newValue, ExceptionCode& ec)
1153 {
1154     if (!isfinite(newValue)) {
1155         ec = NOT_SUPPORTED_ERR;
1156         return;
1157     }
1158     m_inputType->setValueAsNumber(newValue, ec);
1159 }
1160
1161 String HTMLInputElement::placeholder() const
1162 {
1163     return fastGetAttribute(placeholderAttr).string();
1164 }
1165
1166 void HTMLInputElement::setPlaceholder(const String& value)
1167 {
1168     setAttribute(placeholderAttr, value);
1169 }
1170
1171 bool HTMLInputElement::searchEventsShouldBeDispatched() const
1172 {
1173     return hasAttribute(incrementalAttr);
1174 }
1175
1176 void HTMLInputElement::setValueFromRenderer(const String& value)
1177 {
1178     // File upload controls will never use this.
1179     ASSERT(!isFileUpload());
1180
1181     m_suggestedValue = String();
1182
1183     // Renderer and our event handler are responsible for sanitizing values.
1184     ASSERT(value == sanitizeValue(value) || sanitizeValue(value).isEmpty());
1185
1186     // Workaround for bug where trailing \n is included in the result of textContent.
1187     // The assert macro above may also be simplified to: value == constrainValue(value)
1188     // http://bugs.webkit.org/show_bug.cgi?id=9661
1189     m_valueIfDirty = value == "\n" ? String("") : value;
1190
1191     setFormControlValueMatchesRenderer(true);
1192     m_wasModifiedByUser = true;
1193
1194     // Input event is fired by the Node::defaultEventHandler for editable controls.
1195     if (!isTextField())
1196         dispatchInputEvent();
1197     notifyFormStateChanged();
1198
1199     updatePlaceholderVisibility(false);
1200     setNeedsValidityCheck();
1201
1202     // Clear autofill flag (and yellow background) on user edit.
1203     setAutofilled(false);
1204 }
1205
1206 void* HTMLInputElement::preDispatchEventHandler(Event* event)
1207 {
1208     if (event->type() == eventNames().textInputEvent && m_inputType->shouldSubmitImplicitly(event)) {
1209         event->stopPropagation();
1210         return 0;
1211     }
1212     if (event->type() != eventNames().clickEvent)
1213         return 0;
1214     if (!event->isMouseEvent() || static_cast<MouseEvent*>(event)->button() != LeftButton)
1215         return 0;
1216     // FIXME: Check whether there are any cases where this actually ends up leaking.
1217     return m_inputType->willDispatchClick().leakPtr();
1218 }
1219
1220 void HTMLInputElement::postDispatchEventHandler(Event* event, void* dataFromPreDispatch)
1221 {
1222     OwnPtr<ClickHandlingState> state = adoptPtr(static_cast<ClickHandlingState*>(dataFromPreDispatch));
1223     if (!state)
1224         return;
1225     m_inputType->didDispatchClick(event, *state);
1226 }
1227
1228 void HTMLInputElement::defaultEventHandler(Event* evt)
1229 {
1230     if (evt->isMouseEvent() && evt->type() == eventNames().clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
1231         m_inputType->handleClickEvent(static_cast<MouseEvent*>(evt));
1232         if (evt->defaultHandled())
1233             return;
1234     }
1235
1236     if (evt->isKeyboardEvent() && evt->type() == eventNames().keydownEvent) {
1237         m_inputType->handleKeydownEvent(static_cast<KeyboardEvent*>(evt));
1238         if (evt->defaultHandled())
1239             return;
1240     }
1241
1242     // Call the base event handler before any of our own event handling for almost all events in text fields.
1243     // Makes editing keyboard handling take precedence over the keydown and keypress handling in this function.
1244     bool callBaseClassEarly = isTextField() && (evt->type() == eventNames().keydownEvent || evt->type() == eventNames().keypressEvent);
1245     if (callBaseClassEarly) {
1246         HTMLTextFormControlElement::defaultEventHandler(evt);
1247         if (evt->defaultHandled())
1248             return;
1249     }
1250
1251     // DOMActivate events cause the input to be "activated" - in the case of image and submit inputs, this means
1252     // actually submitting the form. For reset inputs, the form is reset. These events are sent when the user clicks
1253     // on the element, or presses enter while it is the active element. JavaScript code wishing to activate the element
1254     // must dispatch a DOMActivate event - a click event will not do the job.
1255     if (evt->type() == eventNames().DOMActivateEvent) {
1256         m_inputType->handleDOMActivateEvent(evt);
1257         if (evt->defaultHandled())
1258             return;
1259     }
1260
1261     // Use key press event here since sending simulated mouse events
1262     // on key down blocks the proper sending of the key press event.
1263     if (evt->isKeyboardEvent() && evt->type() == eventNames().keypressEvent) {
1264         m_inputType->handleKeypressEvent(static_cast<KeyboardEvent*>(evt));
1265         if (evt->defaultHandled())
1266             return;
1267     }
1268
1269     if (evt->isKeyboardEvent() && evt->type() == eventNames().keyupEvent) {
1270         m_inputType->handleKeyupEvent(static_cast<KeyboardEvent*>(evt));
1271         if (evt->defaultHandled())
1272             return;
1273     }
1274
1275     if (m_inputType->shouldSubmitImplicitly(evt)) {
1276         if (isSearchField()) {
1277             addSearchResult();
1278             onSearch();
1279         }
1280         // Form submission finishes editing, just as loss of focus does.
1281         // If there was a change, send the event now.
1282         if (wasChangedSinceLastFormControlChangeEvent())
1283             dispatchFormControlChangeEvent();
1284
1285         RefPtr<HTMLFormElement> formForSubmission = m_inputType->formForSubmission();
1286         // Form may never have been present, or may have been destroyed by code responding to the change event.
1287         if (formForSubmission)
1288             formForSubmission->submitImplicitly(evt, canTriggerImplicitSubmission());
1289
1290         evt->setDefaultHandled();
1291         return;
1292     }
1293
1294     if (evt->isBeforeTextInsertedEvent())
1295         m_inputType->handleBeforeTextInsertedEvent(static_cast<BeforeTextInsertedEvent*>(evt));
1296
1297     if (evt->isWheelEvent()) {
1298         m_inputType->handleWheelEvent(static_cast<WheelEvent*>(evt));
1299         if (evt->defaultHandled())
1300             return;
1301     }
1302
1303     if (evt->isMouseEvent() && evt->type() == eventNames().mousedownEvent) {
1304         m_inputType->handleMouseDownEvent(static_cast<MouseEvent*>(evt));
1305         if (evt->defaultHandled())
1306             return;
1307     }
1308
1309     m_inputType->forwardEvent(evt);
1310
1311     if (!callBaseClassEarly && !evt->defaultHandled())
1312         HTMLTextFormControlElement::defaultEventHandler(evt);
1313 }
1314
1315 bool HTMLInputElement::isURLAttribute(Attribute *attr) const
1316 {
1317     return (attr->name() == srcAttr || attr->name() == formactionAttr);
1318 }
1319
1320 String HTMLInputElement::defaultValue() const
1321 {
1322     return fastGetAttribute(valueAttr);
1323 }
1324
1325 void HTMLInputElement::setDefaultValue(const String &value)
1326 {
1327     setAttribute(valueAttr, value);
1328 }
1329
1330 void HTMLInputElement::setDefaultName(const AtomicString& name)
1331 {
1332     m_name = name;
1333 }
1334
1335 String HTMLInputElement::accept() const
1336 {
1337     return fastGetAttribute(acceptAttr);
1338 }
1339
1340 String HTMLInputElement::alt() const
1341 {
1342     return fastGetAttribute(altAttr);
1343 }
1344
1345 int HTMLInputElement::maxLength() const
1346 {
1347     return m_maxLength;
1348 }
1349
1350 void HTMLInputElement::setMaxLength(int maxLength, ExceptionCode& ec)
1351 {
1352     if (maxLength < 0)
1353         ec = INDEX_SIZE_ERR;
1354     else
1355         setAttribute(maxlengthAttr, String::number(maxLength));
1356 }
1357
1358 bool HTMLInputElement::multiple() const
1359 {
1360     return fastHasAttribute(multipleAttr);
1361 }
1362
1363 void HTMLInputElement::setSize(unsigned size)
1364 {
1365     setAttribute(sizeAttr, String::number(size));
1366 }
1367
1368 KURL HTMLInputElement::src() const
1369 {
1370     return document()->completeURL(fastGetAttribute(srcAttr));
1371 }
1372
1373 void HTMLInputElement::setAutofilled(bool autofilled)
1374 {
1375     if (autofilled == m_isAutofilled)
1376         return;
1377
1378     m_isAutofilled = autofilled;
1379     setNeedsStyleRecalc();
1380 }
1381
1382 FileList* HTMLInputElement::files()
1383 {
1384     return m_inputType->files();
1385 }
1386
1387 void HTMLInputElement::receiveDroppedFiles(const Vector<String>& filenames)
1388 {
1389     m_inputType->receiveDroppedFiles(filenames);
1390 }
1391
1392 Icon* HTMLInputElement::icon() const
1393 {
1394     return m_inputType->icon();
1395 }
1396
1397 String HTMLInputElement::visibleValue() const
1398 {
1399     return m_inputType->visibleValue();
1400 }
1401
1402 String HTMLInputElement::convertFromVisibleValue(const String& visibleValue) const
1403 {
1404     return m_inputType->convertFromVisibleValue(visibleValue);
1405 }
1406
1407 bool HTMLInputElement::isAcceptableValue(const String& proposedValue) const
1408 {
1409     return m_inputType->isAcceptableValue(proposedValue);
1410 }
1411
1412 String HTMLInputElement::sanitizeValue(const String& proposedValue) const
1413 {
1414     return m_inputType->sanitizeValue(proposedValue);
1415 }
1416
1417 bool HTMLInputElement::hasUnacceptableValue() const
1418 {
1419     return m_inputType->hasUnacceptableValue();
1420 }
1421
1422 bool HTMLInputElement::isInRange() const
1423 {
1424     return m_inputType->supportsRangeLimitation() && !rangeUnderflow(value()) && !rangeOverflow(value());
1425 }
1426
1427 bool HTMLInputElement::isOutOfRange() const
1428 {
1429     return m_inputType->supportsRangeLimitation() && (rangeUnderflow(value()) || rangeOverflow(value()));
1430 }
1431
1432 bool HTMLInputElement::needsActivationCallback()
1433 {
1434     return m_autocomplete == Off || m_inputType->shouldResetOnDocumentActivation();
1435 }
1436
1437 void HTMLInputElement::registerForActivationCallbackIfNeeded()
1438 {
1439     if (needsActivationCallback())
1440         document()->registerForDocumentActivationCallbacks(this);
1441 }
1442
1443 void HTMLInputElement::unregisterForActivationCallbackIfNeeded()
1444 {
1445     if (!needsActivationCallback())
1446         document()->unregisterForDocumentActivationCallbacks(this);
1447 }
1448
1449 bool HTMLInputElement::isRequiredFormControl() const
1450 {
1451     return m_inputType->supportsRequired() && required();
1452 }
1453
1454 void HTMLInputElement::addSearchResult()
1455 {
1456     ASSERT(isSearchField());
1457     if (renderer())
1458         toRenderTextControlSingleLine(renderer())->addSearchResult();
1459 }
1460
1461 void HTMLInputElement::onSearch()
1462 {
1463     ASSERT(isSearchField());
1464     if (m_inputType)
1465         static_cast<SearchInputType*>(m_inputType.get())->stopSearchEventTimer();
1466     dispatchEvent(Event::create(eventNames().searchEvent, true, false));
1467 }
1468
1469 void HTMLInputElement::documentDidBecomeActive()
1470 {
1471     ASSERT(needsActivationCallback());
1472     reset();
1473 }
1474
1475 void HTMLInputElement::willMoveToNewOwnerDocument()
1476 {
1477     m_inputType->willMoveToNewOwnerDocument();
1478
1479     // Always unregister for cache callbacks when leaving a document, even if we would otherwise like to be registered
1480     if (needsActivationCallback())
1481         document()->unregisterForDocumentActivationCallbacks(this);
1482
1483     document()->checkedRadioButtons().removeButton(this);
1484
1485     HTMLTextFormControlElement::willMoveToNewOwnerDocument();
1486 }
1487
1488 void HTMLInputElement::didMoveToNewOwnerDocument()
1489 {
1490     registerForActivationCallbackIfNeeded();
1491
1492     HTMLTextFormControlElement::didMoveToNewOwnerDocument();
1493 }
1494
1495 void HTMLInputElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
1496 {
1497     HTMLTextFormControlElement::addSubresourceAttributeURLs(urls);
1498
1499     addSubresourceURL(urls, src());
1500 }
1501
1502 bool HTMLInputElement::recalcWillValidate() const
1503 {
1504     return m_inputType->supportsValidation() && HTMLTextFormControlElement::recalcWillValidate();
1505 }
1506
1507 #if ENABLE(INPUT_COLOR)
1508 bool HTMLInputElement::connectToColorChooser()
1509 {
1510     if (!m_inputType->isColorControl())
1511         return false;
1512     ColorChooser::chooser()->connectClient(static_cast<ColorInputType*>(m_inputType.get()));
1513     return true;
1514 }
1515 #endif
1516     
1517 #if ENABLE(DATALIST)
1518
1519 HTMLElement* HTMLInputElement::list() const
1520 {
1521     return dataList();
1522 }
1523
1524 HTMLDataListElement* HTMLInputElement::dataList() const
1525 {
1526     if (!m_hasNonEmptyList)
1527         return 0;
1528
1529     if (!m_inputType->shouldRespectListAttribute())
1530         return 0;
1531
1532     Element* element = treeScope()->getElementById(fastGetAttribute(listAttr));
1533     if (!element)
1534         return 0;
1535     if (!element->hasTagName(datalistTag))
1536         return 0;
1537
1538     return static_cast<HTMLDataListElement*>(element);
1539 }
1540
1541 HTMLOptionElement* HTMLInputElement::selectedOption() const
1542 {
1543     String value = this->value();
1544
1545     // The empty string never matches to a datalist option because it
1546     // doesn't represent a suggestion according to the standard.
1547     if (value.isEmpty())
1548         return 0;
1549
1550     HTMLDataListElement* sourceElement = dataList();
1551     if (!sourceElement)
1552         return 0;
1553     RefPtr<HTMLCollection> options = sourceElement->options();
1554     if (!options)
1555         return 0;
1556     unsigned length = options->length();
1557     for (unsigned i = 0; i < length; ++i) {
1558         HTMLOptionElement* option = static_cast<HTMLOptionElement*>(options->item(i));
1559         if (!option->disabled() && value == option->value())
1560             return option;
1561     }
1562     return 0;
1563 }
1564
1565 #endif // ENABLE(DATALIST)
1566
1567 bool HTMLInputElement::isSteppable() const
1568 {
1569     return m_inputType->isSteppable();
1570 }
1571
1572 void HTMLInputElement::stepUpFromRenderer(int n)
1573 {
1574     // The differences from stepUp()/stepDown():
1575     //
1576     // Difference 1: the current value
1577     // If the current value is not a number, including empty, the current value is assumed as 0.
1578     //   * If 0 is in-range, and matches to step value
1579     //     - The value should be the +step if n > 0
1580     //     - The value should be the -step if n < 0
1581     //     If -step or +step is out of range, new value should be 0.
1582     //   * If 0 is smaller than the minimum value
1583     //     - The value should be the minimum value for any n
1584     //   * If 0 is larger than the maximum value
1585     //     - The value should be the maximum value for any n
1586     //   * If 0 is in-range, but not matched to step value
1587     //     - The value should be the larger matched value nearest to 0 if n > 0
1588     //       e.g. <input type=number min=-100 step=3> -> 2
1589     //     - The value should be the smaler matched value nearest to 0 if n < 0
1590     //       e.g. <input type=number min=-100 step=3> -> -1
1591     //   As for date/datetime-local/month/time/week types, the current value is assumed as "the current local date/time".
1592     //   As for datetime type, the current value is assumed as "the current date/time in UTC".
1593     // If the current value is smaller than the minimum value:
1594     //  - The value should be the minimum value if n > 0
1595     //  - Nothing should happen if n < 0
1596     // If the current value is larger than the maximum value:
1597     //  - The value should be the maximum value if n < 0
1598     //  - Nothing should happen if n > 0
1599     //
1600     // Difference 2: clamping steps
1601     // If the current value is not matched to step value:
1602     // - The value should be the larger matched value nearest to 0 if n > 0
1603     //   e.g. <input type=number value=3 min=-100 step=3> -> 5
1604     // - The value should be the smaler matched value nearest to 0 if n < 0
1605     //   e.g. <input type=number value=3 min=-100 step=3> -> 2
1606     //
1607     // n is assumed as -n if step < 0.
1608
1609     ASSERT(isSteppable());
1610     if (!isSteppable())
1611         return;
1612     ASSERT(n);
1613     if (!n)
1614         return;
1615
1616     unsigned stepDecimalPlaces, baseDecimalPlaces;
1617     double step, base;
1618     // FIXME: Not any changes after stepping, even if it is an invalid value, may be better.
1619     // (e.g. Stepping-up for <input type="number" value="foo" step="any" /> => "foo")
1620     if (!getAllowedValueStepWithDecimalPlaces(AnyIsDefaultStep, &step, &stepDecimalPlaces))
1621       return;
1622     base = m_inputType->stepBaseWithDecimalPlaces(&baseDecimalPlaces);
1623     baseDecimalPlaces = min(baseDecimalPlaces, 16u);
1624
1625     int sign;
1626     if (step > 0)
1627         sign = n;
1628     else if (step < 0)
1629         sign = -n;
1630     else
1631         sign = 0;
1632
1633     const double nan = numeric_limits<double>::quiet_NaN();
1634     String currentStringValue = value();
1635     double current = m_inputType->parseToDouble(currentStringValue, nan);
1636     if (!isfinite(current)) {
1637         ExceptionCode ec;
1638         current = m_inputType->defaultValueForStepUp();
1639         double nextDiff = step * n;
1640         if (current < m_inputType->minimum() - nextDiff)
1641             current = m_inputType->minimum() - nextDiff;
1642         if (current > m_inputType->maximum() - nextDiff)
1643             current = m_inputType->maximum() - nextDiff;
1644         setValueAsNumber(current, ec);
1645     }
1646     if ((sign > 0 && current < m_inputType->minimum()) || (sign < 0 && current > m_inputType->maximum()))
1647         setValue(m_inputType->serialize(sign > 0 ? m_inputType->minimum() : m_inputType->maximum()));
1648     else {
1649         ExceptionCode ec;
1650         if (stepMismatch(value())) {
1651             ASSERT(step);
1652             double newValue;
1653             double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, baseDecimalPlaces)));
1654
1655             if (sign < 0)
1656                 newValue = round((base + floor((current - base) / step) * step) * scale) / scale;
1657             else if (sign > 0)
1658                 newValue = round((base + ceil((current - base) / step) * step) * scale) / scale;
1659             else
1660                 newValue = current;
1661
1662             if (newValue < m_inputType->minimum())
1663                 newValue = m_inputType->minimum();
1664             if (newValue > m_inputType->maximum())
1665                 newValue = m_inputType->maximum();
1666
1667             setValueAsNumber(newValue, ec);
1668             current = newValue;
1669             if (n > 1)
1670                 applyStep(n - 1, AnyIsDefaultStep, ec);
1671             else if (n < -1)
1672                 applyStep(n + 1, AnyIsDefaultStep, ec);
1673         } else
1674             applyStep(n, AnyIsDefaultStep, ec);
1675     }
1676
1677     if (currentStringValue != value()) {
1678         if (m_inputType->isRangeControl())
1679             dispatchFormControlChangeEvent();
1680         else
1681             dispatchFormControlInputEvent();
1682     }
1683 }
1684
1685 #if ENABLE(WCSS)
1686
1687 static inline const AtomicString& formatCodes()
1688 {
1689     DEFINE_STATIC_LOCAL(AtomicString, codes, ("AaNnXxMm"));
1690     return codes;
1691 }
1692
1693 static unsigned cursorPositionToMaskIndex(const String& inputFormatMask, unsigned cursorPosition)
1694 {
1695     UChar mask;
1696     int index = -1;
1697     do {
1698         mask = inputFormatMask[++index];
1699         if (mask == '\\')
1700             ++index;
1701         else if (mask == '*' || (isASCIIDigit(mask) && mask != '0')) {
1702             index = inputFormatMask.length() - 1;
1703             break;
1704         }
1705     } while (cursorPosition--);
1706
1707     return index;
1708 }
1709
1710 bool HTMLInputElement::isConformToInputMask(const String& inputChars) const
1711 {
1712     for (unsigned i = 0; i < inputChars.length(); ++i) {
1713         if (!isConformToInputMask(inputChars[i], i))
1714             return false;
1715     }
1716     return true;
1717 }
1718
1719 bool HTMLInputElement::isConformToInputMask(UChar inChar, unsigned cursorPosition) const
1720 {
1721     if (m_inputFormatMask.isEmpty() || m_inputFormatMask == "*M" || m_inputFormatMask == "*m")
1722         return true;
1723
1724     if (cursorPosition >= m_maxInputCharsAllowed())
1725         return false;
1726
1727     unsigned maskIndex = cursorPositionToMaskIndex(m_inputFormatMask, cursorPosition);
1728     bool ok = true;
1729     UChar mask = m_inputFormatMask[maskIndex];
1730     // Match the inputed character with input mask
1731     switch (mask) {
1732     case 'A':
1733         ok = !isASCIIDigit(inChar) && !isASCIILower(inChar) && isASCIIPrintable(inChar);
1734         break;
1735     case 'a':
1736         ok = !isASCIIDigit(inChar) && !isASCIIUpper(inChar) && isASCIIPrintable(inChar);
1737         break;
1738     case 'N':
1739         ok = isASCIIDigit(inChar);
1740         break;
1741     case 'n':
1742         ok = !isASCIIAlpha(inChar) && isASCIIPrintable(inChar);
1743         break;
1744     case 'X':
1745         ok = !isASCIILower(inChar) && isASCIIPrintable(inChar);
1746         break;
1747     case 'x':
1748         ok = !isASCIIUpper(inChar) && isASCIIPrintable(inChar);
1749         break;
1750     case 'M':
1751     case 'm':
1752         ok = isASCIIPrintable(inChar);
1753         break;
1754     default:
1755         ok = (mask == inChar);
1756         break;
1757     }
1758
1759     return ok;
1760 }
1761
1762 String HTMLInputElement::validateInputMask(String& inputMask)
1763 {
1764     inputMask.replace("\\\\", "\\");
1765
1766     bool isValid = true;
1767     bool hasWildcard = false;
1768     unsigned escapeCharCount = 0;
1769     unsigned maskLength = inputMask.length();
1770     UChar formatCode;
1771     for (unsigned i = 0; i < maskLength; ++i) {
1772         formatCode = inputMask[i];
1773         if (formatCodes().find(formatCode) == -1) {
1774             if (formatCode == '*' || (isASCIIDigit(formatCode) && formatCode != '0')) {
1775                 // Validate codes which ends with '*f' or 'nf'
1776                 formatCode = inputMask[++i];
1777                 if ((i + 1 != maskLength) || formatCodes().find(formatCode) == -1) {
1778                     isValid = false;
1779                     break;
1780                 }
1781                 hasWildcard = true;
1782             } else if (formatCode == '\\') {
1783                 // skip over the next mask character
1784                 ++i;
1785                 ++escapeCharCount;
1786             } else {
1787                 isValid = false;
1788                 break;
1789             }
1790         }
1791     }
1792
1793     if (!isValid)
1794         return String();
1795     // calculate the number of characters allowed to be entered by input mask
1796     unsigned allowedLength = maskLength;
1797     if (escapeCharCount)
1798         allowedLength -= escapeCharCount;
1799
1800     if (hasWildcard) {
1801         formatCode = inputMask[maskLength - 2];
1802         if (formatCode == '*')
1803             allowedLength = m_maxInputCharsAllowed;
1804         else {
1805             unsigned leftLen = String(&formatCode).toInt();
1806             allowedLength = leftLen + allowedLength - 2;
1807         }
1808     }
1809
1810     if (allowedLength < m_maxInputCharsAllowed)
1811         m_maxInputCharsAllowed = allowedLength;
1812
1813     return inputMask;
1814 }
1815
1816 void HTMLInputElement::setWapInputFormat(String& mask)
1817 {
1818     String validateMask = validateInputMask(mask);
1819     if (!validateMask.isEmpty())
1820         m_inputFormatMask = validateMask;
1821 }
1822
1823 #endif
1824
1825 #if ENABLE(INPUT_SPEECH)
1826
1827 bool HTMLInputElement::isSpeechEnabled() const
1828 {
1829     // FIXME: Add support for RANGE, EMAIL, URL, COLOR and DATE/TIME input types.
1830     return m_inputType->shouldRespectSpeechAttribute() && RuntimeEnabledFeatures::speechInputEnabled() && hasAttribute(webkitspeechAttr);
1831 }
1832
1833 #endif
1834
1835 bool HTMLInputElement::isTextButton() const
1836 {
1837     return m_inputType->isTextButton();
1838 }
1839
1840 bool HTMLInputElement::isRadioButton() const
1841 {
1842     return m_inputType->isRadioButton();
1843 }
1844
1845 bool HTMLInputElement::isSearchField() const
1846 {
1847     return m_inputType->isSearchField();
1848 }
1849
1850 bool HTMLInputElement::isInputTypeHidden() const
1851 {
1852     return m_inputType->isHiddenType();
1853 }
1854
1855 bool HTMLInputElement::isPasswordField() const
1856 {
1857     return m_inputType->isPasswordField();
1858 }
1859
1860 bool HTMLInputElement::isCheckbox() const
1861 {
1862     return m_inputType->isCheckbox();
1863 }
1864
1865 bool HTMLInputElement::isRangeControl() const
1866 {
1867     return m_inputType->isRangeControl();
1868 }
1869
1870 bool HTMLInputElement::isText() const
1871 {
1872     return m_inputType->isTextType();
1873 }
1874
1875 bool HTMLInputElement::isEmailField() const
1876 {
1877     return m_inputType->isEmailField();
1878 }
1879
1880 bool HTMLInputElement::isFileUpload() const
1881 {
1882     return m_inputType->isFileUpload();
1883 }
1884
1885 bool HTMLInputElement::isImageButton() const
1886 {
1887     return m_inputType->isImageButton();
1888 }
1889
1890 bool HTMLInputElement::isNumberField() const
1891 {
1892     return m_inputType->isNumberField();
1893 }
1894
1895 bool HTMLInputElement::isSubmitButton() const
1896 {
1897     return m_inputType->isSubmitButton();
1898 }
1899
1900 bool HTMLInputElement::isTelephoneField() const
1901 {
1902     return m_inputType->isTelephoneField();
1903 }
1904
1905 bool HTMLInputElement::isURLField() const
1906 {
1907     return m_inputType->isURLField();
1908 }
1909
1910 bool HTMLInputElement::isEnumeratable() const
1911 {
1912     return m_inputType->isEnumeratable();
1913 }
1914
1915 bool HTMLInputElement::shouldAppearChecked() const
1916 {
1917     return checked() && m_inputType->isCheckable();
1918 }
1919
1920 bool HTMLInputElement::supportsPlaceholder() const
1921 {
1922     return m_inputType->supportsPlaceholder();
1923 }
1924
1925 void HTMLInputElement::updatePlaceholderText()
1926 {
1927     return m_inputType->updatePlaceholderText();
1928 }
1929
1930 CheckedRadioButtons& HTMLInputElement::checkedRadioButtons() const
1931 {
1932     if (HTMLFormElement* formElement = form())
1933         return formElement->checkedRadioButtons();
1934     return document()->checkedRadioButtons();
1935 }
1936
1937 void HTMLInputElement::parseMaxLengthAttribute(Attribute* attribute)
1938 {
1939     int maxLength;
1940     if (!parseHTMLInteger(attribute->value(), maxLength))
1941         maxLength = maximumLength;
1942     if (maxLength < 0 || maxLength > maximumLength)
1943         maxLength = maximumLength;
1944     int oldMaxLength = m_maxLength;
1945     m_maxLength = maxLength;
1946     if (oldMaxLength != maxLength)
1947         updateValueIfNeeded();
1948     setNeedsStyleRecalc();
1949     setNeedsValidityCheck();
1950 }
1951
1952 void HTMLInputElement::updateValueIfNeeded()
1953 {
1954     String newValue = sanitizeValue(m_valueIfDirty);
1955     if (newValue != m_valueIfDirty)
1956         setValue(newValue);
1957 }
1958
1959 } // namespace