renderer/RenderMenuList.* -> layout/LayoutMenuList.*

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 34 matching lines @@
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/FormDataList.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLOptGroupElement.h"
 #include "core/html/HTMLOptionElement.h"
 #include "core/html/forms/FormController.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutListBox.h"
+#include "core/layout/LayoutMenuList.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
-#include "core/rendering/RenderMenuList.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/text/PlatformLocale.h"
 
 using namespace WTF::Unicode;
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // Upper limit agreed upon with representatives of Opera and Mozilla.
@@ skipping 279 matching lines @@
             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 (RenderMenuList* menuList = toRenderMenuList(renderer())) {
+            if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
                 if (menuList->popupIsVisible())
                     menuList->hidePopup();
             }
         }
 
     } else
         HTMLFormControlElementWithState::parseAttribute(name, value);
 }
 
 bool HTMLSelectElement::shouldShowFocusRingOnMouseFocus() const
 {
     return true;
 }
 
 bool HTMLSelectElement::canSelectAll() const
 {
     return !usesMenuList();
 }
 
 LayoutObject* HTMLSelectElement::createRenderer(const LayoutStyle&)
 {
     if (usesMenuList())
-        return new RenderMenuList(this);
+        return new LayoutMenuList(this);
     return new LayoutListBox(this);
 }
 
 PassRefPtrWillBeRawPtr<HTMLCollection> HTMLSelectElement::selectedOptions()
 {
     updateListItemSelectedStates();
     return ensureCachedCollection<HTMLCollection>(SelectedOptions);
 }
 
 PassRefPtrWillBeRawPtr<HTMLOptionsCollection> HTMLSelectElement::options()
@@ skipping 335 matching lines @@
         return;
     scrollToIndex(activeSelectionEndListIndex());
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->selectedChildrenChanged(this);
 }
 
 void HTMLSelectElement::setOptionsChangedOnRenderer()
 {
     if (LayoutObject* renderer = this->renderer()) {
         if (usesMenuList())
-            toRenderMenuList(renderer)->setOptionsChanged(true);
+            toLayoutMenuList(renderer)->setOptionsChanged(true);
     }
 }
 
 const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
 #if ENABLE(ASSERT)
         WillBeHeapVector<RawPtrWillBeMember<HTMLElement>> items = m_listItems;
@@ skipping 211 matching lines @@
 
     scrollToSelection();
     setNeedsValidityCheck();
 
     if (usesMenuList()) {
         m_isProcessingUserDrivenChange = flags & UserDriven;
         if (flags & DispatchInputAndChangeEvent)
             dispatchInputAndChangeEventForMenuList();
         if (LayoutObject* renderer = this->renderer()) {
             if (usesMenuList()) {
-                toRenderMenuList(renderer)->didSetSelectedIndex(listIndex);
+                toLayoutMenuList(renderer)->didSetSelectedIndex(listIndex);
             } else if (renderer->isListBox()) {
                 if (AXObjectCache* cache = document().existingAXObjectCache())
                     cache->selectedChildrenChanged(this);
             }
         }
     }
 
     notifyFormStateChanged();
 }
 
@@ skipping 208 matching lines @@
 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())
         return;
     // Save the selection so it can be compared to the new selection
     // when dispatching change events during selectOption, which
-    // gets called from RenderMenuList::valueChanged, which gets called
+    // gets called from LayoutMenuList::valueChanged, which gets called
     // after the user makes a selection from the menu.
     saveLastSelection();
-    if (RenderMenuList* menuList = toRenderMenuList(renderer()))
+    if (LayoutMenuList* menuList = toLayoutMenuList(renderer()))
         menuList->showPopup();
     event->setDefaultHandled();
     return;
 }
 
 bool HTMLSelectElement::shouldOpenPopupForKeyDownEvent(KeyboardEvent* keyEvent)
 {
     const String& keyIdentifier = keyEvent->keyIdentifier();
     LayoutTheme& layoutTheme = LayoutTheme::theme();
 
@@ skipping 87 matching lines @@
             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 (RenderMenuList* menuList = toRenderMenuList(renderer())) {
+            if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
                 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 RenderMenuList::valueChanged,
+                    // 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 (RenderMenuList* menuList = toRenderMenuList(renderer())) {
+        if (LayoutMenuList* menuList = toLayoutMenuList(renderer())) {
             if (menuList->popupIsVisible())
                 menuList->hidePopup();
         }
     }
 }
 
 void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shift)
 {
     ASSERT(listIndex >= 0);
 
@@ skipping 427 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