Update renderer to layoutObject 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 562 matching lines @@
 
 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();
-    // Can't use m_size because renderer forces a minimum size.
+    // Can't use m_size because layoutObject forces a minimum size.
     int pageSize = 0;
     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);
@@ skipping 132 matching lines @@
 {
     if (!isFinishedParsingChildren())
         return;
     if (usesMenuList())
         return;
     scrollToIndex(activeSelectionEndListIndex());
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->listboxActiveIndexChanged(this);
 }
 
-void HTMLSelectElement::setOptionsChangedOnRenderer()
+void HTMLSelectElement::setOptionsChangedOnLayoutObject()
 {
-    if (LayoutObject* renderer = this->layoutObject()) {
+    if (LayoutObject* layoutObject = this->layoutObject()) {
         if (usesMenuList())
-            toLayoutMenuList(renderer)->setOptionsChanged(true);
+            toLayoutMenuList(layoutObject)->setOptionsChanged(true);
     }
 }
 
 const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
 #if ENABLE(ASSERT)
         WillBeHeapVector<RawPtrWillBeMember<HTMLElement>> items = m_listItems;
@@ skipping 12 matching lines @@
 }
 
 void HTMLSelectElement::setRecalcListItems()
 {
     // FIXME: This function does a bunch of confusing things depending on if it
     // is in the document or not.
 
     m_shouldRecalcListItems = true;
     // Manual selection anchor is reset when manipulating the select programmatically.
     m_activeSelectionAnchorIndex = -1;
-    setOptionsChangedOnRenderer();
+    setOptionsChangedOnLayoutObject();
     setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::ControlValue));
     if (!inDocument()) {
         if (HTMLOptionsCollection* collection = cachedCollection<HTMLOptionsCollection>(SelectOptions))
             collection->invalidateCache();
     }
     if (!inDocument())
         invalidateSelectedItems();
 
     if (layoutObject()) {
         if (AXObjectCache* cache = layoutObject()->document().existingAXObjectCache())
@@ skipping 86 matching lines @@
 
 int HTMLSelectElement::suggestedIndex() const
 {
     return m_suggestedIndex;
 }
 
 void HTMLSelectElement::setSuggestedIndex(int suggestedIndex)
 {
     m_suggestedIndex = suggestedIndex;
 
-    if (LayoutObject* renderer = this->layoutObject())  {
-        renderer->updateFromElement();
+    if (LayoutObject* layoutObject = this->layoutObject())  {
+        layoutObject->updateFromElement();
         scrollToIndex(suggestedIndex);
     }
 }
 
 void HTMLSelectElement::scrollToIndex(int listIndex)
 {
     if (listIndex < 0)
         return;
     if (usesMenuList())
         return;
@@ skipping 58 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->layoutObject())
-        renderer->updateFromElement();
+    if (LayoutObject* layoutObject = this->layoutObject())
+        layoutObject->updateFromElement();
 
     scrollToSelection();
     setNeedsValidityCheck();
 
     if (usesMenuList()) {
         m_isProcessingUserDrivenChange = flags & UserDriven;
         if (flags & DispatchInputAndChangeEvent)
             dispatchInputAndChangeEventForMenuList();
-        if (LayoutObject* renderer = this->layoutObject()) {
+        if (LayoutObject* layoutObject = this->layoutObject()) {
             if (usesMenuList()) {
-                toLayoutMenuList(renderer)->didSetSelectedIndex(listIndex);
+                toLayoutMenuList(layoutObject)->didSetSelectedIndex(listIndex);
             }
         }
     }
 
     notifyFormStateChanged();
 }
 
 int HTMLSelectElement::optionToListIndex(int optionIndex) const
 {
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = listItems();
@@ skipping 129 matching lines @@
                 if (foundIndex == kNotFound)
                     foundIndex = searchOptionsForValue(value, 0, startIndex);
                 if (foundIndex == kNotFound)
                     continue;
                 toHTMLOptionElement(items[foundIndex])->setSelectedState(true);
                 startIndex = foundIndex + 1;
             }
         }
     }
 
-    setOptionsChangedOnRenderer();
+    setOptionsChangedOnLayoutObject();
     setNeedsValidityCheck();
 }
 
 void HTMLSelectElement::parseMultipleAttribute(const AtomicString& value)
 {
     m_multiple = !value.isNull();
     setNeedsValidityCheck();
 
     lazyReattachIfAttached();
 }
@@ skipping 40 matching lines @@
         } else
             toHTMLOptionElement(element)->setSelectedState(false);
 
         if (!firstOption)
             firstOption = toHTMLOptionElement(element);
     }
 
     if (!selectedOption && firstOption && !m_multiple && m_size <= 1)
         firstOption->setSelectedState(true);
 
-    setOptionsChangedOnRenderer();
+    setOptionsChangedOnLayoutObject();
     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
+    // 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.
     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(layoutObject()))
@@ skipping 214 matching lines @@
     if (m_lastOnChangeSelection.isEmpty())
         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.
+        // Calling focus() may cause us to lose our layoutObject or change the layoutObject type, in which case do not want to handle the event.
         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.
+        // Calling focus() may cause us to lose our layoutObject, in which case do not want to handle the event.
         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());
@@ skipping 278 matching lines @@
 bool HTMLSelectElement::isInteractiveContent() const
 {
     return true;
 }
 
 bool HTMLSelectElement::supportsAutofocus() const
 {
     return true;
 }
 
-void HTMLSelectElement::updateListOnRenderer()
+void HTMLSelectElement::updateListOnLayoutObject()
 {
-    setOptionsChangedOnRenderer();
+    setOptionsChangedOnLayoutObject();
 }
 
 DEFINE_TRACE(HTMLSelectElement)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_listItems);
 #endif
     HTMLFormControlElementWithState::trace(visitor);
 }
 
@@ skipping 11 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