Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/LayoutTheme.cpp

 /**
  * This file is part of the theme implementation for form controls in WebCore.
  *
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Computer, Inc.
  *
  * 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.
  *
@@ skipping 49 matching lines @@
 #include "public/platform/WebFallbackThemeEngine.h"
 #include "public/platform/WebRect.h"
 #include "wtf/text/StringBuilder.h"
 
 // The methods in this file are shared by all themes on every platform.
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static WebFallbackThemeEngine::State getWebFallbackThemeState(const LayoutTheme* theme, const RenderObject* o)
+static WebFallbackThemeEngine::State getWebFallbackThemeState(const LayoutTheme* theme, const LayoutObject* o)
 {
     if (!theme->isEnabled(o))
         return WebFallbackThemeEngine::StateDisabled;
     if (theme->isPressed(o))
         return WebFallbackThemeEngine::StatePressed;
     if (theme->isHovered(o))
         return WebFallbackThemeEngine::StateHover;
 
     return WebFallbackThemeEngine::StateNormal;
 }
@@ skipping 141 matching lines @@
         return adjustSearchFieldCancelButtonStyle(style, e);
     case SearchFieldDecorationPart:
         return adjustSearchFieldDecorationStyle(style, e);
     case SearchFieldResultsDecorationPart:
         return adjustSearchFieldResultsDecorationStyle(style, e);
     default:
         break;
     }
 }
 
-bool LayoutTheme::paint(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
+bool LayoutTheme::paint(LayoutObject* o, const PaintInfo& paintInfo, const IntRect& r)
 {
     ControlPart part = o->style()->appearance();
 
     if (shouldUseFallbackTheme(o->style()))
         return paintUsingFallbackTheme(o, paintInfo, r);
 
 #if USE(NEW_THEME)
     switch (part) {
     case CheckboxPart:
     case RadioPart:
@@ skipping 85 matching lines @@
         return paintSearchFieldDecoration(o, paintInfo, r);
     case SearchFieldResultsDecorationPart:
         return paintSearchFieldResultsDecoration(o, paintInfo, r);
     default:
         break;
     }
 
     return true; // We don't support the appearance, so let the normal background/border paint.
 }
 
-bool LayoutTheme::paintBorderOnly(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
+bool LayoutTheme::paintBorderOnly(LayoutObject* o, const PaintInfo& paintInfo, const IntRect& r)
 {
     // Call the appropriate paint method based off the appearance value.
     switch (o->style()->appearance()) {
     case TextFieldPart:
         return paintTextField(o, paintInfo, r);
     case TextAreaPart:
         return paintTextArea(o, paintInfo, r);
     case MenulistButtonPart:
     case SearchFieldPart:
     case ListboxPart:
@@ skipping 17 matching lines @@
     case SearchFieldCancelButtonPart:
     case SearchFieldDecorationPart:
     case SearchFieldResultsDecorationPart:
     default:
         break;
     }
 
     return false;
 }
 
-bool LayoutTheme::paintDecorations(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
+bool LayoutTheme::paintDecorations(LayoutObject* o, const PaintInfo& paintInfo, const IntRect& r)
 {
     // Call the appropriate paint method based off the appearance value.
     switch (o->style()->appearance()) {
     case MenulistButtonPart:
         return paintMenuListButton(o, paintInfo, r);
     case TextFieldPart:
     case TextAreaPart:
     case CheckboxPart:
     case RadioPart:
     case PushButtonPart:
@@ skipping 130 matching lines @@
 Color LayoutTheme::platformInactiveListBoxSelectionBackgroundColor() const
 {
     return platformInactiveSelectionBackgroundColor();
 }
 
 Color LayoutTheme::platformInactiveListBoxSelectionForegroundColor() const
 {
     return platformInactiveSelectionForegroundColor();
 }
 
-int LayoutTheme::baselinePosition(const RenderObject* o) const
+int LayoutTheme::baselinePosition(const LayoutObject* o) const
 {
     if (!o->isBox())
         return 0;
 
     const RenderBox* box = toRenderBox(o);
 
 #if USE(NEW_THEME)
     return box->size().height() + box->marginTop() + m_platformTheme->baselinePositionAdjustment(o->style()->appearance()) * o->style()->effectiveZoom();
 #else
     return box->size().height() + box->marginTop();
@@ skipping 46 matching lines @@
 
     case SliderHorizontalPart:
     case SliderVerticalPart:
         return style->boxShadow();
 
     default:
         return false;
     }
 }
 
-void LayoutTheme::adjustPaintInvalidationRect(const RenderObject* o, IntRect& r)
+void LayoutTheme::adjustPaintInvalidationRect(const LayoutObject* o, IntRect& r)
 {
 #if USE(NEW_THEME)
     m_platformTheme->inflateControlPaintRect(o->style()->appearance(), controlStatesForRenderer(o), r, o->style()->effectiveZoom());
 #endif
 }
 
-bool LayoutTheme::shouldDrawDefaultFocusRing(RenderObject* renderer) const
+bool LayoutTheme::shouldDrawDefaultFocusRing(LayoutObject* renderer) const
 {
     if (supportsFocusRing(renderer->style()))
         return false;
     Node* node = renderer->node();
     if (!node)
         return true;
     if (!renderer->style()->hasAppearance() && !node->isLink())
         return true;
     // We can't use LayoutTheme::isFocused because outline:auto might be
     // specified to non-:focus rulesets.
     if (node->focused() && !node->shouldHaveFocusAppearance())
         return false;
     return true;
 }
 
 bool LayoutTheme::supportsFocusRing(const RenderStyle* style) const
 {
     return (style->hasAppearance() && style->appearance() != TextFieldPart && style->appearance() != TextAreaPart && style->appearance() != MenulistButtonPart && style->appearance() != ListboxPart);
 }
 
-bool LayoutTheme::stateChanged(RenderObject* o, ControlState state) const
+bool LayoutTheme::stateChanged(LayoutObject* o, ControlState state) const
 {
     // Default implementation assumes the controls don't respond to changes in :hover state
     if (state == HoverControlState && !supportsHover(o->style()))
         return false;
 
     // Assume pressed state is only responded to if the control is enabled.
     if (state == PressedControlState && !isEnabled(o))
         return false;
 
     o->setShouldDoFullPaintInvalidation();
     return true;
 }
 
-ControlStates LayoutTheme::controlStatesForRenderer(const RenderObject* o) const
+ControlStates LayoutTheme::controlStatesForRenderer(const LayoutObject* o) const
 {
     ControlStates result = 0;
     if (isHovered(o)) {
         result |= HoverControlState;
         if (isSpinUpButtonPartHovered(o))
             result |= SpinUpControlState;
     }
     if (isPressed(o)) {
         result |= PressedControlState;
         if (isSpinUpButtonPartPressed(o))
             result |= SpinUpControlState;
     }
     if (isFocused(o) && o->style()->outlineStyleIsAuto())
         result |= FocusControlState;
     if (isEnabled(o))
         result |= EnabledControlState;
     if (isChecked(o))
         result |= CheckedControlState;
     if (isReadOnlyControl(o))
         result |= ReadOnlyControlState;
     if (!isActive(o))
         result |= WindowInactiveControlState;
     if (isIndeterminate(o))
         result |= IndeterminateControlState;
     return result;
 }
 
-bool LayoutTheme::isActive(const RenderObject* o) const
+bool LayoutTheme::isActive(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node)
         return false;
 
     Page* page = node->document().page();
     if (!page)
         return false;
 
     return page->focusController().isActive();
 }
 
-bool LayoutTheme::isChecked(const RenderObject* o) const
+bool LayoutTheme::isChecked(const LayoutObject* o) const
 {
     if (!isHTMLInputElement(o->node()))
         return false;
     return toHTMLInputElement(o->node())->shouldAppearChecked();
 }
 
-bool LayoutTheme::isIndeterminate(const RenderObject* o) const
+bool LayoutTheme::isIndeterminate(const LayoutObject* o) const
 {
     if (!isHTMLInputElement(o->node()))
         return false;
     return toHTMLInputElement(o->node())->shouldAppearIndeterminate();
 }
 
-bool LayoutTheme::isEnabled(const RenderObject* o) const
+bool LayoutTheme::isEnabled(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node || !node->isElementNode())
         return true;
     return !toElement(node)->isDisabledFormControl();
 }
 
-bool LayoutTheme::isFocused(const RenderObject* o) const
+bool LayoutTheme::isFocused(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node)
         return false;
 
     node = node->focusDelegate();
     Document& document = node->document();
     LocalFrame* frame = document.frame();
     return node == document.focusedElement() && node->focused() && node->shouldHaveFocusAppearance() && frame && frame->selection().isFocusedAndActive();
 }
 
-bool LayoutTheme::isPressed(const RenderObject* o) const
+bool LayoutTheme::isPressed(const LayoutObject* o) const
 {
     if (!o->node())
         return false;
     return o->node()->active();
 }
 
-bool LayoutTheme::isSpinUpButtonPartPressed(const RenderObject* o) const
+bool LayoutTheme::isSpinUpButtonPartPressed(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node || !node->active() || !node->isElementNode()
         || !toElement(node)->isSpinButtonElement())
         return false;
     SpinButtonElement* element = toSpinButtonElement(node);
     return element->upDownState() == SpinButtonElement::Up;
 }
 
-bool LayoutTheme::isReadOnlyControl(const RenderObject* o) const
+bool LayoutTheme::isReadOnlyControl(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node || !node->isElementNode() || !toElement(node)->isFormControlElement())
         return false;
     HTMLFormControlElement* element = toHTMLFormControlElement(node);
     return element->isReadOnly();
 }
 
-bool LayoutTheme::isHovered(const RenderObject* o) const
+bool LayoutTheme::isHovered(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node)
         return false;
     if (!node->isElementNode() || !toElement(node)->isSpinButtonElement())
         return node->hovered();
     SpinButtonElement* element = toSpinButtonElement(node);
     return element->hovered() && element->upDownState() != SpinButtonElement::Indeterminate;
 }
 
-bool LayoutTheme::isSpinUpButtonPartHovered(const RenderObject* o) const
+bool LayoutTheme::isSpinUpButtonPartHovered(const LayoutObject* o) const
 {
     Node* node = o->node();
     if (!node || !node->isElementNode() || !toElement(node)->isSpinButtonElement())
         return false;
     SpinButtonElement* element = toSpinButtonElement(node);
     return element->upDownState() == SpinButtonElement::Up;
 }
 
 #if !USE(NEW_THEME)
 
@@ skipping 43 matching lines @@
 IntSize LayoutTheme::meterSizeForBounds(const RenderMeter*, const IntRect& bounds) const
 {
     return bounds.size();
 }
 
 bool LayoutTheme::supportsMeter(ControlPart) const
 {
     return false;
 }
 
-bool LayoutTheme::paintMeter(RenderObject*, const PaintInfo&, const IntRect&)
+bool LayoutTheme::paintMeter(LayoutObject*, const PaintInfo&, const IntRect&)
 {
     return true;
 }
 
-void LayoutTheme::paintSliderTicks(RenderObject* o, const PaintInfo& paintInfo, const IntRect& rect)
+void LayoutTheme::paintSliderTicks(LayoutObject* o, const PaintInfo& paintInfo, const IntRect& rect)
 {
     Node* node = o->node();
     if (!isHTMLInputElement(node))
         return;
 
     HTMLInputElement* input = toHTMLInputElement(node);
     if (input->type() != InputTypeNames::range)
         return;
 
     HTMLDataListElement* dataList = input->dataList();
     if (!dataList)
         return;
 
     double min = input->minimum();
     double max = input->maximum();
     ControlPart part = o->style()->appearance();
     // We don't support ticks on alternate sliders like MediaVolumeSliders.
     if (part !=  SliderHorizontalPart && part != SliderVerticalPart)
         return;
     bool isHorizontal = part ==  SliderHorizontalPart;
 
     IntSize thumbSize;
-    RenderObject* thumbRenderer = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderThumb())->renderer();
+    LayoutObject* thumbRenderer = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderThumb())->renderer();
     if (thumbRenderer) {
         RenderStyle* thumbStyle = thumbRenderer->style();
         int thumbWidth = thumbStyle->width().intValue();
         int thumbHeight = thumbStyle->height().intValue();
         thumbSize.setWidth(isHorizontal ? thumbWidth : thumbHeight);
         thumbSize.setHeight(isHorizontal ? thumbHeight : thumbWidth);
     }
 
     IntSize tickSize = sliderTickSize();
     float zoomFactor = o->style()->effectiveZoom();
     FloatRect tickRect;
     int tickRegionSideMargin = 0;
     int tickRegionWidth = 0;
     IntRect trackBounds;
-    RenderObject* trackRenderer = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderTrack())->renderer();
+    LayoutObject* trackRenderer = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderTrack())->renderer();
     // We can ignoring transforms because transform is handled by the graphics context.
     if (trackRenderer)
         trackBounds = trackRenderer->absoluteBoundingBoxRectIgnoringTransforms();
     IntRect sliderBounds = o->absoluteBoundingBoxRectIgnoringTransforms();
 
     // Make position relative to the transformed ancestor element.
     trackBounds.setX(trackBounds.x() - sliderBounds.x() + rect.x());
     trackBounds.setY(trackBounds.y() - sliderBounds.y() + rect.y());
 
     if (isHorizontal) {
@@ skipping 284 matching lines @@
     switch (part) {
     case CheckboxPart:
         return adjustCheckboxStyleUsingFallbackTheme(style, e);
     case RadioPart:
         return adjustRadioStyleUsingFallbackTheme(style, e);
     default:
         break;
     }
 }
 
-bool LayoutTheme::paintUsingFallbackTheme(RenderObject* o, const PaintInfo& i, const IntRect& r)
+bool LayoutTheme::paintUsingFallbackTheme(LayoutObject* o, const PaintInfo& i, const IntRect& r)
 {
     ControlPart part = o->style()->appearance();
     switch (part) {
     case CheckboxPart:
         return paintCheckboxUsingFallbackTheme(o, i, r);
     case RadioPart:
         return paintRadioUsingFallbackTheme(o, i, r);
     default:
         break;
     }
     return true;
 }
 
 // static
 void LayoutTheme::setSizeIfAuto(RenderStyle* style, const IntSize& size)
 {
     if (style->width().isIntrinsicOrAuto())
         style->setWidth(Length(size.width(), Fixed));
     if (style->height().isAuto())
         style->setHeight(Length(size.height(), Fixed));
 }
 
-bool LayoutTheme::paintCheckboxUsingFallbackTheme(RenderObject* o, const PaintInfo& i, const IntRect& r)
+bool LayoutTheme::paintCheckboxUsingFallbackTheme(LayoutObject* o, const PaintInfo& i, const IntRect& r)
 {
     WebFallbackThemeEngine::ExtraParams extraParams;
     WebCanvas* canvas = i.context->canvas();
     extraParams.button.checked = isChecked(o);
     extraParams.button.indeterminate = isIndeterminate(o);
 
     float zoomLevel = o->style()->effectiveZoom();
     GraphicsContextStateSaver stateSaver(*i.context);
     IntRect unzoomedRect = r;
     if (zoomLevel != 1) {
@@ skipping 21 matching lines @@
     setSizeIfAuto(style, size);
 
     // padding - not honored by WinIE, needs to be removed.
     style->resetPadding();
 
     // border - honored by WinIE, but looks terrible (just paints in the control box and turns off the Windows XP theme)
     // for now, we will not honor it.
     style->resetBorder();
 }
 
-bool LayoutTheme::paintRadioUsingFallbackTheme(RenderObject* o, const PaintInfo& i, const IntRect& r)
+bool LayoutTheme::paintRadioUsingFallbackTheme(LayoutObject* o, const PaintInfo& i, const IntRect& r)
 {
     WebFallbackThemeEngine::ExtraParams extraParams;
     WebCanvas* canvas = i.context->canvas();
     extraParams.button.checked = isChecked(o);
     extraParams.button.indeterminate = isIndeterminate(o);
 
     float zoomLevel = o->style()->effectiveZoom();
     GraphicsContextStateSaver stateSaver(*i.context);
     IntRect unzoomedRect = r;
     if (zoomLevel != 1) {
@@ skipping 22 matching lines @@
 
     // padding - not honored by WinIE, needs to be removed.
     style->resetPadding();
 
     // border - honored by WinIE, but looks terrible (just paints in the control box and turns off the Windows XP theme)
     // for now, we will not honor it.
     style->resetBorder();
 }
 
 } // namespace blink