Update <select> when any of its <option> children has "display: none"

Source/core/rendering/RenderListBox.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  *               2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 68 matching lines @@
 // widget, but I'm not sure this is right for the new control.
 const int baselineAdjustment = 7;
 
 RenderListBox::RenderListBox(Element* element)
     : RenderBlockFlow(element)
     , m_optionsChanged(true)
     , m_scrollToRevealSelectionAfterLayout(true)
     , m_inAutoscroll(false)
     , m_optionsWidth(0)
     , m_indexOffset(0)
+    , m_listItemCount(0)
 {
     ASSERT(element);
     ASSERT(element->isHTMLElement());
     ASSERT(isHTMLSelectElement(element));
 
     if (FrameView* frameView = frame()->view())
         frameView->addScrollableArea(this);
 }
 
 RenderListBox::~RenderListBox()
@@ skipping 12 matching lines @@
 }
 
 inline HTMLSelectElement* RenderListBox::selectElement() const
 {
     return toHTMLSelectElement(node());
 }
 
 void RenderListBox::updateFromElement()
 {
     FontCachePurgePreventer fontCachePurgePreventer;
-
     if (m_optionsChanged) {
         const Vector<HTMLElement*>& listItems = selectElement()->listItems();
-        int size = numItems();
+        int size = static_cast<int>(listItems.size());
 
         float width = 0;
+        m_listItemCount = 0;
         for (int i = 0; i < size; ++i) {
             HTMLElement* element = listItems[i];
+            RenderStyle* listItemStyle = element->renderStyle();
+            if (listItemStyle && listItemStyle->display() == NONE)
+                continue;
+
+            ++m_listItemCount;
             String text;
             Font itemFont = style()->font();
             if (isHTMLOptionElement(*element)) {
                 text = toHTMLOptionElement(*element).textIndentedToRespectGroupLabel();
             } else if (isHTMLOptGroupElement(*element)) {
                 text = toHTMLOptGroupElement(*element).groupLabelText();
                 FontDescription d = itemFont.fontDescription();
                 d.setWeight(d.bolderWeight());
                 itemFont = Font(d);
                 itemFont.update(document().styleEngine()->fontSelector());
@@ skipping 60 matching lines @@
     repaintScrollbarIfNeeded();
     RenderBox::repaintTreeAfterLayout();
 }
 
 void RenderListBox::scrollToRevealSelection()
 {
     HTMLSelectElement* select = selectElement();
 
     m_scrollToRevealSelectionAfterLayout = false;
 
-    int firstIndex = select->activeSelectionStartListIndex();
-    if (firstIndex >= 0 && !listIndexIsVisible(select->activeSelectionEndListIndex()))
-        scrollToRevealElementAtListIndex(firstIndex);
+    int firstIndex = optionIndexToRenderListBoxIndex(select->activeSelectionStartListIndex());
+    int lastIndex = optionIndexToRenderListBoxIndex(select->activeSelectionEndListIndex());
+    if (firstIndex >= 0 && !listIndexIsVisible(lastIndex))
+        scrollToRevealElementAtListIndexInternal(firstIndex);
 }
 
 void RenderListBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     maxLogicalWidth = m_optionsWidth + 2 * optionsSpacingHorizontal;
     if (m_vBar)
         maxLogicalWidth += verticalScrollbarWidth();
     if (!style()->width().isPercent())
         minLogicalWidth = maxLogicalWidth;
 }
@@ skipping 37 matching lines @@
 }
 
 int RenderListBox::numVisibleItems() const
 {
     // Only count fully visible rows. But don't return 0 even if only part of a row shows.
     return max<int>(1, (contentHeight() + rowSpacing) / itemHeight());
 }
 
 int RenderListBox::numItems() const
 {
-    return selectElement()->listItems().size();
+    return m_listItemCount;
 }
 
 LayoutUnit RenderListBox::listHeight() const
 {
     return itemHeight() * numItems() - rowSpacing;
 }
 
 void RenderListBox::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     LayoutUnit height = itemHeight() * size() - rowSpacing + borderAndPaddingHeight();
     RenderBox::computeLogicalHeight(height, logicalTop, computedValues);
 }
 
 int RenderListBox::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode lineDirection, LinePositionMode linePositionMode) const
 {
     return RenderBox::baselinePosition(baselineType, firstLine, lineDirection, linePositionMode) - baselineAdjustment;
 }
 
-LayoutRect RenderListBox::itemBoundingBoxRect(const LayoutPoint& additionalOffset, int index)
+LayoutRect RenderListBox::itemBoundingBoxRectInternal(const LayoutPoint& additionalOffset, int index) const
 {
     // For RTL, items start after the left-side vertical scrollbar.
     int scrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? verticalScrollbarWidth() : 0;
     return LayoutRect(additionalOffset.x() + borderLeft() + paddingLeft() + scrollbarOffset,
         additionalOffset.y() + borderTop() + paddingTop() + itemHeight() * (index - m_indexOffset),
         contentWidth(), itemHeight());
 }
 
 void RenderListBox::paintObject(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
@@ skipping 41 matching lines @@
 void RenderListBox::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer)
 {
     if (!isSpatialNavigationEnabled(frame()))
         return RenderBlockFlow::addFocusRingRects(rects, additionalOffset, paintContainer);
 
     HTMLSelectElement* select = selectElement();
 
     // Focus the last selected item.
     int selectedItem = select->activeSelectionEndListIndex();
     if (selectedItem >= 0) {
-        rects.append(pixelSnappedIntRect(itemBoundingBoxRect(additionalOffset, selectedItem)));
+        rects.append(pixelSnappedIntRect(itemBoundingBoxRectInternal(additionalOffset, selectedItem)));
         return;
     }
 
     // No selected items, find the first non-disabled item.
     int size = numItems();
     const Vector<HTMLElement*>& listItems = select->listItems();
     for (int i = 0; i < size; ++i) {
-        HTMLElement* element = listItems[i];
+        HTMLElement* element = listItems[renderListBoxIndexToOptionIndex(i)];
         if (isHTMLOptionElement(*element) && !element->isDisabledFormControl()) {
-            rects.append(pixelSnappedIntRect(itemBoundingBoxRect(additionalOffset, i)));
+            rects.append(pixelSnappedIntRect(itemBoundingBoxRectInternal(additionalOffset, i)));
             return;
         }
     }
 }
 
 int RenderListBox::scrollbarLeft() const
 {
     int scrollbarLeft = 0;
     if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         scrollbarLeft = borderLeft();
@@ skipping 34 matching lines @@
     return offset;
 }
 
 void RenderListBox::paintItemForeground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
 {
     FontCachePurgePreventer fontCachePurgePreventer;
 
     HTMLSelectElement* select = selectElement();
 
     const Vector<HTMLElement*>& listItems = select->listItems();
-    HTMLElement* element = listItems[listIndex];
+    HTMLElement* element = listItems[renderListBoxIndexToOptionIndex(listIndex)];
 
     RenderStyle* itemStyle = element->renderStyle();
     if (!itemStyle)
         itemStyle = style();
 
     if (itemStyle->visibility() == HIDDEN)
         return;
 
     String itemText;
     bool isOptionElement = isHTMLOptionElement(*element);
     if (isOptionElement)
         itemText = toHTMLOptionElement(*element).textIndentedToRespectGroupLabel();
     else if (isHTMLOptGroupElement(*element))
         itemText = toHTMLOptGroupElement(*element).groupLabelText();
     applyTextTransform(style(), itemText, ' ');
 
     Color textColor = element->renderStyle() ? resolveColor(element->renderStyle(), CSSPropertyColor) : resolveColor(CSSPropertyColor);
     if (isOptionElement && ((toHTMLOptionElement(*element).selected() && select->suggestedIndex() < 0) || listIndex == select->suggestedIndex())) {
         if (frame()->selection().isFocusedAndActive() && document().focusedElement() == node())
             textColor = RenderTheme::theme().activeListBoxSelectionForegroundColor();
         // Honor the foreground color for disabled items
         else if (!element->isDisabledFormControl() && !select->isDisabledFormControl())
             textColor = RenderTheme::theme().inactiveListBoxSelectionForegroundColor();
     }
 
     paintInfo.context->setFillColor(textColor);
 
     TextRun textRun(itemText, 0, 0, TextRun::AllowTrailingExpansion, itemStyle->direction(), isOverride(itemStyle->unicodeBidi()), true, TextRun::NoRounding);
     Font itemFont = style()->font();
-    LayoutRect r = itemBoundingBoxRect(paintOffset, listIndex);
+    LayoutRect r = itemBoundingBoxRectInternal(paintOffset, listIndex);
     r.move(itemOffsetForAlignment(textRun, itemStyle, itemFont, r));
 
     if (isHTMLOptGroupElement(*element)) {
         FontDescription d = itemFont.fontDescription();
         d.setWeight(d.bolderWeight());
         itemFont = Font(d);
         itemFont.update(document().styleEngine()->fontSelector());
     }
 
     // Draw the item text
     TextRunPaintInfo textRunPaintInfo(textRun);
     textRunPaintInfo.bounds = r;
     paintInfo.context->drawBidiText(itemFont, textRunPaintInfo, roundedIntPoint(r.location()));
 }
 
 void RenderListBox::paintItemBackground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
 {
     const Vector<HTMLElement*>& listItems = selectElement()->listItems();
-    HTMLElement* element = listItems[listIndex];
+    HTMLElement* element = listItems[renderListBoxIndexToOptionIndex(listIndex)];
 
     Color backColor;
     if (isHTMLOptionElement(*element) && ((toHTMLOptionElement(*element).selected() && selectElement()->suggestedIndex() < 0) || listIndex == selectElement()->suggestedIndex())) {
         if (frame()->selection().isFocusedAndActive() && document().focusedElement() == node())
             backColor = RenderTheme::theme().activeListBoxSelectionBackgroundColor();
         else
             backColor = RenderTheme::theme().inactiveListBoxSelectionBackgroundColor();
     } else {
         backColor = element->renderStyle() ? resolveColor(element->renderStyle(), CSSPropertyBackgroundColor) : resolveColor(CSSPropertyBackgroundColor);
     }
 
     // Draw the background for this list box item
     if (!element->renderStyle() || element->renderStyle()->visibility() != HIDDEN) {
-        LayoutRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
+        LayoutRect itemRect = itemBoundingBoxRectInternal(paintOffset, listIndex);
         itemRect.intersect(controlClipRect(paintOffset));
         paintInfo.context->fillRect(pixelSnappedIntRect(itemRect), backColor);
     }
 }
 
 bool RenderListBox::isPointInOverflowControl(HitTestResult& result, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset)
 {
     if (!m_vBar || !m_vBar->shouldParticipateInHitTesting())
         return false;
 
     LayoutRect vertRect(accumulatedOffset.x() + scrollbarLeft(),
                         accumulatedOffset.y() + borderTop(),
                         verticalScrollbarWidth(),
                         height() - borderTop() - borderBottom());
 
     if (vertRect.contains(locationInContainer)) {
         result.setScrollbar(m_vBar.get());
         return true;
     }
     return false;
 }
 
-int RenderListBox::listIndexAtOffset(const LayoutSize& offset)
+int RenderListBox::listIndexAtOffset(const LayoutSize& offset) const
 {
     if (!numItems())
         return -1;
 
     if (offset.height() < borderTop() + paddingTop() || offset.height() > height() - paddingBottom() - borderBottom())
         return -1;
 
     int scrollbarWidth = verticalScrollbarWidth();
     int rightScrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? scrollbarWidth : 0;
     int leftScrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? 0 : scrollbarWidth;
     if (offset.width() < borderLeft() + paddingLeft() + rightScrollbarOffset
         || offset.width() > width() - borderRight() - paddingRight() - leftScrollbarOffset)
         return -1;
 
     int newOffset = (offset.height() - borderTop() - paddingTop()) / itemHeight() + m_indexOffset;
-    return newOffset < numItems() ? newOffset : -1;
+    return newOffset < numItems() ? renderListBoxIndexToOptionIndex(newOffset) : -1;
 }
 
 void RenderListBox::panScroll(const IntPoint& panStartMousePosition)
 {
     const int maxSpeed = 20;
     const int iconRadius = 7;
     const int speedReducer = 4;
 
     // FIXME: This doesn't work correctly with transforms.
     FloatPoint absOffset = localToAbsolute();
@@ skipping 36 matching lines @@
 
 int RenderListBox::scrollToward(const IntPoint& destination)
 {
     // FIXME: This doesn't work correctly with transforms.
     FloatPoint absPos = localToAbsolute();
     IntSize positionOffset = roundedIntSize(destination - absPos);
 
     int rows = numVisibleItems();
     int offset = m_indexOffset;
 
-    if (positionOffset.height() < borderTop() + paddingTop() && scrollToRevealElementAtListIndex(offset - 1))
+    if (positionOffset.height() < borderTop() + paddingTop() && scrollToRevealElementAtListIndexInternal(offset - 1))
         return offset - 1;
 
-    if (positionOffset.height() > height() - paddingBottom() - borderBottom() && scrollToRevealElementAtListIndex(offset + rows))
+    if (positionOffset.height() > height() - paddingBottom() - borderBottom() && scrollToRevealElementAtListIndexInternal(offset + rows))
         return offset + rows - 1;
 
     return listIndexAtOffset(positionOffset);
 }
 
 void RenderListBox::autoscroll(const IntPoint&)
 {
     IntPoint pos = frame()->view()->windowToContents(frame()->eventHandler().lastKnownMousePosition());
 
     int endIndex = scrollToward(pos);
     if (selectElement()->isDisabledFormControl())
         return;
 
     if (endIndex >= 0) {
         HTMLSelectElement* select = selectElement();
         m_inAutoscroll = true;
 
         if (!select->multiple())
-            select->setActiveSelectionAnchorIndex(endIndex);
+            select->setActiveSelectionAnchorIndex(renderListBoxIndexToOptionIndex(endIndex));
 
-        select->setActiveSelectionEndIndex(endIndex);
+        select->setActiveSelectionEndIndex(renderListBoxIndexToOptionIndex(endIndex));
         select->updateListBoxSelection(!select->multiple());
         m_inAutoscroll = false;
     }
 }
 
 void RenderListBox::stopAutoscroll()
 {
     if (selectElement()->isDisabledFormControl())
         return;
 
     selectElement()->listBoxOnChange();
 }
 
-bool RenderListBox::scrollToRevealElementAtListIndex(int index)
+bool RenderListBox::scrollToRevealElementAtListIndexInternal(int index)
 {
     if (index < 0 || index >= numItems() || listIndexIsVisible(index))
         return false;
 
     int newOffset;
     if (index < m_indexOffset)
         newOffset = index;
     else
         newOffset = index - numVisibleItems() + 1;
 
     scrollToOffsetWithoutAnimation(VerticalScrollbar, newOffset);
 
     return true;
 }
 
-bool RenderListBox::listIndexIsVisible(int index)
+bool RenderListBox::listIndexIsVisible(int index) const
 {
     return index >= m_indexOffset && index < m_indexOffset + numVisibleItems();
 }
 
 bool RenderListBox::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
 {
     return ScrollableArea::scroll(direction, granularity, multiplier);
 }
 
 int RenderListBox::scrollSize(ScrollbarOrientation orientation) const
@@ skipping 75 matching lines @@
 
 bool RenderListBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
     if (!RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction))
         return false;
     const Vector<HTMLElement*>& listItems = selectElement()->listItems();
     int size = numItems();
     LayoutPoint adjustedLocation = accumulatedOffset + location();
 
     for (int i = 0; i < size; ++i) {
-        if (itemBoundingBoxRect(adjustedLocation, i).contains(locationInContainer.point())) {
-            if (Element* node = listItems[i]) {
+        if (itemBoundingBoxRectInternal(adjustedLocation, i).contains(locationInContainer.point())) {
+            if (Element* node = listItems[renderListBoxIndexToOptionIndex(i)]) {
                 result.setInnerNode(node);
                 if (!result.innerNonSharedNode())
                     result.setInnerNonSharedNode(node);
                 result.setLocalPoint(locationInContainer.point() - toLayoutSize(adjustedLocation));
                 break;
             }
         }
     }
 
     return true;
@@ skipping 210 matching lines @@
         destroyScrollbar();
 
     if (m_vBar)
         m_vBar->styleChanged();
 
     // Force an update since we know the scrollbars have changed things.
     if (document().hasAnnotatedRegions())
         document().setAnnotatedRegionsDirty(true);
 }
 
+int RenderListBox::renderListBoxIndexToOptionIndex(int index) const

[keishi, 2014/04/11 15:07:09]

I'm sorry this should have been renderListBoxIndexToListIndex.
listIndex is the index used for HTMLSelectItem::listItems() which contains
option element, optgroup elements, and hr elements.
optionIndex is the index for option elements only.

[spartha, 2014/04/12 18:53:22]

Done.

+{
+    const Vector<HTMLElement*>& listItems = selectElement()->listItems();
+    const int size = static_cast<int>(listItems.size());
+
+    if (size == numItems())
+        return index;
+
+    int rendererIndex = 0;
+    int i = 0;
+    for (; i < size; ++i) {
+        HTMLElement* element = listItems[i];
+        RenderStyle* listItemStyle = element->renderStyle();
+        if (listItemStyle && listItemStyle->display() == NONE)
+            continue;
+        if (index == rendererIndex)
+            break;
+        ++rendererIndex;
+    }
+    return i;
+}
+
+int RenderListBox::optionIndexToRenderListBoxIndex(int index) const

[keishi, 2014/04/11 15:07:09]

Ditto.

[spartha, 2014/04/12 18:53:22]

Done.

+{
+    const Vector<HTMLElement*>& listItems = selectElement()->listItems();
+    const int size = static_cast<int>(listItems.size());
+
+    if (size == numItems())
+        return index;
+
+    int realIndex = 0;
+    for (int i = 0; i < size; ++i) {
+        HTMLElement* element = listItems[i];
+        RenderStyle* listItemStyle = element->renderStyle();
+        if (listItemStyle && listItemStyle->display() == NONE)
+            continue;
+        if (index == i)
+            break;
+        ++realIndex;
+    }
+    return realIndex;
+}
+
+LayoutRect RenderListBox::itemBoundingBoxRect(const LayoutPoint& point, int index) const
+{
+    return itemBoundingBoxRectInternal(point, optionIndexToRenderListBoxIndex(index));
+}
+
+bool RenderListBox::scrollToRevealElementAtListIndex(int index)
+{
+    return scrollToRevealElementAtListIndexInternal(optionIndexToRenderListBoxIndex(index));
+}
+
 } // namespace WebCore