Use C++11 features in core/html

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 222 matching lines @@
 {
     int listIndex = optionToListIndex(optionIndex);
     if (listIndex < 0)
         return;
 
     listItems()[listIndex]->remove(IGNORE_EXCEPTION);
 }
 
 String HTMLSelectElement::value() const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); i++) {
         if (isHTMLOptionElement(items[i]) && toHTMLOptionElement(items[i])->selected())
             return toHTMLOptionElement(items[i])->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;
     if (value.isNull()) {
         optionIndex = -1;
     } else {
         // Find the option with value() matching the given parameter and make it the current selection.
-        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
         for (unsigned i = 0; i < items.size(); i++) {
             if (isHTMLOptionElement(items[i])) {
                 if (toHTMLOptionElement(items[i])->value() == value)
                     break;
                 optionIndex++;
             }
         }
         if (optionIndex >= static_cast<int>(items.size()))
             optionIndex = -1;
     }
 
     int previousSelectedIndex = selectedIndex();
     setSuggestedIndex(-1);
     if (m_isAutofilledByPreview)
         setAutofilled(false);
     setSelectedIndex(optionIndex);
 
     if (sendEvents && previousSelectedIndex != selectedIndex()) {
         if (usesMenuList())
             dispatchInputAndChangeEventForMenuList(false);
         else
             listBoxOnChange();
     }
 }
 
 String HTMLSelectElement::suggestedValue() const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         if (isHTMLOptionElement(items[i]) && m_suggestedIndex >= 0) {
             if (i == static_cast<unsigned>(m_suggestedIndex))
                 return toHTMLOptionElement(items[i])->value();
         }
     }
     return "";
 }
 
 void HTMLSelectElement::setSuggestedValue(const String& value)
 {
     if (value.isNull()) {
         setSuggestedIndex(-1);
         return;
     }
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     unsigned optionIndex = 0;
     for (unsigned i = 0; i < items.size(); ++i) {
         if (isHTMLOptionElement(items[i])) {
             if (toHTMLOptionElement(items[i])->value() == value) {
                 setSuggestedIndex(optionIndex);
                 m_isAutofilledByPreview = true;
                 return;
             }
             optionIndex++;
         }
@@ skipping 175 matching lines @@
 
     if (diff < 0) { // Add dummy elements.
         do {
             RefPtrWillBeRawPtr<Element> option = document().createElement(optionTag, false);
             ASSERT(option);
             add(toHTMLElement(option), 0, exceptionState);
             if (exceptionState.hadException())
                 break;
         } while (++diff);
     } else {
-        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
 
         // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
         // of elements that we intend to remove then attempt to remove them one at a time.
-        WillBeHeapVector<RefPtrWillBeMember<Element> > itemsToRemove;
+        WillBeHeapVector<RefPtrWillBeMember<Element>> itemsToRemove;
         size_t optionIndex = 0;
         for (size_t i = 0; i < items.size(); ++i) {
             Element* item = items[i];
             if (isHTMLOptionElement(items[i]) && optionIndex++ >= newLen) {
                 ASSERT(item->parentNode());
                 itemsToRemove.append(item);
             }
         }
 
         for (size_t i = 0; i < itemsToRemove.size(); ++i) {
@@ skipping 10 matching lines @@
     return isRequired();
 }
 
 // Returns the 1st valid item |skip| items from |listIndex| in direction |direction| if there is one.
 // Otherwise, it returns the valid item closest to that boundary which is past |listIndex| if there is one.
 // Otherwise, it returns |listIndex|.
 // Valid means that it is enabled and an option element.
 int HTMLSelectElement::nextValidIndex(int listIndex, SkipDirection direction, int skip) const
 {
     ASSERT(direction == -1 || direction == 1);
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& listItems = this->listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = this->listItems();
     int lastGoodIndex = listIndex;
     int size = listItems.size();
     for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {
         --skip;
         HTMLElement* element = listItems[listIndex];
         if (!isHTMLOptionElement(*element))
             continue;
         if (toHTMLOptionElement(*element).isDisplayNone())
             continue;
         if (element->isDisabledFormControl())
@@ skipping 14 matching lines @@
 
 int HTMLSelectElement::previousSelectableListIndex(int startIndex) const
 {
     if (startIndex == -1)
         startIndex = listItems().size();
     return nextValidIndex(startIndex, SkipBackwards, 1);
 }
 
 int HTMLSelectElement::firstSelectableListIndex() const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int index = nextValidIndex(items.size(), SkipBackwards, INT_MAX);
     if (static_cast<size_t>(index) == items.size())
         return -1;
     return index;
 }
 
 int HTMLSelectElement::lastSelectableListIndex() const
 {
     return nextValidIndex(-1, SkipForwards, INT_MAX);
 }
 
 // Returns the index of the next valid item one page away from |startIndex| in direction |direction|.
 int HTMLSelectElement::nextSelectableListIndexPageAway(int startIndex, SkipDirection direction) const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     // Can't use m_size because renderer forces a minimum size.
     int pageSize = 0;
     if (renderer()->isListBox())
         pageSize = toRenderListBox(renderer())->size() - 1; // -1 so we still show context.
 
     // One page away, but not outside valid bounds.
     // If there is a valid option item one page away, the index is chosen.
     // If there is no exact one page away valid option, returns startIndex or the most far index.
     int edgeIndex = (direction == SkipForwards) ? 0 : (items.size() - 1);
     int skipAmount = pageSize + ((direction == SkipForwards) ? startIndex : (edgeIndex - startIndex));
@@ skipping 20 matching lines @@
 }
 
 void HTMLSelectElement::saveLastSelection()
 {
     if (usesMenuList()) {
         m_lastOnChangeIndex = selectedIndex();
         return;
     }
 
     m_lastOnChangeSelection.clear();
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         m_lastOnChangeSelection.append(isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected());
     }
 }
 
 void HTMLSelectElement::setActiveSelectionAnchorIndex(int index)
 {
     m_activeSelectionAnchorIndex = index;
 
     // Cache the selection state so we can restore the old selection as the new
     // selection pivots around this anchor index.
     m_cachedStateForActiveSelection.clear();
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         m_cachedStateForActiveSelection.append(isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected());
     }
 }
 
 void HTMLSelectElement::setActiveSelectionEndIndex(int index)
 {
     if (index == m_activeSelectionEndIndex)
         return;
     m_activeSelectionEndIndex = index;
     setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Control));
 }
 
 void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions, bool scroll)
 {
     ASSERT(renderer() && (renderer()->isListBox() || m_multiple));
     ASSERT(!listItems().size() || m_activeSelectionAnchorIndex >= 0);
 
     unsigned start = std::min(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
     unsigned end = std::max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl() || !toHTMLOptionElement(element)->renderer())
             continue;
 
         if (i >= start && i <= end)
             toHTMLOptionElement(element)->setSelectedState(m_activeSelectionState);
         else if (deselectOtherOptions || i >= m_cachedStateForActiveSelection.size())
             toHTMLOptionElement(element)->setSelectedState(false);
         else
             toHTMLOptionElement(element)->setSelectedState(m_cachedStateForActiveSelection[i]);
     }
 
     setNeedsValidityCheck();
     if (scroll)
         scrollToSelection();
     notifyFormStateChanged();
 }
 
 void HTMLSelectElement::listBoxOnChange()
 {
     ASSERT(!usesMenuList() || m_multiple);
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
 
     // If the cached selection list is empty, or the size has changed, then fire
     // dispatchFormControlChangeEvent, and return early.
     // FIXME: Why? This looks unreasonable.
     if (m_lastOnChangeSelection.isEmpty() || m_lastOnChangeSelection.size() != items.size()) {
         dispatchFormControlChangeEvent();
         return;
     }
 
     // Update m_lastOnChangeSelection and fire dispatchFormControlChangeEvent.
@@ skipping 39 matching lines @@
 }
 
 void HTMLSelectElement::setOptionsChangedOnRenderer()
 {
     if (RenderObject* renderer = this->renderer()) {
         if (usesMenuList())
             toRenderMenuList(renderer)->setOptionsChanged(true);
     }
 }
 
-const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& HTMLSelectElement::listItems() const
+const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
 #if ENABLE(ASSERT)
-        WillBeHeapVector<RawPtrWillBeMember<HTMLElement> > items = m_listItems;
+        WillBeHeapVector<RawPtrWillBeMember<HTMLElement>> items = m_listItems;
         recalcListItems(false);
         ASSERT(items == m_listItems);
 #endif
     }
 
     return m_listItems;
 }
 
 void HTMLSelectElement::invalidateSelectedItems()
 {
@@ skipping 82 matching lines @@
 
     if (!foundSelected && m_size <= 1 && firstOption && !firstOption->selected())
         firstOption->setSelectedState(true);
 }
 
 int HTMLSelectElement::selectedIndex() const
 {
     unsigned index = 0;
 
     // Return the number of the first option selected.
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (size_t i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         if (isHTMLOptionElement(*element)) {
             if (toHTMLOptionElement(*element).selected())
                 return index;
             ++index;
         }
     }
 
     return -1;
@@ skipping 18 matching lines @@
         scrollTo(suggestedIndex);
     }
 }
 
 void HTMLSelectElement::scrollTo(int listIndex)
 {
     if (listIndex < 0)
         return;
     if (usesMenuList())
         return;
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int listSize = static_cast<int>(items.size());
     if (listIndex >= listSize)
         return;
     document().updateLayoutIgnorePendingStylesheets();
     if (!renderer() || !renderer()->isListBox())
         return;
     LayoutRect bounds = items[listIndex]->boundingBox();
     toRenderListBox(renderer())->scrollToRect(bounds);
 }
 
@@ skipping 18 matching lines @@
     if (listIndex <= m_activeSelectionEndIndex)
         m_activeSelectionEndIndex--;
     if (listIndex == selectedIndex())
         setAutofilled(false);
 }
 
 void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
 {
     bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int listIndex = optionToListIndex(optionIndex);
 
     if (selectedIndex() != optionIndex && isAutofilled())
         setAutofilled(false);
 
     HTMLElement* element = 0;
     if (listIndex >= 0) {
         element = items[listIndex];
         if (isHTMLOptionElement(*element)) {
             if (m_activeSelectionAnchorIndex < 0 || shouldDeselect)
@@ skipping 27 matching lines @@
                     cache->selectedChildrenChanged(this);
             }
         }
     }
 
     notifyFormStateChanged();
 }
 
 int HTMLSelectElement::optionToListIndex(int optionIndex) const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int listSize = static_cast<int>(items.size());
     if (optionIndex < 0 || optionIndex >= listSize)
         return -1;
 
     int optionIndex2 = -1;
     for (int listIndex = 0; listIndex < listSize; ++listIndex) {
         if (isHTMLOptionElement(*items[listIndex])) {
             ++optionIndex2;
             if (optionIndex2 == optionIndex)
                 return listIndex;
         }
     }
 
     return -1;
 }
 
 int HTMLSelectElement::listToOptionIndex(int listIndex) const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !isHTMLOptionElement(*items[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;
     }
 
@@ skipping 14 matching lines @@
     // We only need to fire change events here for menu lists, because we fire
     // change events for list boxes whenever the selection change is actually made.
     // This matches other browsers' behavior.
     if (usesMenuList())
         dispatchInputAndChangeEventForMenuList();
     HTMLFormControlElementWithState::dispatchBlurEvent(newFocusedElement);
 }
 
 void HTMLSelectElement::deselectItemsWithoutValidation(HTMLElement* excludeElement)
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         if (element != excludeElement && isHTMLOptionElement(*element))
             toHTMLOptionElement(element)->setSelectedState(false);
     }
 }
 
 FormControlState HTMLSelectElement::saveFormControlState() const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     size_t length = items.size();
     FormControlState state;
     for (unsigned i = 0; i < length; ++i) {
         if (!isHTMLOptionElement(*items[i]))
             continue;
         HTMLOptionElement* option = toHTMLOptionElement(items[i]);
         if (!option->selected())
             continue;
         state.append(option->value());
         state.append(String::number(i));
         if (!multiple())
             break;
     }
     return state;
 }
 
 size_t HTMLSelectElement::searchOptionsForValue(const String& value, size_t listIndexStart, size_t listIndexEnd) const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     size_t loopEndIndex = std::min(items.size(), listIndexEnd);
     for (size_t i = listIndexStart; i < loopEndIndex; ++i) {
         if (!isHTMLOptionElement(items[i]))
             continue;
         if (toHTMLOptionElement(items[i])->value() == value)
             return i;
     }
     return kNotFound;
 }
 
 void HTMLSelectElement::restoreFormControlState(const FormControlState& state)
 {
     recalcListItems();
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     size_t itemsSize = items.size();
     if (!itemsSize)
         return;
 
     for (size_t i = 0; i < itemsSize; ++i) {
         if (!isHTMLOptionElement(items[i]))
             continue;
         toHTMLOptionElement(items[i])->setSelectedState(false);
     }
 
@@ skipping 40 matching lines @@
     lazyReattachIfAttached();
 }
 
 bool HTMLSelectElement::appendFormData(FormDataList& list, bool)
 {
     const AtomicString& name = this->name();
     if (name.isEmpty())
         return false;
 
     bool successful = false;
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
 
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         if (isHTMLOptionElement(*element) && toHTMLOptionElement(*element).selected() && !toHTMLOptionElement(*element).isDisabledFormControl()) {
             list.appendData(name, toHTMLOptionElement(*element).value());
             successful = true;
         }
     }
 
     // It's possible that this is a menulist with multiple options and nothing
     // will be submitted (!successful). We won't send a unselected non-disabled
     // option as fallback. This behavior matches to other browsers.
     return successful;
 }
 
 void HTMLSelectElement::resetImpl()
 {
     HTMLOptionElement* firstOption = 0;
     HTMLOptionElement* selectedOption = 0;
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         if (!isHTMLOptionElement(*element))
             continue;
 
         if (items[i]->fastHasAttribute(selectedAttr)) {
             if (selectedOption && !m_multiple)
                 selectedOption->setSelectedState(false);
             toHTMLOptionElement(element)->setSelectedState(true);
             selectedOption = toHTMLOptionElement(element);
@@ skipping 76 matching lines @@
             if (!m_activeSelectionState)
                 return;
         }
 
         // The key handling below shouldn't be used for non spatial navigation mode Mac
         if (RenderTheme::theme().popsMenuByArrowKeys() && !isSpatialNavigationEnabled(document().frame()))
             return;
 
         const String& keyIdentifier = keyEvent->keyIdentifier();
         bool handled = true;
-        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& listItems = this->listItems();
+        const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = this->listItems();
         int listIndex = optionToListIndex(selectedIndex());
 
         if (keyIdentifier == "Down" || keyIdentifier == "Right")
             listIndex = nextValidIndex(listIndex, SkipForwards, 1);
         else if (keyIdentifier == "Up" || keyIdentifier == "Left")
             listIndex = nextValidIndex(listIndex, SkipBackwards, 1);
         else if (keyIdentifier == "PageDown")
             listIndex = nextValidIndex(listIndex, SkipForwards, 3);
         else if (keyIdentifier == "PageUp")
             listIndex = nextValidIndex(listIndex, SkipBackwards, 3);
@@ skipping 121 matching lines @@
 int HTMLSelectElement::listIndexForEventTargetOption(const Event& event)
 {
     Node* targetNode = event.target()->toNode();
     if (!targetNode || !isHTMLOptionElement(*targetNode))
         return -1;
     return listIndexForOption(toHTMLOptionElement(*targetNode));
 }
 
 int HTMLSelectElement::listIndexForOption(const HTMLOptionElement& option)
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = this->listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = this->listItems();
     size_t length = items.size();
     for (size_t i = 0; i < length; ++i) {
         if (items[i].get() == &option)
             return i;
     }
     return -1;
 }
 
 AutoscrollController* HTMLSelectElement::autoscrollController() const
 {
     if (Page* page = document().page())
         return &page->autoscrollController();
     return 0;
 }
 
 void HTMLSelectElement::handleMouseRelease()
 {
     // We didn't start this click/drag on any options.
     if (m_lastOnChangeSelection.isEmpty())
         return;
     listBoxOnChange();
 }
 
 void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& listItems = this->listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = this->listItems();
     if (event->type() == EventTypeNames::gesturetap && event->isGestureEvent()) {
         focus();
         // Calling focus() may cause us to lose our renderer or change the render type, in which case do not want to handle the event.
         if (!renderer() || !renderer()->isListBox())
             return;
 
         // Convert to coords relative to the list box if needed.
         GestureEvent& gestureEvent = toGestureEvent(*event);
         int listIndex = listIndexForEventTargetOption(gestureEvent);
         if (listIndex >= 0) {
@@ skipping 180 matching lines @@
             typeAheadFind(keyboardEvent);
             event->setDefaultHandled();
             return;
         }
     }
     HTMLFormControlElementWithState::defaultEventHandler(event);
 }
 
 int HTMLSelectElement::lastSelectedListIndex() const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (size_t i = items.size(); i;) {
         HTMLElement* element = items[--i];
         if (isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected())
             return i;
     }
     return -1;
 }
 
 int HTMLSelectElement::indexOfSelectedOption() const
 {
     return optionToListIndex(selectedIndex());
 }
 
 int HTMLSelectElement::optionCount() const
 {
     return listItems().size();
 }
 
 String HTMLSelectElement::optionAtIndex(int index) const
 {
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
 
     HTMLElement* element = items[index];
     if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl())
         return String();
     return toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
 }
 
 void HTMLSelectElement::typeAheadFind(KeyboardEvent* event)
 {
     int index = m_typeAhead.handleEvent(event, TypeAhead::MatchPrefix | TypeAhead::CycleFirstChar);
@@ skipping 14 matching lines @@
     return InsertionDone;
 }
 
 void HTMLSelectElement::accessKeySetSelectedIndex(int index)
 {
     // First bring into focus the list box.
     if (!focused())
         accessKeyAction(false);
 
     // If this index is already selected, unselect. otherwise update the selected index.
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int listIndex = optionToListIndex(index);
     if (listIndex >= 0) {
         HTMLElement* element = items[listIndex];
         if (isHTMLOptionElement(*element)) {
             if (toHTMLOptionElement(*element).selected())
                 toHTMLOptionElement(*element).setSelectedState(false);
             else
                 selectOption(index, DispatchInputAndChangeEvent | UserDriven);
         }
     }
 
     if (usesMenuList())
         dispatchInputAndChangeEventForMenuList();
     else
         listBoxOnChange();
 
     scrollToSelection();
 }
 
 unsigned HTMLSelectElement::length() const
 {
     unsigned options = 0;
 
-    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         if (isHTMLOptionElement(*items[i]))
             ++options;
     }
 
     return options;
 }
 
 void HTMLSelectElement::finishParsingChildren()
 {
@@ skipping 50 matching lines @@
     int focusedIndex = activeSelectionEndListIndex();
     if (focusedIndex < 0)
         focusedIndex = firstSelectableListIndex();
     if (focusedIndex < 0)
         return nullptr;
     HTMLElement* focused = listItems()[focusedIndex];
     return isHTMLOptionElement(focused) ? toHTMLOptionElement(focused) : nullptr;
 }
 
 } // namespace