SELECT element: Introduce HTMLSelectElement::optionAtListIndex().

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 171 matching lines @@
         return String();
     return validationMessage();
 }
 
 void HTMLSelectElement::selectMultipleOptionsByPopup(const Vector<int>& listIndices)
 {
     DCHECK(usesMenuList());
     DCHECK(!multiple());
     for (size_t i = 0; i < listIndices.size(); ++i) {
         bool addSelectionIfNotFirst = i > 0;
-        HTMLElement* element = listItems()[listIndices[i]];
-        if (isHTMLOptionElement(element))
-            updateSelectedState(toHTMLOptionElement(element), addSelectionIfNotFirst, false);
+        if (HTMLOptionElement* option = optionAtListIndex(listIndices[i]))
+            updateSelectedState(option, addSelectionIfNotFirst, false);
     }
     setNeedsValidityCheck();
     // TODO(tkent): Using listBoxOnChange() is very confusing.
     listBoxOnChange();
 }
 
 bool HTMLSelectElement::usesMenuList() const
 {
     if (LayoutTheme::theme().delegatesMenuListRendering())
         return true;
@@ skipping 269 matching lines @@
         }
     }
     setNeedsValidityCheck();
 }
 
 bool HTMLSelectElement::isRequiredFormControl() const
 {
     return isRequired();
 }
 
+HTMLOptionElement* HTMLSelectElement::optionAtListIndex(int listIndex) const
+{
+    if (listIndex < 0)
+        return nullptr;
+    const ListItems& items = listItems();
+    if (static_cast<size_t>(listIndex) >= items.size() || !isHTMLOptionElement(items[listIndex]))
+        return nullptr;
+    return toHTMLOptionElement(items[listIndex]);
+}
+
 // Returns the 1st valid OPTION |skip| items from |listIndex| in direction
 // |direction| if there is one.
 // Otherwise, it returns the valid OPTION closest to that boundary which is past
 // |listIndex| if there is one.
 // Otherwise, it returns nullptr.
 // Valid means that it is enabled and visible.
 HTMLOptionElement* HTMLSelectElement::nextValidOption(int listIndex, SkipDirection direction, int skip) const
 {
     ASSERT(direction == SkipBackwards || direction == SkipForwards);
     const ListItems& listItems = this->listItems();
@@ skipping 557 matching lines @@
                 return listIndex;
         }
     }
 
     return -1;
 }
 
 int HTMLSelectElement::listToOptionIndex(int listIndex) const
 {
     const ListItems& items = listItems();
-    if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !isHTMLOptionElement(*items[listIndex]))
+    if (!optionAtListIndex(listIndex))
         return -1;
 
     // Actual index of option not counting OPTGROUP entries that may be in list.
     int optionIndex = 0;
     for (int i = 0; i < listIndex; ++i) {
         if (isHTMLOptionElement(*items[i]))
             ++optionIndex;
     }
 
     return optionIndex;
@@ skipping 595 matching lines @@
             return;
         }
     }
     HTMLFormControlElementWithState::defaultEventHandler(event);
 }
 
 HTMLOptionElement* HTMLSelectElement::lastSelectedOption() const
 {
     const ListItems& items = listItems();
     for (size_t i = items.size(); i;) {
-        HTMLElement* element = items[--i];
-        if (isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected())
-            return toHTMLOptionElement(element);
+        if (HTMLOptionElement* option = optionAtListIndex(--i)) {
+            if (option->selected())
+                return option;
+        }
     }
     return nullptr;
 }
 
 int HTMLSelectElement::indexOfSelectedOption() const
 {
     return optionToListIndex(selectedIndex());
 }
 
 int HTMLSelectElement::optionCount() const
 {
     return listItems().size();
 }
 
 String HTMLSelectElement::optionAtIndex(int index) const
 {
-    const ListItems& items = listItems();
-    HTMLElement* element = items[index];
-    if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl())
-        return String();
-    return toHTMLOptionElement(element)->displayLabel();
+    if (HTMLOptionElement* option = optionAtListIndex(index)) {
+        if (!option->isDisabledFormControl())
+            return option->displayLabel();
+    }
+    return String();
 }
 
 void HTMLSelectElement::typeAheadFind(KeyboardEvent* event)
 {
     int index = m_typeAhead.handleEvent(event, TypeAhead::MatchPrefix | TypeAhead::CycleFirstChar);
     if (index < 0)
         return;
-    HTMLOptionElement* option = nullptr;
-    if (static_cast<size_t>(index) < listItems().size() && isHTMLOptionElement(listItems()[index]))
-        option = toHTMLOptionElement(listItems()[index]);
-    selectOption(option, DeselectOtherOptions | MakeOptionDirty | DispatchInputAndChangeEvent);
+    selectOption(optionAtListIndex(index), DeselectOtherOptions | MakeOptionDirty | DispatchInputAndChangeEvent);
     if (!usesMenuList())
         listBoxOnChange();
 }
 
 void HTMLSelectElement::accessKeySetSelectedIndex(int index)
 {
     // First bring into focus the list box.
     if (!focused())
         accessKeyAction(false);
 
@@ skipping 159 matching lines @@
 
 void HTMLSelectElement::setIndexToSelectOnCancel(int listIndex)
 {
     m_indexToSelectOnCancel = listIndex;
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 HTMLOptionElement* HTMLSelectElement::optionToBeShown() const
 {
-    if (m_indexToSelectOnCancel >= 0 && static_cast<size_t>(m_indexToSelectOnCancel) < listItems().size() && isHTMLOptionElement(listItems()[m_indexToSelectOnCancel]))
-        return toHTMLOptionElement(listItems()[m_indexToSelectOnCancel]);
+    if (HTMLOptionElement* option = optionAtListIndex(m_indexToSelectOnCancel))
+        return option;
     if (m_suggestedOption)
         return m_suggestedOption;
     // TODO(tkent): We should not call optionToBeShown() in multiple() case.
     if (multiple())
         return selectedOption();
     DCHECK_EQ(selectedOption(), m_lastOnChangeOption);
     return m_lastOnChangeOption;
 }
 
 void HTMLSelectElement::selectOptionByPopup(int listIndex)
 {
     DCHECK(usesMenuList());
     // Check to ensure a page navigation has not occurred while the popup was
     // up.
     Document& doc = document();
     if (&doc != doc.frame()->document())
         return;
 
     setIndexToSelectOnCancel(-1);
 
-    HTMLOptionElement* option = nullptr;
-    if (listIndex >= 0 && isHTMLOptionElement(listItems()[listIndex]))
-        option = toHTMLOptionElement(listItems()[listIndex]);
+    HTMLOptionElement* option = optionAtListIndex(listIndex);
     // 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 (option == selectedOption())
         return;
     selectOption(option, DeselectOtherOptions | MakeOptionDirty | DispatchInputAndChangeEvent);
 }
@@ skipping 132 matching lines @@
 }
 
 void HTMLSelectElement::didMutateSubtree()
 {
     DCHECK(popupIsVisible());
     DCHECK(m_popup);
     m_popup->updateFromElement(PopupMenu::ByDOMChange);
 }
 
 } // namespace blink