Implement select listbox using shadow DOM

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 21 matching lines @@
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
+#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/page/AutoscrollController.h"
 #include "core/page/EventHandler.h"
+#include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
+#include "core/rendering/HitTestRequest.h"
+#include "core/rendering/HitTestResult.h"
 #include "core/rendering/RenderListBox.h"
 #include "core/rendering/RenderMenuList.h"
 #include "core/rendering/RenderTheme.h"
+#include "core/rendering/RenderView.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/text/PlatformLocale.h"
 
 using namespace WTF::Unicode;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // Upper limit agreed upon with representatives of Opera and Mozilla.
 static const unsigned maxSelectItems = 10000;
 
 HTMLSelectElement::HTMLSelectElement(Document& document, HTMLFormElement* form)
     : HTMLFormControlElementWithState(selectTag, document, form)
     , m_typeAhead(this)
     , m_size(0)
     , m_lastOnChangeIndex(-1)
     , m_activeSelectionAnchorIndex(-1)
     , m_activeSelectionEndIndex(-1)
     , m_isProcessingUserDrivenChange(false)
     , m_multiple(false)
     , m_activeSelectionState(false)
     , m_shouldRecalcListItems(false)
     , m_suggestedIndex(-1)
+    , m_capturing(false)
 {
     ScriptWrappable::init(this);
     setHasCustomStyleCallbacks();
 }
 
 PassRefPtrWillBeRawPtr<HTMLSelectElement> HTMLSelectElement::create(Document& document)
 {
     return adoptRefWillBeNoop(new HTMLSelectElement(document, 0));
 }
 
@@ skipping 241 matching lines @@
                 sizeAttribute->setValue(attrSize);
         }
         size = std::max(size, 1);
 
         // Ensure that we've determined selectedness of the items at least once prior to changing the size.
         if (oldSize != size)
             updateListItemSelectedStates();
 
         m_size = size;
         setNeedsValidityCheck();
-        if (m_size != oldSize && inActiveDocument()) {
-            lazyReattachIfAttached();
-            setRecalcListItems();
+        if (m_size != oldSize && document().isActive()) {
+            // ensureShadowDOM needs to be run even when !inDocument().
+            updateView();
+            if (inDocument())
+                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 (menuList->popupIsVisible())
                     menuList->hidePopup();
             }
         }
 
     } else
         HTMLFormControlElementWithState::parseAttribute(name, value);
 }
 
 bool HTMLSelectElement::shouldShowFocusRingOnMouseFocus() const
 {
     return true;
 }
 
 bool HTMLSelectElement::canSelectAll() const
 {
     return !usesMenuList();
 }
 
-RenderObject* HTMLSelectElement::createRenderer(RenderStyle*)
+RenderObject* HTMLSelectElement::createRenderer(RenderStyle* style)
 {
     if (usesMenuList())
         return new RenderMenuList(this);
     return new RenderListBox(this);
 }
 
 PassRefPtrWillBeRawPtr<HTMLCollection> HTMLSelectElement::selectedOptions()
 {
     updateListItemSelectedStates();
     return ensureCachedHTMLCollection(SelectedOptions);
@@ skipping 316 matching lines @@
         m_lastOnChangeIndex = selected;
         m_isProcessingUserDrivenChange = false;
         RefPtrWillBeRawPtr<HTMLSelectElement> protector(this);
         dispatchInputEvent();
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::scrollToSelection()
 {
+    if (!isFinishedParsingChildren())

[keishi, 2014/06/22 11:59:55]

scrollToSelection is very slow compared to the current implementation because we
use element.scrollIntoViewIfNecessary which does layout.
menulist-appearance-basic.html timesout unless we do this.

+        return;
     if (usesMenuList())
         return;
-
-    if (RenderObject* renderer = this->renderer())
-        toRenderListBox(renderer)->selectionChanged();
+    scrollTo(activeSelectionEndListIndex());
+    if (AXObjectCache* cache = document().existingAXObjectCache())
+        cache->selectedChildrenChanged(this);
 }
 
 void HTMLSelectElement::setOptionsChangedOnRenderer()
 {
     if (RenderObject* renderer = this->renderer()) {
         if (usesMenuList())
             toRenderMenuList(renderer)->setOptionsChanged(true);
-        else
-            toRenderListBox(renderer)->setOptionsChanged(true);
     }
 }
 
 const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
 #if ASSERT_ENABLED
         WillBeHeapVector<RawPtrWillBeMember<HTMLElement> > items = m_listItems;
@@ skipping 121 matching lines @@
 {
     return m_suggestedIndex;
 }
 
 void HTMLSelectElement::setSuggestedIndex(int suggestedIndex)
 {
     m_suggestedIndex = suggestedIndex;
 
     if (RenderObject* renderer = this->renderer())  {
         renderer->updateFromElement();
-        if (renderer->isListBox())
-            toRenderListBox(renderer)->scrollToRevealElementAtListIndex(suggestedIndex);
+        scrollTo(suggestedIndex);
     }
 }
 
+void HTMLSelectElement::scrollTo(int listIndex)
+{
+    if (listIndex < 0)
+        return;
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    int listSize = static_cast<int>(items.size());
+    if (listIndex >= listSize)
+        return;
+    items[listIndex]->scrollIntoViewIfNeeded(false);
+}
+
 void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
 {
     ASSERT(option->ownerSelectElement() == this);
     if (optionIsSelected)
         selectOption(option->index());
     else if (!usesMenuList() || multiple())
         selectOption(-1);
     else
         selectOption(nextSelectableListIndex(-1));
 }
 
+void HTMLSelectElement::optionRemoved(HTMLOptionElement* option)

[keishi, 2014/06/22 11:59:56]

listbox-clear-restore.html tests that the scroll position will not be preserved
when removing all options and adding them back.
Right now RenderListBox::layout is resetting the scroll position to zero when
all options are removed.
That is a hack. What we should be doing is adjust the active selection when
options are removed.

+{
+    int listIndex = optionToListIndex(option->index());
+    if (listIndex <= m_activeSelectionAnchorIndex)
+        m_activeSelectionAnchorIndex--;
+    if (listIndex <= m_activeSelectionEndIndex)
+        m_activeSelectionEndIndex--;
+}
+
 void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
 {
     bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
 
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
     int listIndex = optionToListIndex(optionIndex);
 
     HTMLElement* element = 0;
     if (listIndex >= 0) {
         element = items[listIndex];
@@ skipping 15 matching lines @@
 
     scrollToSelection();
 
     setNeedsValidityCheck();
 
     if (usesMenuList()) {
         m_isProcessingUserDrivenChange = flags & UserDriven;
         if (flags & DispatchInputAndChangeEvent)
             dispatchInputAndChangeEventForMenuList();
         if (RenderObject* renderer = this->renderer()) {
-            if (usesMenuList())
+            if (usesMenuList()) {
                 toRenderMenuList(renderer)->didSetSelectedIndex(listIndex);
-            else if (renderer->isListBox())
-                toRenderListBox(renderer)->selectionChanged();
+            } else if (renderer->isListBox()) {
+                if (AXObjectCache* cache = document().existingAXObjectCache())
+                    cache->selectedChildrenChanged(this);
+            }
         }
     }
 
     notifyFormStateChanged();
 }
 
 int HTMLSelectElement::optionToListIndex(int optionIndex) const
 {
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
     int listSize = static_cast<int>(items.size());
@@ skipping 120 matching lines @@
             startIndex = foundIndex + 1;
         }
     }
 
     setOptionsChangedOnRenderer();
     setNeedsValidityCheck();
 }
 
 void HTMLSelectElement::parseMultipleAttribute(const AtomicString& value)
 {
-    bool oldUsesMenuList = usesMenuList();
     m_multiple = !value.isNull();
     setNeedsValidityCheck();
-    if (oldUsesMenuList != usesMenuList())
-        lazyReattachIfAttached();
+
+    updateView();
+}
+
+void HTMLSelectElement::updateView()
+{
+    if (!usesMenuList())
+        ensureUserAgentShadowRoot();
+    else if (userAgentShadowRoot())
+        userAgentShadowRoot()->detach();
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = listItems();
+    for (unsigned i = 0; i < items.size(); ++i) {
+        HTMLElement* element = items[i];
+        if (isHTMLOptionElement(*element))
+            toHTMLOptionElement(*element).updateView();
+        else if (isHTMLOptGroupElement(*element))
+            toHTMLOptGroupElement(*element).updateView();
+    }
+    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();
@@ skipping 257 matching lines @@
     // we're doing a single selection, or a multiple selection (using cmd or
     // ctrl), then initialize the anchor index to the listIndex that just got
     // clicked.
     if (m_activeSelectionAnchorIndex < 0 || !shiftSelect)
         setActiveSelectionAnchorIndex(listIndex);
 
     setActiveSelectionEndIndex(listIndex);
     updateListBoxSelection(!multiSelect);
 }
 
+int HTMLSelectElement::listIndexForMouseEvent(const MouseEvent& event)
+{
+    Node* targetNode = event.target()->toNode();
+    if (targetNode != this)
+        return listIndexForEvent(event);
+    HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::Move | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
+    HitTestResult result(event.absoluteLocation());
+    document().renderView()->hitTest(request, result);
+    Node* hitNode = result.targetNode();
+    if (!hitNode)
+        return -1;
+    return listIndexForNode(*hitNode);
+}
+
+int HTMLSelectElement::listIndexForEvent(const Event& event)
+{
+    Node* targetNode = event.target()->toNode();
+    if (!targetNode)
+        return -1;
+    return listIndexForNode(*targetNode);
+}
+
+int HTMLSelectElement::listIndexForNode(const Node& targetNode)
+{
+    const WillBeHeapVector<RawPtrWillBeMember<HTMLElement> >& items = this->listItems();
+    for (const Node* node = &targetNode; node; node = node->parentOrShadowHostNode()) {
+        if (node->isElementNode() && (toElement(node)->hasTagName(optionTag) || toElement(node)->hasTagName(optgroupTag))) {
+            size_t length = items.size();
+            for (size_t i = 0; i < length; ++i) {
+                if (items[i] == node) {
+                    return i;
+                }
+            }
+        }
+    }
+    return -1;
+}
+
+AutoscrollController* HTMLSelectElement::autoscrollController() const
+{
+    if (Page* page = document().page())
+        return &page->autoscrollController();
+    return 0;
+}
+
 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())
             return;
 
         // Convert to coords relative to the list box if needed.
         GestureEvent& gestureEvent = toGestureEvent(*event);
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(gestureEvent.absoluteLocation(), UseTransforms));
-        int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toIntSize(localOffset));
+        int listIndex = listIndexForEvent(gestureEvent);
         if (listIndex >= 0) {
             if (!isDisabledFormControl())
                 updateSelectedState(listIndex, true, gestureEvent.shiftKey());
             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())
             return;
 
+        if (Page* page = document().page())
+            page->autoscrollController().startAutoscrollForSelection(renderer());
+
+        if (LocalFrame* frame = document().frame()) {
+            frame->eventHandler().setCapturingMouseEventsNode(this);
+            m_capturing = true;
+        }
+
         // Convert to coords relative to the list box if needed.
         MouseEvent* mouseEvent = toMouseEvent(event);
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), UseTransforms));
-        int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toIntSize(localOffset));
+        int listIndex = listIndexForMouseEvent(*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() && !toRenderBox(renderer())->canBeScrolledAndHasScrollableArea()) {
+    } else if (event->type() == EventTypeNames::mousemove && event->isMouseEvent()) {
         MouseEvent* mouseEvent = toMouseEvent(event);
         if (mouseEvent->button() != LeftButton || !mouseEvent->buttonDown())
             return;
-
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), UseTransforms));
-        int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toIntSize(localOffset));
+        int listIndex = listIndexForMouseEvent(*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() && !toRenderBox(renderer())->autoscrollInProgress()) {
+    } else if (event->type() == EventTypeNames::mouseup && event->isMouseEvent() && toMouseEvent(event)->button() == LeftButton && renderer()) {
+        LocalFrame* frame = document().frame();
+        if (m_capturing && frame) {
+            frame->eventHandler().setCapturingMouseEventsNode(nullptr);
+            m_capturing = false;
+        }
         // We didn't start this click/drag on any options.
         if (m_lastOnChangeSelection.isEmpty())
             return;
         listBoxOnChange();
     } else if (event->type() == EventTypeNames::keydown) {
         if (!event->isKeyboardEvent())
             return;
         const String& keyIdentifier = toKeyboardEvent(event)->keyIdentifier();
 
         bool handled = false;
@@ skipping 58 matching lines @@
                 m_activeSelectionState = true;
             // If the anchor is unitialized, or if we're going to deselect all
             // other options, then set the anchor index equal to the end index.
             bool deselectOthers = !m_multiple || (!toKeyboardEvent(event)->shiftKey() && selectNewItem);
             if (m_activeSelectionAnchorIndex < 0 || deselectOthers) {
                 if (deselectOthers)
                     deselectItemsWithoutValidation();
                 setActiveSelectionAnchorIndex(m_activeSelectionEndIndex);
             }
 
-            toRenderListBox(renderer())->scrollToRevealElementAtListIndex(endIndex);
+            scrollTo(endIndex);
             if (selectNewItem) {
                 updateListBoxSelection(deselectOthers);
                 listBoxOnChange();
             } else
                 scrollToSelection();
 
             event->setDefaultHandled();
         }
     } else if (event->type() == EventTypeNames::keypress) {
         if (!event->isKeyboardEvent())
@@ skipping 130 matching lines @@
             ++options;
     }
 
     return options;
 }
 
 void HTMLSelectElement::finishParsingChildren()
 {
     HTMLFormControlElementWithState::finishParsingChildren();
     updateListItemSelectedStates();
+    scrollToSelection();
 }
 
 bool HTMLSelectElement::anonymousIndexedSetter(unsigned index, PassRefPtrWillBeRawPtr<HTMLOptionElement> value, ExceptionState& exceptionState)
 {
     if (!value) { // undefined or null
         remove(index);
         return true;
     }
     setOption(index, value.get(), exceptionState);
     return true;
@@ skipping 15 matching lines @@
 }
 
 void HTMLSelectElement::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_listItems);
 #endif
     HTMLFormControlElementWithState::trace(visitor);
 }
 
+void HTMLSelectElement::didAddUserAgentShadowRoot(ShadowRoot& root)
+{
+    RefPtrWillBeRawPtr<HTMLContentElement> content = HTMLContentElement::create(document());
+    content->setAttribute(selectAttr, "option,optgroup");
+    root.appendChild(content);
+}
+
 } // namespace