Revert of [Reland] Setup LayoutMenuList to not modify layout tree outside style recalc.

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 38 matching lines @@
 
 namespace blink {
 
 using namespace HTMLNames;
 
 LayoutMenuList::LayoutMenuList(Element* element)
     : LayoutFlexibleBox(element)
     , m_buttonText(nullptr)
     , m_innerBlock(nullptr)
     , m_optionsChanged(true)
-    , m_isEmpty(false)
-    , m_hasUpdatedActiveOption(false)
-    , m_popupIsVisible(false)
     , m_optionsWidth(0)
     , m_lastActiveIndex(-1)
+    , m_popupIsVisible(false)
     , m_indexToSelectOnCancel(-1)
 {
     ASSERT(isHTMLSelectElement(element));
 }
 
 LayoutMenuList::~LayoutMenuList()
 {
     ASSERT(!m_popup);
 }
 
@@ skipping 16 matching lines @@
 {
     if (m_innerBlock) {
         ASSERT(firstChild() == m_innerBlock);
         ASSERT(!m_innerBlock->nextSibling());
         return;
     }
 
     // Create an anonymous block.
     ASSERT(!firstChild());
     m_innerBlock = createAnonymousBlock();
-
-    m_buttonText = new LayoutText(&document(), StringImpl::empty());
-    // We need to set the text explicitly though it was specified in the
-    // constructor because LayoutText doesn't refer to the text
-    // specified in the constructor in a case of re-transforming.
-    m_buttonText->setStyle(mutableStyle());
-    m_innerBlock->addChild(m_buttonText);
-
     adjustInnerStyle();
     LayoutFlexibleBox::addChild(m_innerBlock);
 }
 
 void LayoutMenuList::adjustInnerStyle()
 {
     ComputedStyle& innerStyle = m_innerBlock->mutableStyleRef();
     innerStyle.setFlexGrow(1);
     innerStyle.setFlexShrink(1);
     // min-width: 0; is needed for correct shrinking.
@@ skipping 21 matching lines @@
     }
 }
 
 inline HTMLSelectElement* LayoutMenuList::selectElement() const
 {
     return toHTMLSelectElement(node());
 }
 
 void LayoutMenuList::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
+    createInnerBlock();
     m_innerBlock->addChild(newChild, beforeChild);
     ASSERT(m_innerBlock == firstChild());
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->childrenChanged(this);
 }
 
 void LayoutMenuList::removeChild(LayoutObject* oldChild)
 {
     if (oldChild == m_innerBlock || !m_innerBlock) {
         LayoutFlexibleBox::removeChild(oldChild);
         m_innerBlock = nullptr;
     } else {
         m_innerBlock->removeChild(oldChild);
     }
 }
 
 void LayoutMenuList::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
 
-    if (!m_innerBlock)
-        createInnerBlock();
-
-    m_buttonText->setStyle(mutableStyle());
-    adjustInnerStyle();
+    if (m_buttonText)
+        m_buttonText->setStyle(mutableStyle());
+    if (m_innerBlock) // LayoutBlock handled updating the anonymous block's style.
+        adjustInnerStyle();
 
     bool fontChanged = !oldStyle || oldStyle->font() != style()->font();
     if (fontChanged)
         updateOptionsWidth();
 }
 
 void LayoutMenuList::updateOptionsWidth()
 {
     float maxOptionWidth = 0;
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = selectElement()->listItems();
@@ skipping 105 matching lines @@
     }
 
     setText(text.stripWhiteSpace());
 
     didUpdateActiveOption(optionIndex);
 }
 
 void LayoutMenuList::setText(const String& s)
 {
     if (s.isEmpty()) {
-        // FIXME: This is a hack. We need the select to have the same baseline positioning as
-        // any surrounding text. Wihtout any content, we align the bottom of the select to the bottom
-        // of the text. With content (In this case the faked " ") we correctly align the middle of
-        // the select to the middle of the text. It should be possible to remove this, just set
-        // s.impl() into the text and have things align correctly ...  crbug.com/485982
-        m_isEmpty = true;
-        m_buttonText->setText(StringImpl::create(" ", 1), true);
+        if (!m_buttonText || !m_buttonText->isBR()) {
+            // FIXME: We should not modify the structure of the layout tree
+            // during layout. crbug.com/370462
+            DeprecatedDisableModifyLayoutTreeStructureAsserts disabler;
+            if (m_buttonText)
+                m_buttonText->destroy();
+            m_buttonText = new LayoutBR(&document());
+            m_buttonText->setStyle(mutableStyle());
+            addChild(m_buttonText);
+        }
     } else {
-        m_isEmpty = false;
-        m_buttonText->setText(s.impl(), true);
+        if (m_buttonText && !m_buttonText->isBR()) {
+            m_buttonText->setText(s.impl(), true);
+        } else {
+            // FIXME: We should not modify the structure of the layout tree
+            // during layout. crbug.com/370462
+            DeprecatedDisableModifyLayoutTreeStructureAsserts disabler;
+            if (m_buttonText)
+                m_buttonText->destroy();
+            m_buttonText = new LayoutText(&document(), s.impl());
+            m_buttonText->setStyle(mutableStyle());
+            // We need to set the text explicitly though it was specified in the
+            // constructor because LayoutText doesn't refer to the text
+            // specified in the constructor in a case of re-transforming.
+            m_buttonText->setText(s.impl(), true);
+            addChild(m_buttonText);
+        }
+        adjustInnerStyle();
     }
-    adjustInnerStyle();
 }
 
 String LayoutMenuList::text() const
 {
-    return m_buttonText && !m_isEmpty ? m_buttonText->text() : String();
+    return m_buttonText ? m_buttonText->text() : String();
 }
 
 LayoutRect LayoutMenuList::controlClipRect(const LayoutPoint& additionalOffset) const
 {
     // Clip to the intersection of the content box and the content box for the inner box
     // This will leave room for the arrows which sit in the inner box padding,
     // and if the inner box ever spills out of the outer box, that will get clipped too.
     LayoutRect outerBox = contentBoxRect();
     outerBox.moveBy(additionalOffset);
 
@@ skipping 12 matching lines @@
 }
 
 void LayoutMenuList::showPopup()
 {
     if (m_popupIsVisible)
         return;
 
     if (document().frameHost()->chrome().hasOpenedPopup())
         return;
 
+    // Create m_innerBlock here so it ends up as the first child.
+    // This is important because otherwise we might try to create m_innerBlock
+    // inside the showPopup call and it would fail.
+    createInnerBlock();
     if (!m_popup)
         m_popup = document().frameHost()->chrome().createPopupMenu(*document().frame(), this);
     m_popupIsVisible = true;
 
     FloatQuad quad(localToAbsoluteQuad(FloatQuad(borderBoundingBox())));
     IntSize size = pixelSnappedIntRect(frameRect()).size();
     HTMLSelectElement* select = selectElement();
     m_popup->show(quad, size, select->optionToListIndex(select->selectedIndex()));
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->didShowMenuListPopup(this);
+
 }
 
 void LayoutMenuList::hidePopup()
 {
     if (m_popup)
         m_popup->hide();
 }
 
 void LayoutMenuList::valueChanged(unsigned listIndex, bool fireOnChange)
 {
@@ skipping 47 matching lines @@
         return;
 
     if (m_lastActiveIndex == optionIndex)
         return;
     m_lastActiveIndex = optionIndex;
 
     HTMLSelectElement* select = selectElement();
     int listIndex = select->optionToListIndex(optionIndex);
     if (listIndex < 0 || listIndex >= static_cast<int>(select->listItems().size()))
         return;
-
-    // We skip sending accessiblity notifications for the very first option, otherwise
-    // we get extra focus and select events that are undesired.
-    if (!m_hasUpdatedActiveOption) {
-        m_hasUpdatedActiveOption = true;
-        return;
-    }
-
     document().existingAXObjectCache()->handleUpdateActiveMenuOption(this, optionIndex);
 }
 
 String LayoutMenuList::itemText(unsigned listIndex) const
 {
     HTMLSelectElement* select = selectElement();
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = select->listItems();
     if (listIndex >= listItems.size())
         return String();
 
@@ skipping 175 matching lines @@
     HTMLElement* element = listItems[listIndex];
     return isHTMLOptionElement(*element) && toHTMLOptionElement(*element).selected();
 }
 
 void LayoutMenuList::provisionalSelectionChanged(unsigned listIndex)
 {
     setIndexToSelectOnCancel(listIndex);
 }
 
 } // namespace blink