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