Rename renderer() to layoutObject().

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 339 matching lines @@
             lazyReattachIfAttached();
             setRecalcListItems();
         }
     } else if (name == multipleAttr)
         parseMultipleAttribute(value);
     else if (name == accesskeyAttr) {
         // FIXME: ignore for the moment.
         //
     } else if (name == disabledAttr) {
         HTMLFormControlElementWithState::parseAttribute(name, value);
-        if (renderer() && renderer()->isMenuList()) {
-            if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
+        if (layoutObject() && layoutObject()->isMenuList()) {
+            if (LayoutMenuList* menuList = toLayoutMenuList(layoutObject())) {
                 if (menuList->popupIsVisible())
                     menuList->hidePopup();
             }
         }
 
     } else
         HTMLFormControlElementWithState::parseAttribute(name, value);
 }
 
 bool HTMLSelectElement::shouldShowFocusRingOnMouseFocus() const
@@ skipping 39 matching lines @@
     m_lastOnChangeSelection.clear();
 
     HTMLFormControlElementWithState::childrenChanged(change);
 }
 
 void HTMLSelectElement::optionElementChildrenChanged()
 {
     setRecalcListItems();
     setNeedsValidityCheck();
 
-    if (renderer()) {
-        if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
+    if (layoutObject()) {
+        if (AXObjectCache* cache = layoutObject()->document().existingAXObjectCache())
             cache->childrenChanged(this);
     }
 }
 
 void HTMLSelectElement::accessKeyAction(bool sendMouseEvents)
 {
     focus();
     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
 }
 
@@ skipping 101 matching lines @@
     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())
             continue;
-        if (!usesMenuList() && !element->renderer())
+        if (!usesMenuList() && !element->layoutObject())
             continue;
         lastGoodIndex = listIndex;
         if (skip <= 0)
             break;
     }
     return lastGoodIndex;
 }
 
 int HTMLSelectElement::nextSelectableListIndex(int startIndex) const
 {
@@ skipping 20 matching lines @@
 {
     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();
     // Can't use m_size because renderer forces a minimum size.
     int pageSize = 0;
-    if (renderer()->isListBox())
-        pageSize = toLayoutListBox(renderer())->size() - 1; // -1 so we still show context.
+    if (layoutObject()->isListBox())
+        pageSize = toLayoutListBox(layoutObject())->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));
     return nextValidIndex(edgeIndex, direction, skipAmount);
 }
 
 void HTMLSelectElement::selectAll()
 {
     ASSERT(!usesMenuList());
-    if (!renderer() || !m_multiple)
+    if (!layoutObject() || !m_multiple)
         return;
 
     // Save the selection so it can be compared to the new selectAll selection
     // when dispatching change events.
     saveLastSelection();
 
     m_activeSelectionState = true;
     setActiveSelectionAnchorIndex(nextSelectableListIndex(-1));
     setActiveSelectionEndIndex(previousSelectableListIndex(-1));
 
@@ skipping 35 matching lines @@
 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(layoutObject() && (layoutObject()->isListBox() || m_multiple));
 
     int start = std::min(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
     int end = std::max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
 
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     for (int i = 0; i < static_cast<int>(items.size()); ++i) {
         HTMLElement* element = items[i];
-        if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl() || !toHTMLOptionElement(element)->renderer())
+        if (!isHTMLOptionElement(*element) || toHTMLOptionElement(element)->isDisabledFormControl() || !toHTMLOptionElement(element)->layoutObject())
             continue;
 
         if (i >= start && i <= end)
             toHTMLOptionElement(element)->setSelectedState(m_activeSelectionState);
         else if (deselectOtherOptions || i >= static_cast<int>(m_cachedStateForActiveSelection.size()))
             toHTMLOptionElement(element)->setSelectedState(false);
         else
             toHTMLOptionElement(element)->setSelectedState(m_cachedStateForActiveSelection[i]);
     }
 
@@ skipping 54 matching lines @@
         return;
     if (usesMenuList())
         return;
     scrollToIndex(activeSelectionEndListIndex());
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->selectedChildrenChanged(this);
 }
 
 void HTMLSelectElement::setOptionsChangedOnRenderer()
 {
-    if (LayoutObject* renderer = this->renderer()) {
+    if (LayoutObject* renderer = this->layoutObject()) {
         if (usesMenuList())
             toLayoutMenuList(renderer)->setOptionsChanged(true);
     }
 }
 
 const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
@@ skipping 23 matching lines @@
     m_activeSelectionAnchorIndex = -1;
     setOptionsChangedOnRenderer();
     setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::ControlValue));
     if (!inDocument()) {
         if (HTMLOptionsCollection* collection = cachedCollection<HTMLOptionsCollection>(SelectOptions))
             collection->invalidateCache();
     }
     if (!inDocument())
         invalidateSelectedItems();
 
-    if (renderer()) {
-        if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
+    if (layoutObject()) {
+        if (AXObjectCache* cache = layoutObject()->document().existingAXObjectCache())
             cache->childrenChanged(this);
     }
 }
 
 void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
 {
     m_listItems.clear();
 
     m_shouldRecalcListItems = false;
 
@@ skipping 76 matching lines @@
 
 int HTMLSelectElement::suggestedIndex() const
 {
     return m_suggestedIndex;
 }
 
 void HTMLSelectElement::setSuggestedIndex(int suggestedIndex)
 {
     m_suggestedIndex = suggestedIndex;
 
-    if (LayoutObject* renderer = this->renderer())  {
+    if (LayoutObject* renderer = this->layoutObject())  {
         renderer->updateFromElement();
         scrollToIndex(suggestedIndex);
     }
 }
 
 void HTMLSelectElement::scrollToIndex(int listIndex)
 {
     if (listIndex < 0)
         return;
     if (usesMenuList())
         return;
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
     int listSize = static_cast<int>(items.size());
     if (listIndex >= listSize)
         return;
     document().updateLayoutIgnorePendingStylesheets();
-    if (!renderer() || !renderer()->isListBox())
+    if (!layoutObject() || !layoutObject()->isListBox())
         return;
     LayoutRect bounds = items[listIndex]->boundingBox();
-    toLayoutListBox(renderer())->scrollToRect(bounds);
+    toLayoutListBox(layoutObject())->scrollToRect(bounds);
 }
 
 void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
 {
     ASSERT(option->ownerSelectElement() == this);
     if (optionIsSelected)
         selectOption(option->index());
     else if (!usesMenuList() || multiple())
         selectOption(-1);
     else
@@ skipping 39 matching lines @@
             if (m_activeSelectionEndIndex < 0 || shouldDeselect)
                 setActiveSelectionEndIndex(listIndex);
             toHTMLOptionElement(*element).setSelectedState(true);
         }
     }
 
     if (shouldDeselect)
         deselectItemsWithoutValidation(element);
 
     // For the menu list case, this is what makes the selected element appear.
-    if (LayoutObject* renderer = this->renderer())
+    if (LayoutObject* renderer = this->layoutObject())
         renderer->updateFromElement();
 
     scrollToSelection();
     setNeedsValidityCheck();
 
     if (usesMenuList()) {
         m_isProcessingUserDrivenChange = flags & UserDriven;
         if (flags & DispatchInputAndChangeEvent)
             dispatchInputAndChangeEventForMenuList();
-        if (LayoutObject* renderer = this->renderer()) {
+        if (LayoutObject* renderer = this->layoutObject()) {
             if (usesMenuList()) {
                 toLayoutMenuList(renderer)->didSetSelectedIndex(listIndex);
             } else if (renderer->isListBox()) {
                 if (AXObjectCache* cache = document().existingAXObjectCache())
                     cache->selectedChildrenChanged(this);
             }
         }
     }
 
     notifyFormStateChanged();
@@ skipping 206 matching lines @@
     setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::ControlValue));
     setNeedsValidityCheck();
 }
 
 void HTMLSelectElement::handlePopupOpenKeyboardEvent(Event* event)
 {
     focus();
     // Calling focus() may cause us to lose our renderer. Return true so
     // that our caller doesn't process the event further, but don't set
     // the event as handled.
-    if (!renderer() || !renderer()->isMenuList() || isDisabledFormControl())
+    if (!layoutObject() || !layoutObject()->isMenuList() || isDisabledFormControl())
         return;
     // Save the selection so it can be compared to the new selection
     // when dispatching change events during selectOption, which
     // gets called from LayoutMenuList::valueChanged, which gets called
     // after the user makes a selection from the menu.
     saveLastSelection();
-    if (LayoutMenuList* menuList = toLayoutMenuList(renderer()))
+    if (LayoutMenuList* menuList = toLayoutMenuList(layoutObject()))
         menuList->showPopup();
     event->setDefaultHandled();
     return;
 }
 
 bool HTMLSelectElement::shouldOpenPopupForKeyDownEvent(KeyboardEvent* keyEvent)
 {
     const String& keyIdentifier = keyEvent->keyIdentifier();
     LayoutTheme& layoutTheme = LayoutTheme::theme();
 
@@ skipping 10 matching lines @@
     LayoutTheme& layoutTheme = LayoutTheme::theme();
     int keyCode = event->keyCode();
 
     return ((layoutTheme.popsMenuBySpaceKey() && event->keyCode() == ' ')
         || (layoutTheme.popsMenuByReturnKey() && keyCode == '\r'));
 }
 
 void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
 {
     if (event->type() == EventTypeNames::keydown) {
-        if (!renderer() || !event->isKeyboardEvent())
+        if (!layoutObject() || !event->isKeyboardEvent())
             return;
 
         KeyboardEvent* keyEvent = toKeyboardEvent(event);
         if (shouldOpenPopupForKeyDownEvent(keyEvent)) {
             handlePopupOpenKeyboardEvent(event);
             return;
         }
 
         // When using spatial navigation, we want to be able to navigate away
         // from the select element when the user hits any of the arrow keys,
@@ skipping 28 matching lines @@
             handled = false;
 
         if (handled && static_cast<size_t>(listIndex) < listItems.size())
             selectOption(listToOptionIndex(listIndex), DeselectOtherOptions | DispatchInputAndChangeEvent | UserDriven);
 
         if (handled)
             event->setDefaultHandled();
     }
 
     if (event->type() == EventTypeNames::keypress) {
-        if (!renderer() || !event->isKeyboardEvent())
+        if (!layoutObject() || !event->isKeyboardEvent())
             return;
 
         int keyCode = toKeyboardEvent(event)->keyCode();
         if (keyCode == ' ' && isSpatialNavigationEnabled(document().frame())) {
             // Use space to toggle arrow key handling for selection change or spatial navigation.
             m_activeSelectionState = !m_activeSelectionState;
             event->setDefaultHandled();
             return;
         }
 
         KeyboardEvent* keyEvent = toKeyboardEvent(event);
         if (shouldOpenPopupForKeyPressEvent(keyEvent)) {
             handlePopupOpenKeyboardEvent(event);
             return;
         }
 
         if (!LayoutTheme::theme().popsMenuByReturnKey() && keyCode == '\r') {
             if (form())
                 form()->submitImplicitly(event, false);
             dispatchInputAndChangeEventForMenuList();
             event->setDefaultHandled();
         }
     }
 
     if (event->type() == EventTypeNames::mousedown && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton) {
         focus();
-        if (renderer() && renderer()->isMenuList() && !isDisabledFormControl()) {
-            if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
+        if (layoutObject() && layoutObject()->isMenuList() && !isDisabledFormControl()) {
+            if (LayoutMenuList* menuList = toLayoutMenuList(layoutObject())) {
                 if (menuList->popupIsVisible())
                     menuList->hidePopup();
                 else {
                     // Save the selection so it can be compared to the new
                     // selection when we call onChange during selectOption,
                     // which gets called from LayoutMenuList::valueChanged,
                     // which gets called after the user makes a selection from
                     // the menu.
                     saveLastSelection();
                     menuList->showPopup();
                 }
             }
         }
         event->setDefaultHandled();
     }
 
     if (event->type() == EventTypeNames::blur) {
-        if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
+        if (LayoutMenuList* menuList = toLayoutMenuList(layoutObject())) {
             if (menuList->popupIsVisible())
                 menuList->hidePopup();
         }
     }
 }
 
 void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shift)
 {
     ASSERT(listIndex >= 0);
 
@@ skipping 79 matching lines @@
         return;
     listBoxOnChange();
 }
 
 void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
 {
     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())
+        if (!layoutObject() || !layoutObject()->isListBox())
             return;
 
         // Convert to coords relative to the list box if needed.
         GestureEvent& gestureEvent = toGestureEvent(*event);
         int listIndex = listIndexForEventTargetOption(gestureEvent);
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
                 updateSelectedState(listIndex, true, gestureEvent.shiftKey());
                 listBoxOnChange();
             }
             event->setDefaultHandled();
         }
     } else if (event->type() == EventTypeNames::mousedown && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton) {
         focus();
         // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event.
-        if (!renderer() || !renderer()->isListBox() || isDisabledFormControl())
+        if (!layoutObject() || !layoutObject()->isListBox() || isDisabledFormControl())
             return;
 
         // Convert to coords relative to the list box if needed.
         MouseEvent* mouseEvent = toMouseEvent(event);
         int listIndex = listIndexForEventTargetOption(*mouseEvent);
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
 #if OS(MACOSX)
                 updateSelectedState(listIndex, mouseEvent->metaKey(), mouseEvent->shiftKey());
 #else
                 updateSelectedState(listIndex, mouseEvent->ctrlKey(), mouseEvent->shiftKey());
 #endif
             }
             if (LocalFrame* frame = document().frame())
                 frame->eventHandler().setMouseDownMayStartAutoscroll();
 
             event->setDefaultHandled();
         }
     } else if (event->type() == EventTypeNames::mousemove && event->isMouseEvent()) {
         MouseEvent* mouseEvent = toMouseEvent(event);
         if (mouseEvent->button() != LeftButton || !mouseEvent->buttonDown())
             return;
 
         if (Page* page = document().page())
-            page->autoscrollController().startAutoscrollForSelection(renderer());
+            page->autoscrollController().startAutoscrollForSelection(layoutObject());
 
         int listIndex = listIndexForEventTargetOption(*mouseEvent);
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
                 if (m_multiple) {
                     // Only extend selection if there is something selected.
                     if (m_activeSelectionAnchorIndex < 0)
                         return;
 
                     setActiveSelectionEndIndex(listIndex);
                     updateListBoxSelection(false);
                 } else {
                     setActiveSelectionAnchorIndex(listIndex);
                     setActiveSelectionEndIndex(listIndex);
                     updateListBoxSelection(true);
                 }
             }
         }
-    } else if (event->type() == EventTypeNames::mouseup && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton && renderer()) {
-        if (document().page() && document().page()->autoscrollController().autoscrollInProgress(toLayoutBox(renderer())))
+    } else if (event->type() == EventTypeNames::mouseup && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton && layoutObject()) {
+        if (document().page() && document().page()->autoscrollController().autoscrollInProgress(toLayoutBox(layoutObject())))
             document().page()->autoscrollController().stopAutoscroll();
         else
             handleMouseRelease();
     } else if (event->type() == EventTypeNames::keydown) {
         if (!event->isKeyboardEvent())
             return;
         const String& keyIdentifier = toKeyboardEvent(event)->keyIdentifier();
 
         bool handled = false;
         int endIndex = 0;
@@ skipping 87 matching lines @@
             m_activeSelectionState = !m_activeSelectionState;
             updateSelectedState(listToOptionIndex(m_activeSelectionEndIndex), true /*multi*/, false /*shift*/);
             listBoxOnChange();
             event->setDefaultHandled();
         }
     }
 }
 
 void HTMLSelectElement::defaultEventHandler(Event* event)
 {
-    if (!renderer())
+    if (!layoutObject())
         return;
 
     if (isDisabledFormControl()) {
         HTMLFormControlElementWithState::defaultEventHandler(event);
         return;
     }
 
     if (usesMenuList())
         menuListDefaultEventHandler(event);
     else
@@ skipping 158 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