Improve performance to remove OPTIONs from a single-selection SELECT.

third_party/WebKit/Source/core/layout/LayoutMenuList.cpp

 /*
  * This file is part of the select element layoutObject in WebCore.
  *
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *               2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 135 matching lines @@
     LayoutBlock::styleDidChange(diff, oldStyle);
 
     if (!m_innerBlock)
         createInnerBlock();
 
     m_buttonText->setStyle(mutableStyle());
     adjustInnerStyle();
 
     bool fontChanged = !oldStyle || oldStyle->font() != style()->font();
     if (fontChanged)
-        updateOptionsHeightWidth();
+        m_optionsChanged = true;
 }
 
-void LayoutMenuList::updateOptionsHeightWidth()
+void LayoutMenuList::updateOptionsHeightWidth() const
 {
+    if (!m_optionsChanged)
+        return;
+
     float maxOptionHeight = 0;
     float maxOptionWidth = 0;
     const HeapVector<Member<HTMLElement>>& listItems = selectElement()->listItems();
     int size = listItems.size();
 
     for (int i = 0; i < size; ++i) {
         HTMLElement* element = listItems[i];
         if (!isHTMLOptionElement(*element))
             continue;
 
@@ skipping 13 matching lines @@
             if (!text.isEmpty()) {
                 TextRun textRun = constructTextRun(itemStyle->font(), text, styleRef());
                 optionWidth += computeTextWidth(textRun, *itemStyle);
             }
             maxOptionWidth = std::max(maxOptionWidth, optionWidth);
         } else if (!text.isEmpty()) {
             maxOptionWidth = std::max(maxOptionWidth, computeTextWidth(textRun, *itemStyle));
         }
     }
 
-    int height = static_cast<int>(ceilf(maxOptionHeight));
-    int width = static_cast<int>(ceilf(maxOptionWidth));
-    if (m_optionsWidth == width && m_optionsHeight == height)
-        return;
+    m_optionsWidth = static_cast<int>(ceilf(maxOptionWidth));
+    m_optionsHeight = static_cast<int>(ceilf(maxOptionHeight));
+    m_optionsChanged = false;
+}
 
-    auto invalidationReason = LayoutInvalidationReason::Unknown;
-    if (m_optionsWidth != width) {
-        m_optionsWidth = width;
-        invalidationReason = LayoutInvalidationReason::MenuWidthChanged;
-    }
-
-    if (m_optionsHeight != height) {
-        m_optionsHeight = height;
-        invalidationReason = LayoutInvalidationReason::MenuHeightChanged;
-    }
-
-    if (parent())
-        setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(invalidationReason);
+void LayoutMenuList::setOptionsChanged(bool changed)
+{
+    m_optionsChanged = changed;
+    if (changed && parent())
+        setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::MenuOptionsChanged);
 }
 
 float LayoutMenuList::computeTextHeight(const TextRun& textRun, const ComputedStyle& computedStyle) const
 {
     FloatRect glyphBounds;
     computedStyle.font().width(textRun, nullptr /* fallbackFonts */, &glyphBounds);
     return glyphBounds.height();
 }
 
 float LayoutMenuList::computeTextWidth(const TextRun& textRun, const ComputedStyle& computedStyle) const
 {
     return computedStyle.font().width(textRun);
 }
 
 void LayoutMenuList::updateFromElement()
 {
-    if (m_optionsChanged) {
-        updateOptionsHeightWidth();
-        m_optionsChanged = false;
-    }
-
-    updateText();
-}
-
-void LayoutMenuList::updateText()
-{
     setTextFromOption(selectElement()->optionIndexToBeShown());
 }
 
 void LayoutMenuList::setTextFromOption(int optionIndex)
 {
     HTMLSelectElement* select = selectElement();
     const HeapVector<Member<HTMLElement>>& listItems = select->listItems();
     const int size = listItems.size();
 
     String text = emptyString();
@@ skipping 74 matching lines @@
 
     LayoutRect innerBox(additionalOffset + m_innerBlock->location()
         + LayoutSize(m_innerBlock->paddingLeft(), m_innerBlock->paddingTop())
         , m_innerBlock->contentSize());
 
     return intersection(outerBox, innerBox);
 }
 
 void LayoutMenuList::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
+    updateOptionsHeightWidth();
     maxLogicalWidth = std::max(m_optionsWidth, LayoutTheme::theme().minimumMenuListSize(styleRef())) + m_innerBlock->paddingLeft() + m_innerBlock->paddingRight();
     if (!style()->width().hasPercent())
         minLogicalWidth = maxLogicalWidth;
 }
 
 void LayoutMenuList::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop,
     LogicalExtentComputedValues& computedValues) const
 {
+    updateOptionsHeightWidth();
     logicalHeight = LayoutUnit(m_optionsHeight) + borderAndPaddingHeight()
         + LayoutUnit(cInnerBlockVerticalPaddingEm * style()->computedFontSize());
     LayoutBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
 }
 
 void LayoutMenuList::didSetSelectedIndex(int optionIndex)
 {
     didUpdateActiveOption(optionIndex);
 }
 
@@ skipping 25 matching lines @@
 {
     return paddingLeft() + m_innerBlock->paddingLeft();
 }
 
 LayoutUnit LayoutMenuList::clientPaddingRight() const
 {
     return paddingRight() + m_innerBlock->paddingRight();
 }
 
 } // namespace blink