573047f2a7c1733f3ac726c55449d747aff92ce5
[WebKit-https.git] / Source / WebCore / html / HTMLSelectElement.cpp
1 /*
2  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
3  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
4  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
7  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
8  * Copyright (C) 2010 Google Inc. All rights reserved.
9  * Copyright (C) 2009 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 "HTMLSelectElement.h"
30
31 #include "AXObjectCache.h"
32 #include "Chrome.h"
33 #include "ChromeClient.h"
34 #include "ElementTraversal.h"
35 #include "EventHandler.h"
36 #include "EventNames.h"
37 #include "ExceptionCodePlaceholder.h"
38 #include "FormController.h"
39 #include "FormDataList.h"
40 #include "Frame.h"
41 #include "GenericCachedHTMLCollection.h"
42 #include "HTMLFormElement.h"
43 #include "HTMLNames.h"
44 #include "HTMLOptGroupElement.h"
45 #include "HTMLOptionElement.h"
46 #include "HTMLOptionsCollection.h"
47 #include "KeyboardEvent.h"
48 #include "LocalizedStrings.h"
49 #include "MouseEvent.h"
50 #include "NodeRareData.h"
51 #include "Page.h"
52 #include "PlatformMouseEvent.h"
53 #include "RenderListBox.h"
54 #include "RenderMenuList.h"
55 #include "RenderTheme.h"
56 #include "Settings.h"
57 #include "SpatialNavigation.h"
58
59 using namespace WTF::Unicode;
60
61 namespace WebCore {
62
63 using namespace HTMLNames;
64
65 // Upper limit agreed upon with representatives of Opera and Mozilla.
66 static const unsigned maxSelectItems = 10000;
67
68 HTMLSelectElement::HTMLSelectElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
69     : HTMLFormControlElementWithState(tagName, document, form)
70     , m_typeAhead(this)
71     , m_size(0)
72     , m_lastOnChangeIndex(-1)
73     , m_activeSelectionAnchorIndex(-1)
74     , m_activeSelectionEndIndex(-1)
75     , m_isProcessingUserDrivenChange(false)
76     , m_multiple(false)
77     , m_activeSelectionState(false)
78     , m_allowsNonContiguousSelection(false)
79     , m_shouldRecalcListItems(false)
80 {
81     ASSERT(hasTagName(selectTag));
82 }
83
84 Ref<HTMLSelectElement> HTMLSelectElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
85 {
86     ASSERT(tagName.matches(selectTag));
87     return adoptRef(*new HTMLSelectElement(tagName, document, form));
88 }
89
90 void HTMLSelectElement::didRecalcStyle(Style::Change styleChange)
91 {
92     // Even though the options didn't necessarily change, we will call setOptionsChangedOnRenderer for its side effect
93     // of recomputing the width of the element. We need to do that if the style change included a change in zoom level.
94     setOptionsChangedOnRenderer();
95     HTMLFormControlElement::didRecalcStyle(styleChange);
96 }
97
98 const AtomicString& HTMLSelectElement::formControlType() const
99 {
100     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, selectMultiple, ("select-multiple", AtomicString::ConstructFromLiteral));
101     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, selectOne, ("select-one", AtomicString::ConstructFromLiteral));
102     return m_multiple ? selectMultiple : selectOne;
103 }
104
105 void HTMLSelectElement::deselectItems(HTMLOptionElement* excludeElement)
106 {
107     deselectItemsWithoutValidation(excludeElement);
108     updateValidity();
109 }
110
111 void HTMLSelectElement::optionSelectedByUser(int optionIndex, bool fireOnChangeNow, bool allowMultipleSelection)
112 {
113     // User interaction such as mousedown events can cause list box select elements to send change events.
114     // This produces that same behavior for changes triggered by other code running on behalf of the user.
115     if (!usesMenuList()) {
116         updateSelectedState(optionToListIndex(optionIndex), allowMultipleSelection, false);
117         updateValidity();
118         if (fireOnChangeNow)
119             listBoxOnChange();
120         return;
121     }
122
123     // Bail out if this index is already the selected one, to avoid running unnecessary JavaScript that can mess up
124     // autofill when there is no actual change (see https://bugs.webkit.org/show_bug.cgi?id=35256 and <rdar://7467917>).
125     // The selectOption function does not behave this way, possibly because other callers need a change event even
126     // in cases where the selected option is not change.
127     if (optionIndex == selectedIndex())
128         return;
129
130     selectOption(optionIndex, DeselectOtherOptions | (fireOnChangeNow ? DispatchChangeEvent : 0) | UserDriven);
131 }
132
133 bool HTMLSelectElement::hasPlaceholderLabelOption() const
134 {
135     // The select element has no placeholder label option if it has an attribute "multiple" specified or a display size of non-1.
136     // 
137     // The condition "size() > 1" is not compliant with the HTML5 spec as of Dec 3, 2010. "size() != 1" is correct.
138     // Using "size() > 1" here because size() may be 0 in WebKit.
139     // See the discussion at https://bugs.webkit.org/show_bug.cgi?id=43887
140     //
141     // "0 size()" happens when an attribute "size" is absent or an invalid size attribute is specified.
142     // In this case, the display size should be assumed as the default.
143     // The default display size is 1 for non-multiple select elements, and 4 for multiple select elements.
144     //
145     // Finally, if size() == 0 and non-multiple, the display size can be assumed as 1.
146     if (multiple() || size() > 1)
147         return false;
148
149     int listIndex = optionToListIndex(0);
150     ASSERT(listIndex >= 0);
151     if (listIndex < 0)
152         return false;
153     HTMLOptionElement& option = downcast<HTMLOptionElement>(*listItems()[listIndex]);
154     return !listIndex && option.value().isEmpty();
155 }
156
157 String HTMLSelectElement::validationMessage() const
158 {
159     if (!willValidate())
160         return String();
161
162     if (customError())
163         return customValidationMessage();
164
165     return valueMissing() ? validationMessageValueMissingForSelectText() : String();
166 }
167
168 bool HTMLSelectElement::valueMissing() const
169 {
170     if (!willValidate())
171         return false;
172
173     if (!isRequired())
174         return false;
175
176     int firstSelectionIndex = selectedIndex();
177
178     // If a non-placeholer label option is selected (firstSelectionIndex > 0), it's not value-missing.
179     return firstSelectionIndex < 0 || (!firstSelectionIndex && hasPlaceholderLabelOption());
180 }
181
182 void HTMLSelectElement::listBoxSelectItem(int listIndex, bool allowMultiplySelections, bool shift, bool fireOnChangeNow)
183 {
184     if (!multiple())
185         optionSelectedByUser(listToOptionIndex(listIndex), fireOnChangeNow, false);
186     else {
187         updateSelectedState(listIndex, allowMultiplySelections, shift);
188         updateValidity();
189         if (fireOnChangeNow)
190             listBoxOnChange();
191     }
192 }
193
194 bool HTMLSelectElement::usesMenuList() const
195 {
196 #if !PLATFORM(IOS)
197     const Page* page = document().page();
198     RefPtr<RenderTheme> renderTheme = page ? &page->theme() : RenderTheme::defaultTheme();
199     if (renderTheme->delegatesMenuListRendering())
200         return true;
201
202     return !m_multiple && m_size <= 1;
203 #else
204     return !m_multiple;
205 #endif
206 }
207
208 int HTMLSelectElement::activeSelectionStartListIndex() const
209 {
210     if (m_activeSelectionAnchorIndex >= 0)
211         return m_activeSelectionAnchorIndex;
212     return optionToListIndex(selectedIndex());
213 }
214
215 int HTMLSelectElement::activeSelectionEndListIndex() const
216 {
217     if (m_activeSelectionEndIndex >= 0)
218         return m_activeSelectionEndIndex;
219     return lastSelectedListIndex();
220 }
221
222 void HTMLSelectElement::add(HTMLElement* element, HTMLElement* beforeElement, ExceptionCode& ec)
223 {
224     if (!element || !(is<HTMLOptionElement>(*element) || element->hasTagName(hrTag) || is<HTMLOptGroupElement>(*element)))
225         return;
226
227     // Make sure the element is ref'd and deref'd so we don't leak it.
228     Ref<HTMLElement> protectNewChild(*element);
229
230     insertBefore(*element, beforeElement, ec);
231     updateValidity();
232 }
233
234 void HTMLSelectElement::add(HTMLElement* element, int beforeIndex, ExceptionCode& ec)
235 {
236     add(element, item(beforeIndex), ec);
237 }
238
239 void HTMLSelectElement::removeByIndex(int optionIndex)
240 {
241     int listIndex = optionToListIndex(optionIndex);
242     if (listIndex < 0)
243         return;
244
245     listItems()[listIndex]->remove(IGNORE_EXCEPTION);
246 }
247
248 void HTMLSelectElement::remove(HTMLOptionElement* option)
249 {
250     if (option->ownerSelectElement() != this)
251         return;
252
253     option->remove(IGNORE_EXCEPTION);
254 }
255
256 String HTMLSelectElement::value() const
257 {
258     for (auto* item : listItems()) {
259         if (is<HTMLOptionElement>(*item)) {
260             HTMLOptionElement& option = downcast<HTMLOptionElement>(*item);
261             if (option.selected())
262                 return option.value();
263         }
264     }
265     return emptyString();
266 }
267
268 void HTMLSelectElement::setValue(const String &value)
269 {
270     // We clear the previously selected option(s) when needed, to guarantee calling setSelectedIndex() only once.
271     if (value.isNull()) {
272         setSelectedIndex(-1);
273         return;
274     }
275
276     // Find the option with value() matching the given parameter and make it the current selection.
277     unsigned optionIndex = 0;
278     for (auto* item : listItems()) {
279         if (is<HTMLOptionElement>(*item)) {
280             if (downcast<HTMLOptionElement>(*item).value() == value) {
281                 setSelectedIndex(optionIndex);
282                 return;
283             }
284             ++optionIndex;
285         }
286     }
287
288     setSelectedIndex(-1);
289 }
290
291 bool HTMLSelectElement::isPresentationAttribute(const QualifiedName& name) const
292 {
293     if (name == alignAttr) {
294         // Don't map 'align' attribute. This matches what Firefox, Opera and IE do.
295         // See http://bugs.webkit.org/show_bug.cgi?id=12072
296         return false;
297     }
298
299     return HTMLFormControlElementWithState::isPresentationAttribute(name);
300 }
301
302 void HTMLSelectElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
303 {
304     if (name == sizeAttr) {
305         int oldSize = m_size;
306         // Set the attribute value to a number.
307         // This is important since the style rules for this attribute can determine the appearance property.
308         int size = value.toInt();
309         AtomicString attrSize = AtomicString::number(size);
310         if (attrSize != value) {
311             // FIXME: This is horribly factored.
312             if (Attribute* sizeAttribute = ensureUniqueElementData().findAttributeByName(sizeAttr))
313                 sizeAttribute->setValue(attrSize);
314         }
315         size = std::max(size, 0);
316
317         // Ensure that we've determined selectedness of the items at least once prior to changing the size.
318         if (oldSize != size)
319             updateListItemSelectedStates();
320
321         m_size = size;
322         updateValidity();
323         if (m_size != oldSize) {
324             setNeedsStyleRecalc(ReconstructRenderTree);
325             setRecalcListItems();
326         }
327     } else if (name == multipleAttr)
328         parseMultipleAttribute(value);
329     else if (name == accesskeyAttr) {
330         // FIXME: ignore for the moment.
331         //
332     } else
333         HTMLFormControlElementWithState::parseAttribute(name, value);
334 }
335
336 bool HTMLSelectElement::isKeyboardFocusable(KeyboardEvent* event) const
337 {
338     if (renderer())
339         return isFocusable();
340     return HTMLFormControlElementWithState::isKeyboardFocusable(event);
341 }
342
343 bool HTMLSelectElement::isMouseFocusable() const
344 {
345     if (renderer())
346         return isFocusable();
347     return HTMLFormControlElementWithState::isMouseFocusable();
348 }
349
350 bool HTMLSelectElement::canSelectAll() const
351 {
352     return !usesMenuList();
353 }
354
355 RenderPtr<RenderElement> HTMLSelectElement::createElementRenderer(Ref<RenderStyle>&& style, const RenderTreePosition&)
356 {
357 #if !PLATFORM(IOS)
358     if (usesMenuList())
359         return createRenderer<RenderMenuList>(*this, WTFMove(style));
360     return createRenderer<RenderListBox>(*this, WTFMove(style));
361 #else
362     return createRenderer<RenderMenuList>(*this, WTFMove(style));
363 #endif
364 }
365
366 bool HTMLSelectElement::childShouldCreateRenderer(const Node& child) const
367 {
368     if (!HTMLFormControlElementWithState::childShouldCreateRenderer(child))
369         return false;
370 #if !PLATFORM(IOS)
371     if (!usesMenuList())
372         return is<HTMLOptionElement>(child) || is<HTMLOptGroupElement>(child) || validationMessageShadowTreeContains(child);
373 #endif
374     return validationMessageShadowTreeContains(child);
375 }
376
377 Ref<HTMLCollection> HTMLSelectElement::selectedOptions()
378 {
379     return ensureRareData().ensureNodeLists().addCachedCollection<GenericCachedHTMLCollection<CollectionTypeTraits<SelectedOptions>::traversalType>>(*this, SelectedOptions);
380 }
381
382 Ref<HTMLOptionsCollection> HTMLSelectElement::options()
383 {
384     return ensureRareData().ensureNodeLists().addCachedCollection<HTMLOptionsCollection>(*this, SelectOptions);
385 }
386
387 void HTMLSelectElement::updateListItemSelectedStates()
388 {
389     if (m_shouldRecalcListItems)
390         recalcListItems();
391 }
392
393 void HTMLSelectElement::childrenChanged(const ChildChange& change)
394 {
395     setRecalcListItems();
396     updateValidity();
397     m_lastOnChangeSelection.clear();
398
399     HTMLFormControlElementWithState::childrenChanged(change);
400 }
401
402 void HTMLSelectElement::optionElementChildrenChanged()
403 {
404     setRecalcListItems();
405     updateValidity();
406
407     if (renderer()) {
408         if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
409             cache->childrenChanged(this);
410     }
411 }
412
413 void HTMLSelectElement::accessKeyAction(bool sendMouseEvents)
414 {
415     focus();
416     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
417 }
418
419 void HTMLSelectElement::setMultiple(bool multiple)
420 {
421     bool oldMultiple = this->multiple();
422     int oldSelectedIndex = selectedIndex();
423     setAttribute(multipleAttr, multiple ? "" : 0);
424
425     // Restore selectedIndex after changing the multiple flag to preserve
426     // selection as single-line and multi-line has different defaults.
427     if (oldMultiple != this->multiple())
428         setSelectedIndex(oldSelectedIndex);
429 }
430
431 void HTMLSelectElement::setSize(int size)
432 {
433     setIntegralAttribute(sizeAttr, size);
434 }
435
436 HTMLOptionElement* HTMLSelectElement::namedItem(const AtomicString& name)
437 {
438     return options()->namedItem(name);
439 }
440
441 HTMLOptionElement* HTMLSelectElement::item(unsigned index)
442 {
443     return options()->item(index);
444 }
445
446 void HTMLSelectElement::setOption(unsigned index, HTMLOptionElement* option, ExceptionCode& ec)
447 {
448     ec = 0;
449     if (index > maxSelectItems - 1)
450         index = maxSelectItems - 1;
451     int diff = index - length();
452     RefPtr<HTMLOptionElement> before;
453     // Out of array bounds? First insert empty dummies.
454     if (diff > 0) {
455         setLength(index, ec);
456         // Replace an existing entry?
457     } else if (diff < 0) {
458         before = item(index + 1);
459         removeByIndex(index);
460     }
461     // Finally add the new element.
462     if (!ec) {
463         add(option, before.get(), ec);
464         if (diff >= 0 && option->selected())
465             optionSelectionStateChanged(option, true);
466     }
467 }
468
469 void HTMLSelectElement::setLength(unsigned newLen, ExceptionCode& ec)
470 {
471     ec = 0;
472     if (newLen > maxSelectItems)
473         newLen = maxSelectItems;
474     int diff = length() - newLen;
475
476     if (diff < 0) { // Add dummy elements.
477         do {
478             RefPtr<Element> option = document().createElement(optionTag, false);
479             ASSERT(option);
480             add(downcast<HTMLElement>(option.get()), nullptr, ec);
481             if (ec)
482                 break;
483         } while (++diff);
484     } else {
485         const Vector<HTMLElement*>& items = listItems();
486
487         // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
488         // of elements that we intend to remove then attempt to remove them one at a time.
489         Vector<Ref<Element>> itemsToRemove;
490         size_t optionIndex = 0;
491         for (auto& item : items) {
492             if (is<HTMLOptionElement>(*item) && optionIndex++ >= newLen) {
493                 ASSERT(item->parentNode());
494                 itemsToRemove.append(*item);
495             }
496         }
497
498         for (auto& item : itemsToRemove) {
499             if (item->parentNode())
500                 item->parentNode()->removeChild(item.get(), ec);
501         }
502     }
503     updateValidity();
504 }
505
506 bool HTMLSelectElement::isRequiredFormControl() const
507 {
508     return isRequired();
509 }
510
511 #if PLATFORM(IOS)
512 bool HTMLSelectElement::willRespondToMouseClickEvents()
513 {
514     return !isDisabledFormControl();
515 }
516 #endif
517
518 // Returns the 1st valid item |skip| items from |listIndex| in direction |direction| if there is one.
519 // Otherwise, it returns the valid item closest to that boundary which is past |listIndex| if there is one.
520 // Otherwise, it returns |listIndex|.
521 // Valid means that it is enabled and an option element.
522 int HTMLSelectElement::nextValidIndex(int listIndex, SkipDirection direction, int skip) const
523 {
524     ASSERT(direction == -1 || direction == 1);
525     const Vector<HTMLElement*>& listItems = this->listItems();
526     int lastGoodIndex = listIndex;
527     int size = listItems.size();
528     for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {
529         --skip;
530         if (!listItems[listIndex]->isDisabledFormControl() && is<HTMLOptionElement>(*listItems[listIndex])) {
531             lastGoodIndex = listIndex;
532             if (skip <= 0)
533                 break;
534         }
535     }
536     return lastGoodIndex;
537 }
538
539 int HTMLSelectElement::nextSelectableListIndex(int startIndex) const
540 {
541     return nextValidIndex(startIndex, SkipForwards, 1);
542 }
543
544 int HTMLSelectElement::previousSelectableListIndex(int startIndex) const
545 {
546     if (startIndex == -1)
547         startIndex = listItems().size();
548     return nextValidIndex(startIndex, SkipBackwards, 1);
549 }
550
551 int HTMLSelectElement::firstSelectableListIndex() const
552 {
553     const Vector<HTMLElement*>& items = listItems();
554     int index = nextValidIndex(items.size(), SkipBackwards, INT_MAX);
555     if (static_cast<size_t>(index) == items.size())
556         return -1;
557     return index;
558 }
559
560 int HTMLSelectElement::lastSelectableListIndex() const
561 {
562     return nextValidIndex(-1, SkipForwards, INT_MAX);
563 }
564
565 // Returns the index of the next valid item one page away from |startIndex| in direction |direction|.
566 int HTMLSelectElement::nextSelectableListIndexPageAway(int startIndex, SkipDirection direction) const
567 {
568     const Vector<HTMLElement*>& items = listItems();
569     // Can't use m_size because renderer forces a minimum size.
570     int pageSize = 0;
571     if (is<RenderListBox>(*renderer()))
572         pageSize = downcast<RenderListBox>(*renderer()).size() - 1; // -1 so we still show context.
573
574     // One page away, but not outside valid bounds.
575     // If there is a valid option item one page away, the index is chosen.
576     // If there is no exact one page away valid option, returns startIndex or the most far index.
577     int edgeIndex = direction == SkipForwards ? 0 : items.size() - 1;
578     int skipAmount = pageSize + (direction == SkipForwards ? startIndex : edgeIndex - startIndex);
579     return nextValidIndex(edgeIndex, direction, skipAmount);
580 }
581
582 void HTMLSelectElement::selectAll()
583 {
584     ASSERT(!usesMenuList());
585     if (!renderer() || !m_multiple)
586         return;
587
588     // Save the selection so it can be compared to the new selectAll selection
589     // when dispatching change events.
590     saveLastSelection();
591
592     m_activeSelectionState = true;
593     setActiveSelectionAnchorIndex(nextSelectableListIndex(-1));
594     setActiveSelectionEndIndex(previousSelectableListIndex(-1));
595     if (m_activeSelectionAnchorIndex < 0)
596         return;
597
598     updateListBoxSelection(false);
599     listBoxOnChange();
600     updateValidity();
601 }
602
603 void HTMLSelectElement::saveLastSelection()
604 {
605     if (usesMenuList()) {
606         m_lastOnChangeIndex = selectedIndex();
607         return;
608     }
609
610     m_lastOnChangeSelection.clear();
611     for (auto& element : listItems())
612         m_lastOnChangeSelection.append(is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected());
613 }
614
615 void HTMLSelectElement::setActiveSelectionAnchorIndex(int index)
616 {
617     m_activeSelectionAnchorIndex = index;
618
619     // Cache the selection state so we can restore the old selection as the new
620     // selection pivots around this anchor index.
621     m_cachedStateForActiveSelection.clear();
622
623     for (auto& element : listItems())
624         m_cachedStateForActiveSelection.append(is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected());
625 }
626
627 void HTMLSelectElement::setActiveSelectionEndIndex(int index)
628 {
629     m_activeSelectionEndIndex = index;
630 }
631
632 void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions)
633 {
634 #if !PLATFORM(IOS)
635     ASSERT(renderer() && (renderer()->isListBox() || m_multiple));
636 #else
637     ASSERT(renderer() && (renderer()->isMenuList() || m_multiple));
638 #endif
639     ASSERT(!listItems().size() || m_activeSelectionAnchorIndex >= 0);
640
641     unsigned start = std::min(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
642     unsigned end = std::max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
643
644     const Vector<HTMLElement*>& items = listItems();
645     for (unsigned i = 0; i < items.size(); ++i) {
646         HTMLElement* element = items[i];
647         if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
648             continue;
649
650         if (i >= start && i <= end)
651             downcast<HTMLOptionElement>(*element).setSelectedState(m_activeSelectionState);
652         else if (deselectOtherOptions || i >= m_cachedStateForActiveSelection.size())
653             downcast<HTMLOptionElement>(*element).setSelectedState(false);
654         else
655             downcast<HTMLOptionElement>(*element).setSelectedState(m_cachedStateForActiveSelection[i]);
656     }
657
658     scrollToSelection();
659     updateValidity();
660 }
661
662 void HTMLSelectElement::listBoxOnChange()
663 {
664     ASSERT(!usesMenuList() || m_multiple);
665
666     const Vector<HTMLElement*>& items = listItems();
667
668     // If the cached selection list is empty, or the size has changed, then fire
669     // dispatchFormControlChangeEvent, and return early.
670     if (m_lastOnChangeSelection.isEmpty() || m_lastOnChangeSelection.size() != items.size()) {
671         dispatchFormControlChangeEvent();
672         return;
673     }
674
675     // Update m_lastOnChangeSelection and fire dispatchFormControlChangeEvent.
676     bool fireOnChange = false;
677     for (unsigned i = 0; i < items.size(); ++i) {
678         HTMLElement* element = items[i];
679         bool selected = is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected();
680         if (selected != m_lastOnChangeSelection[i])
681             fireOnChange = true;
682         m_lastOnChangeSelection[i] = selected;
683     }
684
685     if (fireOnChange) {
686         dispatchInputEvent();
687         dispatchFormControlChangeEvent();
688     }
689 }
690
691 void HTMLSelectElement::dispatchChangeEventForMenuList()
692 {
693     ASSERT(usesMenuList());
694
695     int selected = selectedIndex();
696     if (m_lastOnChangeIndex != selected && m_isProcessingUserDrivenChange) {
697         m_lastOnChangeIndex = selected;
698         m_isProcessingUserDrivenChange = false;
699         dispatchInputEvent();
700         dispatchFormControlChangeEvent();
701     }
702 }
703
704 void HTMLSelectElement::scrollToSelection()
705 {
706 #if !PLATFORM(IOS)
707     if (usesMenuList())
708         return;
709
710     auto* renderer = this->renderer();
711     if (!is<RenderListBox>(renderer))
712         return;
713     downcast<RenderListBox>(*renderer).selectionChanged();
714 #else
715     if (auto* renderer = this->renderer())
716         renderer->repaint();
717 #endif
718 }
719
720 void HTMLSelectElement::setOptionsChangedOnRenderer()
721 {
722     if (auto* renderer = this->renderer()) {
723 #if !PLATFORM(IOS)
724         if (is<RenderMenuList>(*renderer))
725             downcast<RenderMenuList>(*renderer).setOptionsChanged(true);
726         else
727             downcast<RenderListBox>(*renderer).setOptionsChanged(true);
728 #else
729         downcast<RenderMenuList>(*renderer).setOptionsChanged(true);
730 #endif
731     }
732 }
733
734 const Vector<HTMLElement*>& HTMLSelectElement::listItems() const
735 {
736     if (m_shouldRecalcListItems)
737         recalcListItems();
738     else {
739 #if !ASSERT_DISABLED
740         Vector<HTMLElement*> items = m_listItems;
741         recalcListItems(false);
742         ASSERT(items == m_listItems);
743 #endif
744     }
745
746     return m_listItems;
747 }
748
749 void HTMLSelectElement::invalidateSelectedItems()
750 {
751     if (HTMLCollection* collection = cachedHTMLCollection(SelectedOptions))
752         collection->invalidateCache(document());
753 }
754
755 void HTMLSelectElement::setRecalcListItems()
756 {
757     m_shouldRecalcListItems = true;
758     // Manual selection anchor is reset when manipulating the select programmatically.
759     m_activeSelectionAnchorIndex = -1;
760     setOptionsChangedOnRenderer();
761     setNeedsStyleRecalc();
762     if (!inDocument()) {
763         if (HTMLCollection* collection = cachedHTMLCollection(SelectOptions))
764             collection->invalidateCache(document());
765     }
766     if (!inDocument())
767         invalidateSelectedItems();
768     
769     if (renderer()) {
770         if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
771             cache->childrenChanged(this);
772     }
773 }
774
775 void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
776 {
777     m_listItems.clear();
778
779     m_shouldRecalcListItems = false;
780
781     HTMLOptionElement* foundSelected = 0;
782     HTMLOptionElement* firstOption = 0;
783     for (Element* currentElement = ElementTraversal::firstWithin(*this); currentElement; ) {
784         if (!is<HTMLElement>(*currentElement)) {
785             currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
786             continue;
787         }
788         HTMLElement& current = downcast<HTMLElement>(*currentElement);
789
790         // optgroup tags may not nest. However, both FireFox and IE will
791         // flatten the tree automatically, so we follow suit.
792         // (http://www.w3.org/TR/html401/interact/forms.html#h-17.6)
793         if (is<HTMLOptGroupElement>(current)) {
794             m_listItems.append(&current);
795             if (Element* nextElement = ElementTraversal::firstWithin(current)) {
796                 currentElement = nextElement;
797                 continue;
798             }
799         }
800
801         if (is<HTMLOptionElement>(current)) {
802             m_listItems.append(&current);
803
804             if (updateSelectedStates && !m_multiple) {
805                 HTMLOptionElement& option = downcast<HTMLOptionElement>(current);
806                 if (!firstOption)
807                     firstOption = &option;
808                 if (option.selected()) {
809                     if (foundSelected)
810                         foundSelected->setSelectedState(false);
811                     foundSelected = &option;
812                 } else if (m_size <= 1 && !foundSelected && !option.isDisabledFormControl()) {
813                     foundSelected = &option;
814                     foundSelected->setSelectedState(true);
815                 }
816             }
817         }
818
819         if (current.hasTagName(hrTag))
820             m_listItems.append(&current);
821
822         // In conforming HTML code, only <optgroup> and <option> will be found
823         // within a <select>. We call NodeTraversal::nextSkippingChildren so that we only step
824         // into those tags that we choose to. For web-compat, we should cope
825         // with the case where odd tags like a <div> have been added but we
826         // handle this because such tags have already been removed from the
827         // <select>'s subtree at this point.
828         currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
829     }
830
831     if (!foundSelected && m_size <= 1 && firstOption && !firstOption->selected())
832         firstOption->setSelectedState(true);
833 }
834
835 int HTMLSelectElement::selectedIndex() const
836 {
837     unsigned index = 0;
838
839     // Return the number of the first option selected.
840     for (auto& element : listItems()) {
841         if (is<HTMLOptionElement>(*element)) {
842             if (downcast<HTMLOptionElement>(*element).selected())
843                 return index;
844             ++index;
845         }
846     }
847
848     return -1;
849 }
850
851 void HTMLSelectElement::setSelectedIndex(int index)
852 {
853     selectOption(index, DeselectOtherOptions);
854 }
855
856 void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
857 {
858     ASSERT(option->ownerSelectElement() == this);
859     if (optionIsSelected)
860         selectOption(option->index());
861     else if (!usesMenuList())
862         selectOption(-1);
863     else
864         selectOption(nextSelectableListIndex(-1));
865 }
866
867 void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
868 {
869     bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
870
871     const Vector<HTMLElement*>& items = listItems();
872     int listIndex = optionToListIndex(optionIndex);
873
874     HTMLElement* element = nullptr;
875     if (listIndex >= 0) {
876         element = items[listIndex];
877     }
878
879     if (shouldDeselect)
880         deselectItemsWithoutValidation(element);
881
882     if (is<HTMLOptionElement>(element)) {
883         if (m_activeSelectionAnchorIndex < 0 || shouldDeselect)
884             setActiveSelectionAnchorIndex(listIndex);
885         if (m_activeSelectionEndIndex < 0 || shouldDeselect)
886             setActiveSelectionEndIndex(listIndex);
887         downcast<HTMLOptionElement>(*element).setSelectedState(true);
888     }
889
890     updateValidity();
891
892     // For the menu list case, this is what makes the selected element appear.
893     if (auto* renderer = this->renderer())
894         renderer->updateFromElement();
895
896     scrollToSelection();
897
898     if (usesMenuList()) {
899         m_isProcessingUserDrivenChange = flags & UserDriven;
900         if (flags & DispatchChangeEvent)
901             dispatchChangeEventForMenuList();
902         if (auto* renderer = this->renderer()) {
903             if (is<RenderMenuList>(*renderer))
904                 downcast<RenderMenuList>(*renderer).didSetSelectedIndex(listIndex);
905             else
906                 downcast<RenderListBox>(*renderer).selectionChanged();
907         }
908     }
909 }
910
911 int HTMLSelectElement::optionToListIndex(int optionIndex) const
912 {
913     const Vector<HTMLElement*>& items = listItems();
914     int listSize = static_cast<int>(items.size());
915     if (optionIndex < 0 || optionIndex >= listSize)
916         return -1;
917
918     int optionIndex2 = -1;
919     for (int listIndex = 0; listIndex < listSize; ++listIndex) {
920         if (is<HTMLOptionElement>(*items[listIndex])) {
921             ++optionIndex2;
922             if (optionIndex2 == optionIndex)
923                 return listIndex;
924         }
925     }
926
927     return -1;
928 }
929
930 int HTMLSelectElement::listToOptionIndex(int listIndex) const
931 {
932     const Vector<HTMLElement*>& items = listItems();
933     if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !is<HTMLOptionElement>(*items[listIndex]))
934         return -1;
935
936     // Actual index of option not counting OPTGROUP entries that may be in list.
937     int optionIndex = 0;
938     for (int i = 0; i < listIndex; ++i) {
939         if (is<HTMLOptionElement>(*items[i]))
940             ++optionIndex;
941     }
942
943     return optionIndex;
944 }
945
946 void HTMLSelectElement::dispatchFocusEvent(RefPtr<Element>&& oldFocusedElement, FocusDirection direction)
947 {
948     // Save the selection so it can be compared to the new selection when
949     // dispatching change events during blur event dispatch.
950     if (usesMenuList())
951         saveLastSelection();
952     HTMLFormControlElementWithState::dispatchFocusEvent(WTFMove(oldFocusedElement), direction);
953 }
954
955 void HTMLSelectElement::dispatchBlurEvent(RefPtr<Element>&& newFocusedElement)
956 {
957     // We only need to fire change events here for menu lists, because we fire
958     // change events for list boxes whenever the selection change is actually made.
959     // This matches other browsers' behavior.
960     if (usesMenuList())
961         dispatchChangeEventForMenuList();
962     HTMLFormControlElementWithState::dispatchBlurEvent(WTFMove(newFocusedElement));
963 }
964
965 void HTMLSelectElement::deselectItemsWithoutValidation(HTMLElement* excludeElement)
966 {
967     for (auto& element : listItems()) {
968         if (element != excludeElement && is<HTMLOptionElement>(*element))
969             downcast<HTMLOptionElement>(*element).setSelectedState(false);
970     }
971 }
972
973 FormControlState HTMLSelectElement::saveFormControlState() const
974 {
975     FormControlState state;
976     for (auto& element : listItems()) {
977         if (!is<HTMLOptionElement>(*element))
978             continue;
979         HTMLOptionElement& option = downcast<HTMLOptionElement>(*element);
980         if (!option.selected())
981             continue;
982         state.append(option.value());
983         if (!multiple())
984             break;
985     }
986     return state;
987 }
988
989 size_t HTMLSelectElement::searchOptionsForValue(const String& value, size_t listIndexStart, size_t listIndexEnd) const
990 {
991     const Vector<HTMLElement*>& items = listItems();
992     size_t loopEndIndex = std::min(items.size(), listIndexEnd);
993     for (size_t i = listIndexStart; i < loopEndIndex; ++i) {
994         if (!is<HTMLOptionElement>(*items[i]))
995             continue;
996         if (downcast<HTMLOptionElement>(*items[i]).value() == value)
997             return i;
998     }
999     return notFound;
1000 }
1001
1002 void HTMLSelectElement::restoreFormControlState(const FormControlState& state)
1003 {
1004     recalcListItems();
1005
1006     const Vector<HTMLElement*>& items = listItems();
1007     size_t itemsSize = items.size();
1008     if (!itemsSize)
1009         return;
1010
1011     for (auto& element : items) {
1012         if (!is<HTMLOptionElement>(*element))
1013             continue;
1014         downcast<HTMLOptionElement>(*element).setSelectedState(false);
1015     }
1016
1017     if (!multiple()) {
1018         size_t foundIndex = searchOptionsForValue(state[0], 0, itemsSize);
1019         if (foundIndex != notFound)
1020             downcast<HTMLOptionElement>(*items[foundIndex]).setSelectedState(true);
1021     } else {
1022         size_t startIndex = 0;
1023         for (size_t i = 0; i < state.valueSize(); ++i) {
1024             const String& value = state[i];
1025             size_t foundIndex = searchOptionsForValue(value, startIndex, itemsSize);
1026             if (foundIndex == notFound)
1027                 foundIndex = searchOptionsForValue(value, 0, startIndex);
1028             if (foundIndex == notFound)
1029                 continue;
1030             downcast<HTMLOptionElement>(*items[foundIndex]).setSelectedState(true);
1031             startIndex = foundIndex + 1;
1032         }
1033     }
1034
1035     setOptionsChangedOnRenderer();
1036     updateValidity();
1037 }
1038
1039 void HTMLSelectElement::parseMultipleAttribute(const AtomicString& value)
1040 {
1041     bool oldUsesMenuList = usesMenuList();
1042     m_multiple = !value.isNull();
1043     updateValidity();
1044     if (oldUsesMenuList != usesMenuList())
1045         setNeedsStyleRecalc(ReconstructRenderTree);
1046 }
1047
1048 bool HTMLSelectElement::appendFormData(FormDataList& list, bool)
1049 {
1050     const AtomicString& name = this->name();
1051     if (name.isEmpty())
1052         return false;
1053
1054     bool successful = false;
1055     for (auto& element : listItems()) {
1056         if (is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected() && !downcast<HTMLOptionElement>(*element).isDisabledFormControl()) {
1057             list.appendData(name, downcast<HTMLOptionElement>(*element).value());
1058             successful = true;
1059         }
1060     }
1061
1062     // It's possible that this is a menulist with multiple options and nothing
1063     // will be submitted (!successful). We won't send a unselected non-disabled
1064     // option as fallback. This behavior matches to other browsers.
1065     return successful;
1066
1067
1068 void HTMLSelectElement::reset()
1069 {
1070     HTMLOptionElement* firstOption = nullptr;
1071     HTMLOptionElement* selectedOption = nullptr;
1072
1073     for (auto& element : listItems()) {
1074         if (!is<HTMLOptionElement>(*element))
1075             continue;
1076
1077         HTMLOptionElement& option = downcast<HTMLOptionElement>(*element);
1078         if (option.fastHasAttribute(selectedAttr)) {
1079             if (selectedOption && !m_multiple)
1080                 selectedOption->setSelectedState(false);
1081             option.setSelectedState(true);
1082             selectedOption = &option;
1083         } else
1084             option.setSelectedState(false);
1085
1086         if (!firstOption)
1087             firstOption = &option;
1088     }
1089
1090     if (!selectedOption && firstOption && !m_multiple && m_size <= 1)
1091         firstOption->setSelectedState(true);
1092
1093     setOptionsChangedOnRenderer();
1094     setNeedsStyleRecalc();
1095     updateValidity();
1096 }
1097
1098 #if !PLATFORM(WIN)
1099 bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
1100 {
1101     const Page* page = document().page();
1102     RefPtr<RenderTheme> renderTheme = page ? &page->theme() : RenderTheme::defaultTheme();
1103
1104     if (!renderTheme->popsMenuByArrowKeys())
1105         return false;
1106
1107     if (!isSpatialNavigationEnabled(document().frame())) {
1108         if (event->keyIdentifier() == "Down" || event->keyIdentifier() == "Up") {
1109             focus();
1110             // Calling focus() may cause us to lose our renderer. Return true so
1111             // that our caller doesn't process the event further, but don't set
1112             // the event as handled.
1113             if (!is<RenderMenuList>(renderer()))
1114                 return true;
1115
1116             // Save the selection so it can be compared to the new selection
1117             // when dispatching change events during selectOption, which
1118             // gets called from RenderMenuList::valueChanged, which gets called
1119             // after the user makes a selection from the menu.
1120             saveLastSelection();
1121             downcast<RenderMenuList>(*renderer()).showPopup();
1122             event->setDefaultHandled();
1123         }
1124         return true;
1125     }
1126
1127     return false;
1128 }
1129 #endif
1130
1131 void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
1132 {
1133     ASSERT(renderer() && renderer()->isMenuList());
1134
1135     const Page* page = document().page();
1136     RefPtr<RenderTheme> renderTheme = page ? &page->theme() : RenderTheme::defaultTheme();
1137
1138     if (event->type() == eventNames().keydownEvent) {
1139         if (!is<KeyboardEvent>(*event))
1140             return;
1141
1142         KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
1143         if (platformHandleKeydownEvent(&keyboardEvent))
1144             return;
1145
1146         // When using spatial navigation, we want to be able to navigate away
1147         // from the select element when the user hits any of the arrow keys,
1148         // instead of changing the selection.
1149         if (isSpatialNavigationEnabled(document().frame())) {
1150             if (!m_activeSelectionState)
1151                 return;
1152         }
1153
1154         const String& keyIdentifier = keyboardEvent.keyIdentifier();
1155         bool handled = true;
1156         const Vector<HTMLElement*>& listItems = this->listItems();
1157         int listIndex = optionToListIndex(selectedIndex());
1158
1159         // When using caret browsing, we want to be able to move the focus
1160         // out of the select element when user hits a left or right arrow key.
1161         const Frame* frame = document().frame();
1162         if (frame && frame->settings().caretBrowsingEnabled()) {
1163             if (keyIdentifier == "Left" || keyIdentifier == "Right")
1164                 return;
1165         }
1166
1167         if (keyIdentifier == "Down" || keyIdentifier == "Right")
1168             listIndex = nextValidIndex(listIndex, SkipForwards, 1);
1169         else if (keyIdentifier == "Up" || keyIdentifier == "Left")
1170             listIndex = nextValidIndex(listIndex, SkipBackwards, 1);
1171         else if (keyIdentifier == "PageDown")
1172             listIndex = nextValidIndex(listIndex, SkipForwards, 3);
1173         else if (keyIdentifier == "PageUp")
1174             listIndex = nextValidIndex(listIndex, SkipBackwards, 3);
1175         else if (keyIdentifier == "Home")
1176             listIndex = nextValidIndex(-1, SkipForwards, 1);
1177         else if (keyIdentifier == "End")
1178             listIndex = nextValidIndex(listItems.size(), SkipBackwards, 1);
1179         else
1180             handled = false;
1181
1182         if (handled && static_cast<size_t>(listIndex) < listItems.size())
1183             selectOption(listToOptionIndex(listIndex), DeselectOtherOptions | DispatchChangeEvent | UserDriven);
1184
1185         if (handled)
1186             keyboardEvent.setDefaultHandled();
1187     }
1188
1189     // Use key press event here since sending simulated mouse events
1190     // on key down blocks the proper sending of the key press event.
1191     if (event->type() == eventNames().keypressEvent) {
1192         if (!is<KeyboardEvent>(*event))
1193             return;
1194
1195         KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
1196         int keyCode = keyboardEvent.keyCode();
1197         bool handled = false;
1198
1199         if (keyCode == ' ' && isSpatialNavigationEnabled(document().frame())) {
1200             // Use space to toggle arrow key handling for selection change or spatial navigation.
1201             m_activeSelectionState = !m_activeSelectionState;
1202             keyboardEvent.setDefaultHandled();
1203             return;
1204         }
1205
1206         if (renderTheme->popsMenuBySpaceOrReturn()) {
1207             if (keyCode == ' ' || keyCode == '\r') {
1208                 focus();
1209
1210                 // Calling focus() may remove the renderer or change the
1211                 // renderer type.
1212                 if (!is<RenderMenuList>(renderer()))
1213                     return;
1214
1215                 // Save the selection so it can be compared to the new selection
1216                 // when dispatching change events during selectOption, which
1217                 // gets called from RenderMenuList::valueChanged, which gets called
1218                 // after the user makes a selection from the menu.
1219                 saveLastSelection();
1220                 downcast<RenderMenuList>(*renderer()).showPopup();
1221                 handled = true;
1222             }
1223         } else if (renderTheme->popsMenuByArrowKeys()) {
1224             if (keyCode == ' ') {
1225                 focus();
1226
1227                 // Calling focus() may remove the renderer or change the
1228                 // renderer type.
1229                 if (!is<RenderMenuList>(renderer()))
1230                     return;
1231
1232                 // Save the selection so it can be compared to the new selection
1233                 // when dispatching change events during selectOption, which
1234                 // gets called from RenderMenuList::valueChanged, which gets called
1235                 // after the user makes a selection from the menu.
1236                 saveLastSelection();
1237                 downcast<RenderMenuList>(*renderer()).showPopup();
1238                 handled = true;
1239             } else if (keyCode == '\r') {
1240                 if (form())
1241                     form()->submitImplicitly(&keyboardEvent, false);
1242                 dispatchChangeEventForMenuList();
1243                 handled = true;
1244             }
1245         }
1246
1247         if (handled)
1248             keyboardEvent.setDefaultHandled();
1249     }
1250
1251     if (event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
1252         focus();
1253 #if !PLATFORM(IOS)
1254         if (is<RenderMenuList>(renderer())) {
1255             auto& menuList = downcast<RenderMenuList>(*renderer());
1256             ASSERT(!menuList.popupIsVisible());
1257             // Save the selection so it can be compared to the new
1258             // selection when we call onChange during selectOption,
1259             // which gets called from RenderMenuList::valueChanged,
1260             // which gets called after the user makes a selection from
1261             // the menu.
1262             saveLastSelection();
1263             menuList.showPopup();
1264         }
1265 #endif
1266         event->setDefaultHandled();
1267     }
1268
1269 #if !PLATFORM(IOS)
1270     if (event->type() == eventNames().blurEvent && !focused()) {
1271         auto& menuList = downcast<RenderMenuList>(*renderer());
1272         if (menuList.popupIsVisible())
1273             menuList.hidePopup();
1274     }
1275 #endif
1276 }
1277
1278 void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shift)
1279 {
1280     ASSERT(listIndex >= 0);
1281
1282     // Save the selection so it can be compared to the new selection when
1283     // dispatching change events during mouseup, or after autoscroll finishes.
1284     saveLastSelection();
1285
1286     m_activeSelectionState = true;
1287
1288     bool shiftSelect = m_multiple && shift;
1289     bool multiSelect = m_multiple && multi && !shift;
1290
1291     HTMLElement* clickedElement = listItems()[listIndex];
1292     if (is<HTMLOptionElement>(*clickedElement)) {
1293         // Keep track of whether an active selection (like during drag
1294         // selection), should select or deselect.
1295         if (downcast<HTMLOptionElement>(*clickedElement).selected() && multiSelect)
1296             m_activeSelectionState = false;
1297         if (!m_activeSelectionState)
1298             downcast<HTMLOptionElement>(*clickedElement).setSelectedState(false);
1299     }
1300
1301     // If we're not in any special multiple selection mode, then deselect all
1302     // other items, excluding the clicked option. If no option was clicked, then
1303     // this will deselect all items in the list.
1304     if (!shiftSelect && !multiSelect)
1305         deselectItemsWithoutValidation(clickedElement);
1306
1307     // If the anchor hasn't been set, and we're doing a single selection or a
1308     // shift selection, then initialize the anchor to the first selected index.
1309     if (m_activeSelectionAnchorIndex < 0 && !multiSelect)
1310         setActiveSelectionAnchorIndex(selectedIndex());
1311
1312     // Set the selection state of the clicked option.
1313     if (is<HTMLOptionElement>(*clickedElement) && !downcast<HTMLOptionElement>(*clickedElement).isDisabledFormControl())
1314         downcast<HTMLOptionElement>(*clickedElement).setSelectedState(true);
1315
1316     // If there was no selectedIndex() for the previous initialization, or If
1317     // we're doing a single selection, or a multiple selection (using cmd or
1318     // ctrl), then initialize the anchor index to the listIndex that just got
1319     // clicked.
1320     if (m_activeSelectionAnchorIndex < 0 || !shiftSelect)
1321         setActiveSelectionAnchorIndex(listIndex);
1322
1323     setActiveSelectionEndIndex(listIndex);
1324     updateListBoxSelection(!multiSelect);
1325 }
1326
1327 void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
1328 {
1329     const Vector<HTMLElement*>& listItems = this->listItems();
1330
1331     if (event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
1332         focus();
1333         // Calling focus() may remove or change our renderer, in which case we don't want to handle the event further.
1334         if (!is<RenderListBox>(renderer()))
1335             return;
1336
1337         // Convert to coords relative to the list box if needed.
1338         MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
1339         IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
1340         int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
1341         if (listIndex >= 0) {
1342             if (!isDisabledFormControl()) {
1343 #if PLATFORM(COCOA)
1344                 updateSelectedState(listIndex, mouseEvent.metaKey(), mouseEvent.shiftKey());
1345 #else
1346                 updateSelectedState(listIndex, mouseEvent.ctrlKey(), mouseEvent.shiftKey());
1347 #endif
1348             }
1349             if (Frame* frame = document().frame())
1350                 frame->eventHandler().setMouseDownMayStartAutoscroll();
1351
1352             mouseEvent.setDefaultHandled();
1353         }
1354     } else if (event->type() == eventNames().mousemoveEvent && is<MouseEvent>(*event) && !downcast<RenderBox>(*renderer()).canBeScrolledAndHasScrollableArea()) {
1355         MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
1356         if (mouseEvent.button() != LeftButton || !mouseEvent.buttonDown())
1357             return;
1358
1359         IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
1360         int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
1361         if (listIndex >= 0) {
1362             if (!isDisabledFormControl()) {
1363                 if (m_multiple) {
1364                     // Only extend selection if there is something selected.
1365                     if (m_activeSelectionAnchorIndex < 0)
1366                         return;
1367
1368                     setActiveSelectionEndIndex(listIndex);
1369                     updateListBoxSelection(false);
1370                 } else {
1371                     setActiveSelectionAnchorIndex(listIndex);
1372                     setActiveSelectionEndIndex(listIndex);
1373                     updateListBoxSelection(true);
1374                 }
1375             }
1376             mouseEvent.setDefaultHandled();
1377         }
1378     } else if (event->type() == eventNames().mouseupEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton && document().frame()->eventHandler().autoscrollRenderer() != renderer()) {
1379         // This click or drag event was not over any of the options.
1380         if (m_lastOnChangeSelection.isEmpty())
1381             return;
1382         // This makes sure we fire dispatchFormControlChangeEvent for a single
1383         // click. For drag selection, onChange will fire when the autoscroll
1384         // timer stops.
1385         listBoxOnChange();
1386     } else if (event->type() == eventNames().keydownEvent) {
1387         if (!is<KeyboardEvent>(*event))
1388             return;
1389
1390         KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
1391         const String& keyIdentifier = keyboardEvent.keyIdentifier();
1392
1393         bool handled = false;
1394         int endIndex = 0;
1395         if (m_activeSelectionEndIndex < 0) {
1396             // Initialize the end index
1397             if (keyIdentifier == "Down" || keyIdentifier == "PageDown") {
1398                 int startIndex = lastSelectedListIndex();
1399                 handled = true;
1400                 if (keyIdentifier == "Down")
1401                     endIndex = nextSelectableListIndex(startIndex);
1402                 else
1403                     endIndex = nextSelectableListIndexPageAway(startIndex, SkipForwards);
1404             } else if (keyIdentifier == "Up" || keyIdentifier == "PageUp") {
1405                 int startIndex = optionToListIndex(selectedIndex());
1406                 handled = true;
1407                 if (keyIdentifier == "Up")
1408                     endIndex = previousSelectableListIndex(startIndex);
1409                 else
1410                     endIndex = nextSelectableListIndexPageAway(startIndex, SkipBackwards);
1411             }
1412         } else {
1413             // Set the end index based on the current end index.
1414             if (keyIdentifier == "Down") {
1415                 endIndex = nextSelectableListIndex(m_activeSelectionEndIndex);
1416                 handled = true;
1417             } else if (keyIdentifier == "Up") {
1418                 endIndex = previousSelectableListIndex(m_activeSelectionEndIndex);
1419                 handled = true;
1420             } else if (keyIdentifier == "PageDown") {
1421                 endIndex = nextSelectableListIndexPageAway(m_activeSelectionEndIndex, SkipForwards);
1422                 handled = true;
1423             } else if (keyIdentifier == "PageUp") {
1424                 endIndex = nextSelectableListIndexPageAway(m_activeSelectionEndIndex, SkipBackwards);
1425                 handled = true;
1426             }
1427         }
1428         if (keyIdentifier == "Home") {
1429             endIndex = firstSelectableListIndex();
1430             handled = true;
1431         } else if (keyIdentifier == "End") {
1432             endIndex = lastSelectableListIndex();
1433             handled = true;
1434         }
1435
1436         if (isSpatialNavigationEnabled(document().frame()))
1437             // Check if the selection moves to the boundary.
1438             if (keyIdentifier == "Left" || keyIdentifier == "Right" || ((keyIdentifier == "Down" || keyIdentifier == "Up") && endIndex == m_activeSelectionEndIndex))
1439                 return;
1440
1441         if (endIndex >= 0 && handled) {
1442             // Save the selection so it can be compared to the new selection
1443             // when dispatching change events immediately after making the new
1444             // selection.
1445             saveLastSelection();
1446
1447             ASSERT_UNUSED(listItems, !listItems.size() || static_cast<size_t>(endIndex) < listItems.size());
1448             setActiveSelectionEndIndex(endIndex);
1449
1450 #if PLATFORM(COCOA)
1451             m_allowsNonContiguousSelection = m_multiple && isSpatialNavigationEnabled(document().frame());
1452 #else
1453             m_allowsNonContiguousSelection = m_multiple && (isSpatialNavigationEnabled(document().frame()) || keyboardEvent.ctrlKey());
1454 #endif
1455             bool selectNewItem = keyboardEvent.shiftKey() || !m_allowsNonContiguousSelection;
1456
1457             if (selectNewItem)
1458                 m_activeSelectionState = true;
1459             // If the anchor is unitialized, or if we're going to deselect all
1460             // other options, then set the anchor index equal to the end index.
1461             bool deselectOthers = !m_multiple || (!keyboardEvent.shiftKey() && selectNewItem);
1462             if (m_activeSelectionAnchorIndex < 0 || deselectOthers) {
1463                 if (deselectOthers)
1464                     deselectItemsWithoutValidation();
1465                 setActiveSelectionAnchorIndex(m_activeSelectionEndIndex);
1466             }
1467
1468             downcast<RenderListBox>(*renderer()).scrollToRevealElementAtListIndex(endIndex);
1469             if (selectNewItem) {
1470                 updateListBoxSelection(deselectOthers);
1471                 listBoxOnChange();
1472             } else
1473                 scrollToSelection();
1474
1475             keyboardEvent.setDefaultHandled();
1476         }
1477     } else if (event->type() == eventNames().keypressEvent) {
1478         if (!is<KeyboardEvent>(*event))
1479             return;
1480         KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
1481         int keyCode = keyboardEvent.keyCode();
1482
1483         if (keyCode == '\r') {
1484             if (form())
1485                 form()->submitImplicitly(&keyboardEvent, false);
1486             keyboardEvent.setDefaultHandled();
1487         } else if (m_multiple && keyCode == ' ' && m_allowsNonContiguousSelection) {
1488             // Use space to toggle selection change.
1489             m_activeSelectionState = !m_activeSelectionState;
1490             ASSERT(m_activeSelectionEndIndex >= 0);
1491             ASSERT(m_activeSelectionEndIndex < static_cast<int>(listItems.size()));
1492             ASSERT(is<HTMLOptionElement>(*listItems[m_activeSelectionEndIndex]));
1493             updateSelectedState(m_activeSelectionEndIndex, true /*multi*/, false /*shift*/);
1494             listBoxOnChange();
1495             keyboardEvent.setDefaultHandled();
1496         }
1497     }
1498 }
1499
1500 void HTMLSelectElement::defaultEventHandler(Event* event)
1501 {
1502     if (!renderer())
1503         return;
1504
1505 #if !PLATFORM(IOS)
1506     if (isDisabledFormControl()) {
1507         HTMLFormControlElementWithState::defaultEventHandler(event);
1508         return;
1509     }
1510
1511     if (renderer()->isMenuList())
1512         menuListDefaultEventHandler(event);
1513     else 
1514         listBoxDefaultEventHandler(event);
1515 #else
1516     menuListDefaultEventHandler(event);
1517 #endif
1518     if (event->defaultHandled())
1519         return;
1520
1521     if (event->type() == eventNames().keypressEvent && is<KeyboardEvent>(*event)) {
1522         KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
1523         if (!keyboardEvent.ctrlKey() && !keyboardEvent.altKey() && !keyboardEvent.metaKey() && u_isprint(keyboardEvent.charCode())) {
1524             typeAheadFind(keyboardEvent);
1525             event->setDefaultHandled();
1526             return;
1527         }
1528     }
1529     HTMLFormControlElementWithState::defaultEventHandler(event);
1530 }
1531
1532 int HTMLSelectElement::lastSelectedListIndex() const
1533 {
1534     const Vector<HTMLElement*>& items = listItems();
1535     for (size_t i = items.size(); i;) {
1536         HTMLElement* element = items[--i];
1537         if (is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected())
1538             return i;
1539     }
1540     return -1;
1541 }
1542
1543 int HTMLSelectElement::indexOfSelectedOption() const
1544 {
1545     return optionToListIndex(selectedIndex());
1546 }
1547
1548 int HTMLSelectElement::optionCount() const
1549 {
1550     return listItems().size();
1551 }
1552
1553 String HTMLSelectElement::optionAtIndex(int index) const
1554 {
1555     const Vector<HTMLElement*>& items = listItems();
1556     
1557     HTMLElement* element = items[index];
1558     if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
1559         return String();
1560     return downcast<HTMLOptionElement>(*element).textIndentedToRespectGroupLabel();
1561 }
1562
1563 void HTMLSelectElement::typeAheadFind(KeyboardEvent& event)
1564 {
1565     int index = m_typeAhead.handleEvent(&event, TypeAhead::MatchPrefix | TypeAhead::CycleFirstChar);
1566     if (index < 0)
1567         return;
1568     selectOption(listToOptionIndex(index), DeselectOtherOptions | DispatchChangeEvent | UserDriven);
1569     if (!usesMenuList())
1570         listBoxOnChange();
1571 }
1572
1573 Node::InsertionNotificationRequest HTMLSelectElement::insertedInto(ContainerNode& insertionPoint)
1574 {
1575     // When the element is created during document parsing, it won't have any
1576     // items yet - but for innerHTML and related methods, this method is called
1577     // after the whole subtree is constructed.
1578     recalcListItems();
1579     return HTMLFormControlElementWithState::insertedInto(insertionPoint);
1580 }
1581
1582 void HTMLSelectElement::accessKeySetSelectedIndex(int index)
1583 {    
1584     // First bring into focus the list box.
1585     if (!focused())
1586         accessKeyAction(false);
1587     
1588     // If this index is already selected, unselect. otherwise update the selected index.
1589     const Vector<HTMLElement*>& items = listItems();
1590     int listIndex = optionToListIndex(index);
1591     if (listIndex >= 0) {
1592         HTMLElement* element = items[listIndex];
1593         if (is<HTMLOptionElement>(*element)) {
1594             if (downcast<HTMLOptionElement>(*element).selected())
1595                 downcast<HTMLOptionElement>(*element).setSelectedState(false);
1596             else
1597                 selectOption(index, DispatchChangeEvent | UserDriven);
1598         }
1599     }
1600
1601     if (usesMenuList())
1602         dispatchChangeEventForMenuList();
1603     else
1604         listBoxOnChange();
1605
1606     scrollToSelection();
1607 }
1608
1609 unsigned HTMLSelectElement::length() const
1610 {
1611     unsigned options = 0;
1612
1613     const Vector<HTMLElement*>& items = listItems();
1614     for (unsigned i = 0; i < items.size(); ++i) {
1615         if (is<HTMLOptionElement>(*items[i]))
1616             ++options;
1617     }
1618
1619     return options;
1620 }
1621
1622 } // namespace