Improve conformance of default OPTION selection of SELECT element

third_party/WebKit/Source/core/html/HTMLSelectElement.cpp

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
@@ skipping 351 matching lines @@
         // Set the attribute value to a number.
         // This is important since the style rules for this attribute can
         // determine the appearance property.
         unsigned size = value.getString().toUInt();
         AtomicString attrSize = AtomicString::number(size);
         if (attrSize != value) {
             // FIXME: This is horribly factored.
             if (Attribute* sizeAttribute = ensureUniqueElementData().attributes().find(sizeAttr))
                 sizeAttribute->setValue(attrSize);
         }
-        size = std::max(size, 0u);
-
-        // Ensure that we've determined selectedness of the items at least once
-        // prior to changing the size.
-        if (oldSize != size)
-            updateListItemSelectedStates();
-
-        m_size = size;
+        m_size = std::max(size, 0u);
         setNeedsValidityCheck();
-        if (m_size != oldSize && inActiveDocument()) {
-            lazyReattachIfAttached();
-            setRecalcListItems();
+        if (m_size != oldSize) {
+            if (inActiveDocument())
+                lazyReattachIfAttached();
+            resetToDefaultSelection();
         }
     } else if (name == multipleAttr) {
         parseMultipleAttribute(value);
     } else if (name == accesskeyAttr) {
         // FIXME: ignore for the moment.
         //
     } else if (name == disabledAttr) {
         HTMLFormControlElementWithState::parseAttribute(name, oldValue, value);
         if (popupIsVisible())
             hidePopup();
@@ skipping 15 matching lines @@
 
 LayoutObject* HTMLSelectElement::createLayoutObject(const ComputedStyle&)
 {
     if (usesMenuList())
         return new LayoutMenuList(this);
     return new LayoutListBox(this);
 }
 
 PassRefPtrWillBeRawPtr<HTMLCollection> HTMLSelectElement::selectedOptions()
 {
-    updateListItemSelectedStates();
     return ensureCachedCollection<HTMLCollection>(SelectedOptions);
 }
 
 PassRefPtrWillBeRawPtr<HTMLOptionsCollection> HTMLSelectElement::options()
 {
     return ensureCachedCollection<HTMLOptionsCollection>(SelectOptions);
 }
 
-void HTMLSelectElement::updateListItemSelectedStates()
-{
-    if (!m_shouldRecalcListItems)
-        return;
-    recalcListItems();
-    setNeedsValidityCheck();
-}
-
 void HTMLSelectElement::childrenChanged(const ChildrenChange& change)
 {
     setRecalcListItems();
     setNeedsValidityCheck();
     m_lastOnChangeSelection.clear();
 
     HTMLFormControlElementWithState::childrenChanged(change);
 }
 
 void HTMLSelectElement::optionElementChildrenChanged()
@@ skipping 337 matching lines @@
     }
 }
 
 const HTMLSelectElement::ListItems& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems) {
         recalcListItems();
     } else {
 #if ENABLE(ASSERT)
         WillBeHeapVector<RawPtrWillBeMember<HTMLElement>> items = m_listItems;
-        recalcListItems(false);
+        recalcListItems();
         ASSERT(items == m_listItems);
 #endif
     }
 
     return m_listItems;
 }
 
 void HTMLSelectElement::invalidateSelectedItems()
 {
     if (HTMLCollection* collection = cachedCollection<HTMLCollection>(SelectedOptions))
@@ skipping 12 matching lines @@
             collection->invalidateCache();
         invalidateSelectedItems();
     }
 
     if (layoutObject()) {
         if (AXObjectCache* cache = layoutObject()->document().existingAXObjectCache())
             cache->childrenChanged(this);
     }
 }
 
-void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
+void HTMLSelectElement::recalcListItems() const
 {
     TRACE_EVENT0("blink", "HTMLSelectElement::recalcListItems");
     m_listItems.clear();
 
     m_shouldRecalcListItems = false;
 
-    HTMLOptionElement* foundSelected = nullptr;
-    HTMLOptionElement* firstOption = nullptr;
     for (Element* currentElement = ElementTraversal::firstWithin(*this); currentElement && m_listItems.size() < maxListItems; ) {
         if (!currentElement->isHTMLElement()) {
             currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
             continue;
         }
         HTMLElement& current = toHTMLElement(*currentElement);
 
         // We should ignore nested optgroup elements. The HTML parser flatten
         // them.  However we need to ignore nested optgroups built by DOM APIs.
         // This behavior matches to IE and Firefox.
         if (isHTMLOptGroupElement(current)) {
             if (current.parentNode() != this) {
                 currentElement = ElementTraversal::nextSkippingChildren(current, this);
                 continue;
             }
             m_listItems.append(&current);
             if (Element* nextElement = ElementTraversal::firstWithin(current)) {
                 currentElement = nextElement;
                 continue;
             }
         }
 
-        if (isHTMLOptionElement(current)) {
+        if (isHTMLOptionElement(current))
             m_listItems.append(&current);
 
-            if (updateSelectedStates && !m_multiple) {
-                HTMLOptionElement& option = toHTMLOptionElement(current);
-                if (!firstOption)
-                    firstOption = &option;
-                if (option.selected()) {
-                    if (foundSelected)
-                        foundSelected->setSelectedState(false);
-                    foundSelected = &option;
-                } else if (m_size <= 1 && !foundSelected && !option.isDisabledFormControl()) {
-                    foundSelected = &option;
-                    foundSelected->setSelectedState(true);
-                }
-            }
-        }
-
         if (isHTMLHRElement(current))
             m_listItems.append(&current);
 
         // In conforming HTML code, only <optgroup> and <option> will be found
         // within a <select>. We call NodeTraversal::nextSkippingChildren so
         // that we only step into those tags that we choose to. For web-compat,
         // we should cope with the case where odd tags like a <div> have been
         // added but we handle this because such tags have already been removed
         // from the <select>'s subtree at this point.
         currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
     }
+}
 
-    if (!foundSelected && m_size <= 1 && firstOption && !firstOption->selected())
-        firstOption->setSelectedState(true);
+void HTMLSelectElement::resetToDefaultSelection()
+{
+    // https://html.spec.whatwg.org/multipage/forms.html#ask-for-a-reset
+    if (multiple())
+        return;
+    HTMLOptionElement* firstEnabledOption = nullptr;
+    int firstEnabledOptionIndex = -1;
+    HTMLOptionElement* lastSelectedOption = nullptr;
+    bool didChange = false;
+    int optionIndex = 0;
+    // We can't use HTMLSelectElement::options here because this function is
+    // called in Node::insertedInto and Node::removedFrom before invalidating
+    // node collections.
+    for (auto& item : listItems()) {
+        if (!isHTMLOptionElement(item))
+            continue;
+        HTMLOptionElement* option = toHTMLOptionElement(item);
+        if (option->selected()) {
+            if (lastSelectedOption) {
+                lastSelectedOption->setSelectedState(false);
+                didChange = true;
+            }
+            lastSelectedOption = option;
+        }
+        if (!firstEnabledOption && !option->isDisabledFormControl()) {
+            firstEnabledOption = option;
+            firstEnabledOptionIndex = optionIndex;
+        }
+        ++optionIndex;
+    }
+    if (!lastSelectedOption && m_size <= 1 && firstEnabledOption && !firstEnabledOption->selected()) {
+        selectOption(firstEnabledOption, firstEnabledOptionIndex, 0);
+        lastSelectedOption = firstEnabledOption;
+        didChange = true;
+    }
+    if (didChange)
+        setNeedsValidityCheck();
+    m_lastOnChangeOption = lastSelectedOption;
 }
 
 HTMLOptionElement* HTMLSelectElement::selectedOption() const
 {
     for (const auto& element : listItems()) {
         if (isHTMLOptionElement(*element) && toHTMLOptionElement(*element).selected())
             return toHTMLOptionElement(element);
     }
     return nullptr;
 }
@@ skipping 74 matching lines @@
     else if (!usesMenuList() || multiple())
         selectOption(nullptr);
     else
         selectOption(nextSelectableOption(nullptr));
 }
 
 void HTMLSelectElement::optionInserted(HTMLOptionElement& option, bool optionIsSelected)
 {
     ASSERT(option.ownerSelectElement() == this);
     setRecalcListItems();
-    if (optionIsSelected)
+    if (optionIsSelected) {
         selectOption(&option);
+    } else {
+        // No need to reset if we already have a selected option.
+        if (!m_lastOnChangeOption)
+            resetToDefaultSelection();
+    }
 }
 
 void HTMLSelectElement::optionRemoved(const HTMLOptionElement& option)
 {
     setRecalcListItems();
+    if (option.selected() || !m_lastOnChangeOption)
+        resetToDefaultSelection();
     if (m_lastOnChangeOption == &option)
         m_lastOnChangeOption.clear();
     if (m_optionToScrollTo == &option)
         m_optionToScrollTo.clear();
     if (m_activeSelectionAnchor == &option)
         m_activeSelectionAnchor.clear();
     if (m_activeSelectionEnd == &option)
         m_activeSelectionEnd.clear();
     if (option.selected())
         setAutofilled(false);
@@ skipping 235 matching lines @@
         return;
 
     for (auto& element : listItems()) {
         if (isHTMLOptionElement(*element) && toHTMLOptionElement(*element).selected() && !toHTMLOptionElement(*element).isDisabledFormControl())
             formData.append(name, toHTMLOptionElement(*element).value());
     }
 }
 
 void HTMLSelectElement::resetImpl()
 {
-    HTMLOptionElement* firstOption = nullptr;
-    HTMLOptionElement* selectedOption = nullptr;
-
     for (auto& item : listItems()) {
         if (!isHTMLOptionElement(item))
             continue;
         HTMLOptionElement* option = toHTMLOptionElement(item);
-        if (option->fastHasAttribute(selectedAttr)) {
-            if (selectedOption && !m_multiple)
-                selectedOption->setSelectedState(false);
-            option->setSelectedState(true);
-            selectedOption = option;
-        } else {
-            option->setSelectedState(false);
-        }
+        option->setSelectedState(option->fastHasAttribute(selectedAttr));
         option->setDirty(false);
-
-        if (!firstOption && !option->isDisabledFormControl())
-            firstOption = option;
     }
-
-    if (!selectedOption && firstOption && !m_multiple && m_size <= 1) {
-        firstOption->setSelectedState(true);
-        selectedOption = firstOption;
-    }
-
-    m_lastOnChangeOption = selectedOption;
+    resetToDefaultSelection();
     setOptionsChangedOnLayoutObject();
     setNeedsValidityCheck();
 }
 
 void HTMLSelectElement::handlePopupOpenKeyboardEvent(Event* event)
 {
     focus();
     // Calling focus() may cause us to lose our layoutObject. Return true so
     // that our caller doesn't process the event further, but don't set
     // the event as handled.
@@ skipping 505 matching lines @@
     for (auto& item : listItems()) {
         if (isHTMLOptionElement(*item))
             ++options;
     }
     return options;
 }
 
 void HTMLSelectElement::finishParsingChildren()
 {
     HTMLFormControlElementWithState::finishParsingChildren();
-    updateListItemSelectedStates();
     if (usesMenuList())
         return;
     scrollToOption(selectedOption());
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->listboxActiveIndexChanged(this);
 }
 
 bool HTMLSelectElement::anonymousIndexedSetter(unsigned index, PassRefPtrWillBeRawPtr<HTMLOptionElement> value, ExceptionState& exceptionState)
 {
     if (!value) { // undefined or null
@@ skipping 25 matching lines @@
     visitor->trace(m_listItems);
 #endif
     visitor->trace(m_lastOnChangeOption);
     visitor->trace(m_activeSelectionAnchor);
     visitor->trace(m_activeSelectionEnd);
     visitor->trace(m_optionToScrollTo);
     visitor->trace(m_popup);
     HTMLFormControlElementWithState::trace(visitor);
 }
 
-void HTMLSelectElement::willRecalcStyle(StyleRecalcChange change)
-{
-    // recalcListItems will update the selected state of the <option> elements
-    // in this <select> so we need to do it before we recalc their style so they
-    // match the right selectors (ex. :checked).
-    // TODO(esprehn): Find a way to avoid needing a willRecalcStyle callback.
-    if (m_shouldRecalcListItems)
-        recalcListItems();
-}
-
 void HTMLSelectElement::didAddUserAgentShadowRoot(ShadowRoot& root)
 {
     RefPtrWillBeRawPtr<HTMLContentElement> content = HTMLContentElement::create(document());
     content->setAttribute(selectAttr, "option,optgroup,hr");
     root.appendChild(content);
 }
 
 HTMLOptionElement* HTMLSelectElement::spatialNavigationFocusedOption()
 {
     if (!isSpatialNavigationEnabled(document().frame()))
@@ skipping 142 matching lines @@
     m_popupIsVisible = false;
     m_popup = nullptr;
 }
 
 void HTMLSelectElement::resetTypeAheadSessionForTesting()
 {
     m_typeAhead.resetSession();
 }
 
 } // namespace blink