Rename LayoutStyle to papayawhip

Source/core/layout/LayoutMenuList.cpp

 /*
  * This file is part of the select element renderer 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 11 matching lines @@
  *
  */
 
 #include "config.h"
 #include "core/layout/LayoutMenuList.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AXObjectCache.h"
-#include "core/dom/NodeLayoutStyle.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLOptGroupElement.h"
 #include "core/html/HTMLOptionElement.h"
 #include "core/html/HTMLSelectElement.h"
 #include "core/layout/LayoutBR.h"
 #include "core/layout/LayoutScrollbar.h"
 #include "core/layout/LayoutTheme.h"
@@ skipping 28 matching lines @@
 void LayoutMenuList::destroy()
 {
     if (m_popup)
         m_popup->disconnectClient();
     m_popup = nullptr;
     LayoutFlexibleBox::destroy();
 }
 
 // FIXME: Instead of this hack we should add a ShadowRoot to <select> with no insertion point
 // to prevent children from rendering.
-bool LayoutMenuList::isChildAllowed(LayoutObject* object, const LayoutStyle&) const
+bool LayoutMenuList::isChildAllowed(LayoutObject* object, const ComputedStyle&) const
 {
     return object->isAnonymous() && !object->isLayoutFullScreen();
 }
 
 void LayoutMenuList::createInnerBlock()
 {
     if (m_innerBlock) {
         ASSERT(firstChild() == m_innerBlock);
         ASSERT(!m_innerBlock->nextSibling());
         return;
     }
 
     // Create an anonymous block.
     ASSERT(!firstChild());
     m_innerBlock = createAnonymousBlock();
     adjustInnerStyle();
     LayoutFlexibleBox::addChild(m_innerBlock);
 }
 
 void LayoutMenuList::adjustInnerStyle()
 {
-    LayoutStyle& innerStyle = m_innerBlock->mutableStyleRef();
+    ComputedStyle& innerStyle = m_innerBlock->mutableStyleRef();
     innerStyle.setFlexGrow(1);
     innerStyle.setFlexShrink(1);
     // Use margin:auto instead of align-items:center to get safe centering, i.e.
     // when the content overflows, treat it the same as align-items: flex-start.
     // But we only do that for the cases where html.css would otherwise use center.
     if (style()->alignItems() == ItemPositionCenter) {
         innerStyle.setMarginTop(Length());
         innerStyle.setMarginBottom(Length());
         innerStyle.setAlignSelf(ItemPositionFlexStart);
     }
@@ skipping 30 matching lines @@
 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 LayoutStyle* oldStyle)
+void LayoutMenuList::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
 
     if (m_buttonText)
         m_buttonText->setStyle(style());
     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();
     int size = listItems.size();
 
     for (int i = 0; i < size; ++i) {
         HTMLElement* element = listItems[i];
         if (!isHTMLOptionElement(*element))
             continue;
 
         String text = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
         applyTextTransform(style(), text, ' ');
         if (LayoutTheme::theme().popupOptionSupportsTextIndent()) {
             // Add in the option's text indent.  We can't calculate percentage values for now.
             float optionWidth = 0;
-            if (const LayoutStyle* optionStyle = element->layoutStyle())
+            if (const ComputedStyle* optionStyle = element->computedStyle())
                 optionWidth += minimumValueForLength(optionStyle->textIndent(), 0);
             if (!text.isEmpty())
                 optionWidth += style()->font().width(text);
             maxOptionWidth = std::max(maxOptionWidth, optionWidth);
         } else if (!text.isEmpty()) {
             maxOptionWidth = std::max(maxOptionWidth, style()->font().width(text));
         }
     }
 
     int width = static_cast<int>(ceilf(maxOptionWidth));
@@ skipping 43 matching lines @@
                     firstSelectedIndex = i;
             }
         }
 
         if (selectedCount == 1) {
             ASSERT(0 <= firstSelectedIndex);
             ASSERT(firstSelectedIndex < size);
             HTMLOptionElement* selectedOptionElement = toHTMLOptionElement(listItems[firstSelectedIndex]);
             ASSERT(selectedOptionElement->selected());
             text = selectedOptionElement->textIndentedToRespectGroupLabel();
-            m_optionStyle = selectedOptionElement->mutableLayoutStyle();
+            m_optionStyle = selectedOptionElement->mutableComputedStyle();
         } else {
             Locale& locale = select->locale();
             String localizedNumberString = locale.convertToLocalizedNumber(String::number(selectedCount));
             text = locale.queryString(WebLocalizedString::SelectMenuListText, localizedNumberString);
             ASSERT(!m_optionStyle);
         }
     } else {
         const int i = select->optionToListIndex(optionIndex);
         if (i >= 0 && i < size) {
             Element* element = listItems[i];
             if (isHTMLOptionElement(*element)) {
                 text = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
-                m_optionStyle = element->mutableLayoutStyle();
+                m_optionStyle = element->mutableComputedStyle();
             }
         }
     }
 
     setText(text.stripWhiteSpace());
 
     didUpdateActiveOption(optionIndex);
 }
 
 void LayoutMenuList::setText(const String& s)
@@ skipping 113 matching lines @@
 IntRect LayoutMenuList::elementRectRelativeToViewport() const
 {
     return selectElement()->document().view()->contentsToViewport(absoluteBoundingBoxRect());
 }
 
 Element& LayoutMenuList::ownerElement() const
 {
     return *selectElement();
 }
 
-const LayoutStyle* LayoutMenuList::layoutStyleForItem(Element& element) const
+const ComputedStyle* LayoutMenuList::computedStyleForItem(Element& element) const
 {
     document().updateRenderTreeIfNeeded();
-    return element.layoutStyle() ? element.layoutStyle() : element.computedStyle();
+    return element.computedStyle() ? element.computedStyle() : element.ensureComputedStyle();
 }
 
 void LayoutMenuList::didSetSelectedIndex(int listIndex)
 {
     didUpdateActiveOption(selectElement()->listToOptionIndex(listIndex));
 }
 
 void LayoutMenuList::didUpdateActiveOption(int optionIndex)
 {
     if (!document().existingAXObjectCache())
@@ skipping 77 matching lines @@
 
         // Try to retrieve the style of an option element we know exists (index 0).
         listIndex = 0;
     }
     HTMLElement* element = listItems[listIndex];
 
     Color itemBackgroundColor;
     bool itemHasCustomBackgroundColor;
     getItemBackgroundColor(listIndex, itemBackgroundColor, itemHasCustomBackgroundColor);
 
-    const LayoutStyle* style = element->layoutStyle() ? element->layoutStyle() : element->computedStyle();
+    const ComputedStyle* style = element->computedStyle() ? element->computedStyle() : element->ensureComputedStyle();
     return style ? PopupMenuStyle(resolveColor(*style, CSSPropertyColor), itemBackgroundColor, style->font(), style->visibility() == VISIBLE,
         isHTMLOptionElement(*element) ? toHTMLOptionElement(*element).isDisplayNone() : style->display() == NONE,
         style->textIndent(), style->direction(), isOverride(style->unicodeBidi()),
         itemHasCustomBackgroundColor ? PopupMenuStyle::CustomBackgroundColor : PopupMenuStyle::DefaultBackgroundColor) : menuStyle();
 }
 
 void LayoutMenuList::getItemBackgroundColor(unsigned listIndex, Color& itemBackgroundColor, bool& itemHasCustomBackgroundColor) const
 {
     const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = selectElement()->listItems();
     if (listIndex >= listItems.size()) {
         itemBackgroundColor = resolveColor(CSSPropertyBackgroundColor);
         itemHasCustomBackgroundColor = false;
         return;
     }
     HTMLElement* element = listItems[listIndex];
 
     Color backgroundColor;
-    if (const LayoutStyle* style = element->layoutStyle())
+    if (const ComputedStyle* style = element->computedStyle())
         backgroundColor = resolveColor(*style, CSSPropertyBackgroundColor);
     itemHasCustomBackgroundColor = backgroundColor.alpha();
     // If the item has an opaque background color, return that.
     if (!backgroundColor.hasAlpha()) {
         itemBackgroundColor = backgroundColor;
         return;
     }
 
     // Otherwise, the item's background is overlayed on top of the menu background.
     backgroundColor = resolveColor(CSSPropertyBackgroundColor).blend(backgroundColor);
     if (!backgroundColor.hasAlpha()) {
         itemBackgroundColor = backgroundColor;
         return;
     }
 
     // If the menu background is not opaque, then add an opaque white background behind.
     itemBackgroundColor = Color(Color::white).blend(backgroundColor);
 }
 
 PopupMenuStyle LayoutMenuList::menuStyle() const
 {
     const LayoutObject* o = m_innerBlock ? m_innerBlock : this;
-    const LayoutStyle& style = o->styleRef();
+    const ComputedStyle& style = o->styleRef();
     return PopupMenuStyle(o->resolveColor(CSSPropertyColor), o->resolveColor(CSSPropertyBackgroundColor), style.font(), style.visibility() == VISIBLE,
         style.display() == NONE, style.textIndent(), style.direction(), isOverride(style.unicodeBidi()));
 }
 
 LayoutUnit LayoutMenuList::clientPaddingLeft() const
 {
     return paddingLeft() + m_innerBlock->paddingLeft();
 }
 
 const int endOfLinePadding = 2;
@@ skipping 50 matching lines @@
     HTMLElement* element = listItems[listIndex];
     return isHTMLOptionElement(*element) && toHTMLOptionElement(*element).selected();
 }
 
 void LayoutMenuList::setTextFromItem(unsigned listIndex)
 {
     setTextFromOption(selectElement()->listToOptionIndex(listIndex));
 }
 
 } // namespace blink