Implement select listbox using shadow DOM

Source/core/html/HTMLOptionElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2011 Motorola Mobility, Inc.  All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 16 matching lines @@
 #include "config.h"
 #include "core/html/HTMLOptionElement.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/Text.h"
+#include "core/dom/shadow/ShadowRoot.h"
 #include "core/html/HTMLDataListElement.h"
+#include "core/html/HTMLOptGroupElement.h"
 #include "core/html/HTMLSelectElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/rendering/RenderTheme.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 HTMLOptionElement::HTMLOptionElement(Document& document)
     : HTMLElement(optionTag, document)
     , m_disabled(false)
     , m_isSelected(false)
 {
     setHasCustomStyleCallbacks();
     ScriptWrappable::init(this);
 }
 
 PassRefPtrWillBeRawPtr<HTMLOptionElement> HTMLOptionElement::create(Document& document)
 {
-    return adoptRefWillBeNoop(new HTMLOptionElement(document));
+    RefPtrWillBeRawPtr<HTMLOptionElement> option = adoptRefWillBeNoop(new HTMLOptionElement(document));
+    option->ensureUserAgentShadowRoot();
+    return option.release();
 }
 
 PassRefPtrWillBeRawPtr<HTMLOptionElement> HTMLOptionElement::createForJSConstructor(Document& document, const String& data, const AtomicString& value,
     bool defaultSelected, bool selected, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<HTMLOptionElement> element = adoptRefWillBeNoop(new HTMLOptionElement(document));
+    element->ensureUserAgentShadowRoot();
     element->appendChild(Text::create(document, data.isNull() ? "" : data), exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     if (!value.isNull())
         element->setValue(value);
     if (defaultSelected)
         element->setAttribute(selectedAttr, emptyAtom);
     element->setSelected(selected);
 
@@ skipping 12 matching lines @@
     }
     HTMLElement::attach(optionContext);
 }
 
 void HTMLOptionElement::detach(const AttachContext& context)
 {
     m_style.clear();
     HTMLElement::detach(context);
 }
 
-bool HTMLOptionElement::rendererIsFocusable() const
-{
-    // Option elements do not have a renderer so we check the renderStyle instead.
-    return renderStyle() && renderStyle()->display() != NONE;
-}
-
 String HTMLOptionElement::text() const
 {
     Document& document = this->document();
     String text;
 
     // WinIE does not use the label attribute, so as a quirk, we ignore it.
     if (!document.inQuirksMode())
         text = fastGetAttribute(labelAttr);
 
     // FIXME: The following treats an element with the label attribute set to
@@ skipping 67 matching lines @@
         bool oldDisabled = m_disabled;
         m_disabled = !value.isNull();
         if (oldDisabled != m_disabled) {
             didAffectSelector(AffectedSelectorDisabled | AffectedSelectorEnabled);
             if (renderer() && renderer()->style()->hasAppearance())
                 RenderTheme::theme().stateChanged(renderer(), EnabledControlState);
         }
     } else if (name == selectedAttr) {
         if (bool willBeSelected = !value.isNull())
             setSelected(willBeSelected);
+    } else if (name == labelAttr) {
+        updateLabel();
     } else
         HTMLElement::parseAttribute(name, value);
 }
 
 String HTMLOptionElement::value() const
 {
     const AtomicString& value = fastGetAttribute(valueAttr);
     if (!value.isNull())
         return value;
     return collectOptionInnerText().stripWhiteSpace(isHTMLSpace<UChar>).simplifyWhiteSpace(isHTMLSpace<UChar>);
@@ skipping 43 matching lines @@
     if (HTMLSelectElement* select = ownerSelectElement())
         select->invalidateSelectedItems();
 }
 
 void HTMLOptionElement::childrenChanged(const ChildrenChange& change)
 {
     if (HTMLDataListElement* dataList = ownerDataListElement())
         dataList->optionElementChildrenChanged();
     else if (HTMLSelectElement* select = ownerSelectElement())
         select->optionElementChildrenChanged();
+    updateLabel();
     HTMLElement::childrenChanged(change);
 }
 
 HTMLDataListElement* HTMLOptionElement::ownerDataListElement() const
 {
     return Traversal<HTMLDataListElement>::firstAncestor(*this);
 }
 
 HTMLSelectElement* HTMLOptionElement::ownerSelectElement() const
 {
     return Traversal<HTMLSelectElement>::firstAncestor(*this);
 }
 
 String HTMLOptionElement::label() const
 {
     const AtomicString& label = fastGetAttribute(labelAttr);
     if (!label.isNull())
         return label;
     return collectOptionInnerText().stripWhiteSpace(isHTMLSpace<UChar>).simplifyWhiteSpace(isHTMLSpace<UChar>);
 }
 
 void HTMLOptionElement::setLabel(const AtomicString& label)
 {
     setAttribute(labelAttr, label);
 }
 
 void HTMLOptionElement::updateNonRenderStyle()
 {
-    bool oldDisplayNoneStatus = isDisplayNone();
     m_style = originalStyleForRenderer();
-    if (oldDisplayNoneStatus != isDisplayNone()) {
-        if (HTMLSelectElement* select = ownerSelectElement())
-            select->updateListOnRenderer();
-    }
+    if (HTMLSelectElement* select = ownerSelectElement())
+        select->updateListOnRenderer();
 }
 
 RenderStyle* HTMLOptionElement::nonRendererStyle() const
 {
     return m_style.get();
 }
 
 PassRefPtr<RenderStyle> HTMLOptionElement::customStyleForRenderer()
 {
     updateNonRenderStyle();
@@ skipping 38 matching lines @@
         // FIXME: Might be better to call this unconditionally, always passing m_isSelected,
         // rather than only calling it if we are selected.
         if (m_isSelected)
             select->optionSelectionStateChanged(this, true);
         select->scrollToSelection();
     }
 
     return HTMLElement::insertedInto(insertionPoint);
 }
 
+void HTMLOptionElement::removedFrom(ContainerNode* insertionPoint)
+{
+    if (HTMLSelectElement* select = Traversal<HTMLSelectElement>::firstAncestorOrSelf(*insertionPoint))
+        select->optionRemoved(*this);
+    HTMLElement::removedFrom(insertionPoint);
+}
+
 String HTMLOptionElement::collectOptionInnerText() const
 {
     StringBuilder text;
     for (Node* node = firstChild(); node; ) {
         if (node->isTextNode())
             text.append(node->nodeValue());
         // Text nodes inside script elements are not part of the option text.
         if (node->isElementNode() && toScriptLoaderIfPossible(toElement(node)))
             node = NodeTraversal::nextSkippingChildren(*node, this);
         else
             node = NodeTraversal::next(*node, this);
     }
     return text.toString();
 }
 
 HTMLFormElement* HTMLOptionElement::form() const
 {
     if (HTMLSelectElement* selectElement = ownerSelectElement())
         return selectElement->formOwner();
 
     return 0;
 }
 
-bool HTMLOptionElement::isDisplayNone() const
+void HTMLOptionElement::didAddUserAgentShadowRoot(ShadowRoot& root)
 {
-    ContainerNode* parent = parentNode();
-    // Check for parent optgroup having display NONE
-    if (parent && isHTMLOptGroupElement(*parent)) {
-        if (toHTMLOptGroupElement(*parent).isDisplayNone())
-            return true;
-    }
-    RenderStyle* style = nonRendererStyle();
-    return style && style->display() == NONE;
+    updateLabel();
+}
+
+void HTMLOptionElement::updateLabel()
+{
+    if (ShadowRoot* root = userAgentShadowRoot())
+        root->setTextContent(textIndentedToRespectGroupLabel());
+}
+
+bool HTMLOptionElement::spatialNavigationFocused() const
+{
+    HTMLSelectElement* select = ownerSelectElement();
+    if (!select || !select->focused())
+        return false;
+    return select->spatialNavigationFocusedOption() == this;
 }
 
 } // namespace WebCore