SELECT element: Remove optionIndex argument of HTMLSelectElement::selectOption().

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 127 matching lines @@
 
     // Bail out if this index is already the selected one, to avoid running
     // unnecessary JavaScript that can mess up autofill when there is no actual
     // change (see https://bugs.webkit.org/show_bug.cgi?id=35256 and
     // <rdar://7467917>).  The selectOption function does not behave this way,
     // possibly because other callers need a change event even in cases where
     // the selected option is not change.
     if (optionIndex == selectedIndex())
         return;
 
-    selectOption(optionIndex, DeselectOtherOptions | MakeOptionDirty | (fireOnChangeNow ? DispatchInputAndChangeEvent : 0));
+    selectOption(item(optionIndex), DeselectOtherOptions | MakeOptionDirty | (fireOnChangeNow ? DispatchInputAndChangeEvent : 0));
 }
 
 bool HTMLSelectElement::hasPlaceholderLabelOption() const
 {
     // The select element has no placeholder label option if it has an attribute
     // "multiple" specified or a display size of non-1.
     //
     // The condition "size() > 1" is not compliant with the HTML5 spec as of Dec
     // 3, 2010. "size() != 1" is correct.  Using "size() > 1" here because
     // size() may be 0 in WebKit.  See the discussion at
@@ skipping 117 matching lines @@
     if (HTMLOptionElement* option = selectedOption())
         return option->value();
     return "";
 }
 
 void HTMLSelectElement::setValue(const String &value, bool sendEvents)
 {
     // We clear the previously selected option(s) when needed, to guarantee
     // calling setSelectedIndex() only once.
     int optionIndex = 0;
+    HTMLOptionElement* option = nullptr;
     if (value.isNull()) {
         optionIndex = -1;
     } else {
         // Find the option with value() matching the given parameter and make it
         // the current selection.
         for (auto& item : listItems()) {
             if (!isHTMLOptionElement(item))
                 continue;
-            if (toHTMLOptionElement(item)->value() == value)
+            if (toHTMLOptionElement(item)->value() == value) {
+                option = toHTMLOptionElement(item);
                 break;
+            }
             optionIndex++;
         }
         if (optionIndex >= static_cast<int>(listItems().size()))
             optionIndex = -1;
     }
 
     int previousSelectedIndex = selectedIndex();
     setSuggestedOption(nullptr);
     if (m_isAutofilledByPreview)
         setAutofilled(false);
     SelectOptionFlags flags = DeselectOtherOptions | MakeOptionDirty;
     if (sendEvents)
         flags |= DispatchInputAndChangeEvent;
-    selectOption(optionIndex, flags);
+    selectOption(option, flags);
 
     if (sendEvents && previousSelectedIndex != selectedIndex() && !usesMenuList())
         listBoxOnChange();
 }
 
 String HTMLSelectElement::suggestedValue() const
 {
     return m_suggestedOption ? m_suggestedOption->value() : "";
 }
 
@@ skipping 553 matching lines @@
         currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
     }
 }
 
 void HTMLSelectElement::resetToDefaultSelection(ResetReason reason)
 {
     // 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 (const auto& option : optionList()) {
         if (option->selected()) {
             if (lastSelectedOption) {
                 lastSelectedOption->setSelectedState(false);
                 didChange = true;
             }
             lastSelectedOption = option;
         }
         if (!firstEnabledOption && !option->isDisabledFormControl()) {
             firstEnabledOption = option;
-            firstEnabledOptionIndex = optionIndex;
             if (reason == ResetReasonSelectedOptionRemoved) {
                 // There must be no selected OPTIONs.
                 break;
             }
         }
         ++optionIndex;
     }
     if (!lastSelectedOption && m_size <= 1 && firstEnabledOption && !firstEnabledOption->selected()) {
-        selectOption(firstEnabledOption, firstEnabledOptionIndex, reason == ResetReasonSelectedOptionRemoved ? 0 : DeselectOtherOptions);
+        selectOption(firstEnabledOption, reason == ResetReasonSelectedOptionRemoved ? 0 : DeselectOtherOptions);
         lastSelectedOption = firstEnabledOption;
         didChange = true;
     }
     if (didChange)
         setNeedsValidityCheck();
     m_lastOnChangeOption = lastSelectedOption;
 }
 
 HTMLOptionElement* HTMLSelectElement::selectedOption() const
 {
@@ skipping 15 matching lines @@
         if (toHTMLOptionElement(*element).selected())
             return index;
         ++index;
     }
 
     return -1;
 }
 
 void HTMLSelectElement::setSelectedIndex(int index)
 {
-    selectOption(index, DeselectOtherOptions | MakeOptionDirty);
+    selectOption(item(index), DeselectOtherOptions | MakeOptionDirty);
 }
 
 void HTMLSelectElement::setSuggestedOption(HTMLOptionElement* option)
 {
     if (m_suggestedOption == option)
         return;
     m_suggestedOption = option;
 
     if (LayoutObject* layoutObject = this->layoutObject())  {
         layoutObject->updateFromElement();
@@ skipping 88 matching lines @@
     setNeedsValidityCheck();
     m_lastOnChangeSelection.clear();
 }
 
 void HTMLSelectElement::hrInsertedOrRemoved(HTMLHRElement& hr)
 {
     setRecalcListItems(hr);
     m_lastOnChangeSelection.clear();
 }
 
-void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
-{
-    selectOption(optionIndex < 0 ? nullptr : item(optionIndex), flags);
-}
-
-void HTMLSelectElement::selectOption(HTMLOptionElement* option, SelectOptionFlags flags)
-{
-    selectOption(option, option ? option->index() : -1, flags);
-}
-
 // TODO(tkent): This function is not efficient.  It contains multiple O(N)
 // operations. crbug.com/577989.
-void HTMLSelectElement::selectOption(HTMLOptionElement* element, int optionIndex, SelectOptionFlags flags)
+void HTMLSelectElement::selectOption(HTMLOptionElement* element, SelectOptionFlags flags)
 {
     TRACE_EVENT0("blink", "HTMLSelectElement::selectOption");
-    ASSERT((!element && optionIndex < 0) || (element && optionIndex >= 0));
 
-    // selectedIndex() is O(N).
-    if (isAutofilled() && selectedIndex() != optionIndex)
+    // selectedOption() is O(N).
+    if (isAutofilled() && selectedOption() != element)
         setAutofilled(false);
 
     if (element) {
         element->setSelectedState(true);
         if (flags & MakeOptionDirty)
             element->setDirty(true);
     }
 
     // deselectItemsWithoutValidation() is O(N).
     if (flags & DeselectOtherOptions)
@@ skipping 196 matching lines @@
             }
         }
     }
 
     setNeedsValidityCheck();
 }
 
 void HTMLSelectElement::parseMultipleAttribute(const AtomicString& value)
 {
     bool oldMultiple = m_multiple;
-    int oldSelectedIndex = selectedIndex();
+    HTMLOptionElement* oldSelectedOption = selectedOption();
     m_multiple = !value.isNull();
     setNeedsValidityCheck();
     lazyReattachIfAttached();
     // Restore selectedIndex after changing the multiple flag to preserve
     // selection as single-line and multi-line has different defaults.
     if (oldMultiple != m_multiple) {
         // Preserving the first selection is compatible with Firefox and
         // WebKit. However Edge seems to "ask for a reset" simply.  As of 2016
         // March, the HTML specification says nothing about this.
-        if (oldSelectedIndex >= 0)
-            selectOption(oldSelectedIndex, DeselectOtherOptions);
+        if (oldSelectedOption)
+            selectOption(oldSelectedOption, DeselectOtherOptions);
         else
             resetToDefaultSelection();
     }
 }
 
 void HTMLSelectElement::appendToFormData(FormData& formData)
 {
     const AtomicString& name = this->name();
     if (name.isEmpty())
         return;
@@ skipping 482 matching lines @@
     if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl())
         return String();
     return toHTMLOptionElement(element)->displayLabel();
 }
 
 void HTMLSelectElement::typeAheadFind(KeyboardEvent* event)
 {
     int index = m_typeAhead.handleEvent(event, TypeAhead::MatchPrefix | TypeAhead::CycleFirstChar);
     if (index < 0)
         return;
-    selectOption(listToOptionIndex(index), DeselectOtherOptions | MakeOptionDirty | DispatchInputAndChangeEvent);
+    HTMLOptionElement* option = nullptr;
+    if (static_cast<size_t>(index) < listItems().size() && isHTMLOptionElement(listItems()[index]))
+        option = toHTMLOptionElement(listItems()[index]);
+    selectOption(option, DeselectOtherOptions | MakeOptionDirty | DispatchInputAndChangeEvent);
     if (!usesMenuList())
         listBoxOnChange();
 }
 
 void HTMLSelectElement::accessKeySetSelectedIndex(int index)
 {
     // First bring into focus the list box.
     if (!focused())
         accessKeyAction(false);
 
-    const ListItems& items = listItems();
-    int listIndex = optionToListIndex(index);
-    if (listIndex < 0)
-        return;
-    HTMLElement& element = *items[listIndex];
-    if (!isHTMLOptionElement(element))
+    HTMLOptionElement* option = item(index);
+    if (!option)
         return;
     EventQueueScope scope;
     // If this index is already selected, unselect. otherwise update the
     // selected index.
     SelectOptionFlags flags = DispatchInputAndChangeEvent | (multiple() ? 0 : DeselectOtherOptions);
-    if (toHTMLOptionElement(element).selected()) {
+    if (option->selected()) {
         if (usesMenuList())
-            selectOption(-1, flags);
+            selectOption(nullptr, flags);
         else
-            toHTMLOptionElement(element).setSelectedState(false);
+            option->setSelectedState(false);
     } else {
-        selectOption(index, flags);
+        selectOption(option, flags);
     }
-    toHTMLOptionElement(element).setDirty(true);
+    option->setDirty(true);
     if (usesMenuList())
         return;
     listBoxOnChange();
     scrollToSelection();
 }
 
 unsigned HTMLSelectElement::length() const
 {
     unsigned options = 0;
     for (auto& item : listItems()) {
@@ skipping 294 matching lines @@
 }
 
 void HTMLSelectElement::didMutateSubtree()
 {
     DCHECK(popupIsVisible());
     DCHECK(m_popup);
     m_popup->updateFromElement(PopupMenu::ByDOMChange);
 }
 
 } // namespace blink