Move rendering/RenderTextControl* to layout/LayoutTextControl*

Source/core/layout/LayoutTextControl.cpp

 /**
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2008 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
-#include "core/rendering/RenderTextControl.h"
+#include "core/layout/LayoutTextControl.h"
 
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/TextRunConstructor.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "wtf/unicode/CharacterNames.h"
 
 namespace blink {
 
-RenderTextControl::RenderTextControl(HTMLTextFormControlElement* element)
+LayoutTextControl::LayoutTextControl(HTMLTextFormControlElement* element)
     : RenderBlockFlow(element)
 {
     ASSERT(element);
 }
 
-RenderTextControl::~RenderTextControl()
+LayoutTextControl::~LayoutTextControl()
 {
 }
 
-HTMLTextFormControlElement* RenderTextControl::textFormControlElement() const
+HTMLTextFormControlElement* LayoutTextControl::textFormControlElement() const
 {
     return toHTMLTextFormControlElement(node());
 }
 
-HTMLElement* RenderTextControl::innerEditorElement() const
+HTMLElement* LayoutTextControl::innerEditorElement() const
 {
     return textFormControlElement()->innerEditorElement();
 }
 
-void RenderTextControl::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
+void LayoutTextControl::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     // FIXME: This is a terrible hack to get the caret over the placeholder text since it'll
     // make us paint the placeholder first. (See https://trac.webkit.org/changeset/118733)
     Node* node = newChild->node();
     if (node && node->isElementNode() && toElement(node)->shadowPseudoId() == "-webkit-input-placeholder")
         RenderBlockFlow::addChild(newChild, firstChild());
     else
         RenderBlockFlow::addChild(newChild, beforeChild);
 }
 
-void RenderTextControl::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutTextControl::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
     RenderBlockFlow::styleDidChange(diff, oldStyle);
     Element* innerEditor = innerEditorElement();
     if (!innerEditor)
         return;
     RenderBlock* innerEditorRenderer = toRenderBlock(innerEditor->renderer());
     if (innerEditorRenderer) {
         // We may have set the width and the height in the old style in layout().
         // Reset them now to avoid getting a spurious layout hint.
         innerEditorRenderer->style()->setHeight(Length());
         innerEditorRenderer->style()->setWidth(Length());
         innerEditorRenderer->setStyle(createInnerEditorStyle(styleRef()));
         innerEditor->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Control));
     }
     textFormControlElement()->updatePlaceholderVisibility(false);
 }
 
 static inline void updateUserModifyProperty(HTMLTextFormControlElement& node, LayoutStyle& style)
 {
     style.setUserModify(node.isDisabledOrReadOnly() ? READ_ONLY : READ_WRITE_PLAINTEXT_ONLY);
 }
 
-void RenderTextControl::adjustInnerEditorStyle(LayoutStyle& textBlockStyle) const
+void LayoutTextControl::adjustInnerEditorStyle(LayoutStyle& textBlockStyle) const
 {
     // The inner block, if present, always has its direction set to LTR,
     // so we need to inherit the direction and unicode-bidi style from the element.
     textBlockStyle.setDirection(style()->direction());
     textBlockStyle.setUnicodeBidi(style()->unicodeBidi());
 
     updateUserModifyProperty(*textFormControlElement(), textBlockStyle);
 }
 
-int RenderTextControl::textBlockLogicalHeight() const
+int LayoutTextControl::textBlockLogicalHeight() const
 {
     return logicalHeight() - borderAndPaddingLogicalHeight();
 }
 
-int RenderTextControl::textBlockLogicalWidth() const
+int LayoutTextControl::textBlockLogicalWidth() const
 {
     Element* innerEditor = innerEditorElement();
     ASSERT(innerEditor);
 
     LayoutUnit unitWidth = logicalWidth() - borderAndPaddingLogicalWidth();
     if (innerEditor->renderer())
         unitWidth -= innerEditor->renderBox()->paddingStart() + innerEditor->renderBox()->paddingEnd();
 
     return unitWidth;
 }
 
-void RenderTextControl::updateFromElement()
+void LayoutTextControl::updateFromElement()
 {
     Element* innerEditor = innerEditorElement();
     if (innerEditor && innerEditor->renderer())
         updateUserModifyProperty(*textFormControlElement(), innerEditor->renderer()->mutableStyleRef());
 }
 
-int RenderTextControl::scrollbarThickness() const
+int LayoutTextControl::scrollbarThickness() const
 {
     // FIXME: We should get the size of the scrollbar from the LayoutTheme instead.
     return ScrollbarTheme::theme()->scrollbarThickness();
 }
 
-void RenderTextControl::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
+void LayoutTextControl::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     HTMLElement* innerEditor = innerEditorElement();
     ASSERT(innerEditor);
     if (RenderBox* innerEditorBox = innerEditor->renderBox()) {
         LayoutUnit nonContentHeight = innerEditorBox->borderAndPaddingHeight() + innerEditorBox->marginHeight();
         logicalHeight = computeControlLogicalHeight(innerEditorBox->lineHeight(true, HorizontalLine, PositionOfInteriorLineBoxes), nonContentHeight);
 
         // We are able to have a horizontal scrollbar if the overflow style is scroll, or if its auto and there's no word wrap.
         if ((isHorizontalWritingMode() && (style()->overflowX() == OSCROLL ||  (style()->overflowX() == OAUTO && innerEditor->renderer()->style()->overflowWrap() == NormalOverflowWrap)))
             || (!isHorizontalWritingMode() && (style()->overflowY() == OSCROLL ||  (style()->overflowY() == OAUTO && innerEditor->renderer()->style()->overflowWrap() == NormalOverflowWrap))))
             logicalHeight += scrollbarThickness();
 
         // FIXME: The logical height of the inner text box should have been added before calling computeLogicalHeight to
         // avoid this hack.
         setIntrinsicContentLogicalHeight(logicalHeight);
 
         logicalHeight += borderAndPaddingHeight();
     }
 
     RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
 }
 
-void RenderTextControl::hitInnerEditorElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset)
+void LayoutTextControl::hitInnerEditorElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset)
 {
     HTMLElement* innerEditor = innerEditorElement();
     if (!innerEditor->renderer())
         return;
 
     LayoutPoint adjustedLocation = accumulatedOffset + location();
     LayoutPoint localPoint = pointInContainer - toLayoutSize(adjustedLocation + innerEditor->renderBox()->location());
     if (hasOverflowClip())
         localPoint += scrolledContentOffset();
     result.setInnerNode(innerEditor);
@@ skipping 36 matching lines @@
     "#HeadLineA",
     "#PCMyungjo",
     "#PilGi",
 };
 
 // For font families where any of the fonts don't have a valid entry in the OS/2 table
 // for avgCharWidth, fallback to the legacy webkit behavior of getting the avgCharWidth
 // from the width of a '0'. This only seems to apply to a fixed number of Mac fonts,
 // but, in order to get similar rendering across platforms, we do this check for
 // all platforms.
-bool RenderTextControl::hasValidAvgCharWidth(AtomicString family)
+bool LayoutTextControl::hasValidAvgCharWidth(AtomicString family)
 {
     static HashSet<AtomicString>* fontFamiliesWithInvalidCharWidthMap = 0;
 
     if (family.isEmpty())
         return false;
 
     if (!fontFamiliesWithInvalidCharWidthMap) {
         fontFamiliesWithInvalidCharWidthMap = new HashSet<AtomicString>;
 
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontFamiliesWithInvalidCharWidth); ++i)
             fontFamiliesWithInvalidCharWidthMap->add(AtomicString(fontFamiliesWithInvalidCharWidth[i]));
     }
 
     return !fontFamiliesWithInvalidCharWidthMap->contains(family);
 }
 
-float RenderTextControl::getAvgCharWidth(AtomicString family)
+float LayoutTextControl::getAvgCharWidth(AtomicString family)
 {
     if (hasValidAvgCharWidth(family))
         return roundf(style()->font().primaryFont()->avgCharWidth());
 
     const UChar ch = '0';
     const String str = String(&ch, 1);
     const Font& font = style()->font();
     TextRun textRun = constructTextRun(this, font, str, styleRef(), TextRun::AllowTrailingExpansion);
     return font.width(textRun);
 }
 
-float RenderTextControl::scaleEmToUnits(int x) const
+float LayoutTextControl::scaleEmToUnits(int x) const
 {
     // This matches the unitsPerEm value for MS Shell Dlg and Courier New from the "head" font table.
     float unitsPerEm = 2048.0f;
     return roundf(style()->font().fontDescription().computedSize() * x / unitsPerEm);
 }
 
-void RenderTextControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
+void LayoutTextControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     // Use average character width. Matches IE.
     AtomicString family = style()->font().fontDescription().family().family();
-    maxLogicalWidth = preferredContentLogicalWidth(const_cast<RenderTextControl*>(this)->getAvgCharWidth(family));
+    maxLogicalWidth = preferredContentLogicalWidth(const_cast<LayoutTextControl*>(this)->getAvgCharWidth(family));
     if (RenderBox* innerEditorRenderBox = innerEditorElement()->renderBox())
         maxLogicalWidth += innerEditorRenderBox->paddingStart() + innerEditorRenderBox->paddingEnd();
     if (!style()->logicalWidth().isPercent())
         minLogicalWidth = maxLogicalWidth;
 }
 
-void RenderTextControl::computePreferredLogicalWidths()
+void LayoutTextControl::computePreferredLogicalWidths()
 {
     ASSERT(preferredLogicalWidthsDirty());
 
     m_minPreferredLogicalWidth = 0;
     m_maxPreferredLogicalWidth = 0;
     const LayoutStyle& styleToUse = styleRef();
 
     if (styleToUse.logicalWidth().isFixed() && styleToUse.logicalWidth().value() >= 0)
         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalWidth().value());
     else
@@ skipping 10 matching lines @@
     }
 
     LayoutUnit toAdd = borderAndPaddingLogicalWidth();
 
     m_minPreferredLogicalWidth += toAdd;
     m_maxPreferredLogicalWidth += toAdd;
 
     clearPreferredLogicalWidthsDirty();
 }
 
-void RenderTextControl::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset) const
+void LayoutTextControl::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset) const
 {
     if (!size().isEmpty())
         rects.append(LayoutRect(additionalOffset, size()));
 }
 
-LayoutObject* RenderTextControl::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
+LayoutObject* LayoutTextControl::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     HTMLElement* placeholder = toHTMLTextFormControlElement(node())->placeholderElement();
     LayoutObject* placeholderRenderer = placeholder ? placeholder->renderer() : 0;
     if (!placeholderRenderer)
         return 0;
     if (relayoutChildren)
         layoutScope.setChildNeedsLayout(placeholderRenderer);
     return placeholderRenderer;
 }
 
 } // namespace blink