Changeset 155374 in webkit


Ignore:
Timestamp:
Sep 9, 2013, 12:54:33 PM (11 years ago)
Author:
Antti Koivisto
Message:

Hide node() below RenderLayerModelObject, use element() instead
​https://bugs.webkit.org/show_bug.cgi?id=121038

Reviewed by Dave Hyatt.

Switch all call sites to element(). Remove now unnecessary casts, type checks and dead code.
Make constructors below RenderLayerModelObject take an Element instead of a ContainerNode.

This also removes a branch from many hasTagName() and isFooElement() calls.

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::startOfContinuations):

  • accessibility/AccessibilityTable.cpp:

(WebCore::AccessibilityTable::isDataTable):

  • accessibility/AccessibilityTableCell.cpp:

(WebCore::AccessibilityTableCell::titleUIElement):

  • accessibility/AccessibilityTableColumn.cpp:

(WebCore::AccessibilityTableColumn::headerObjectForSection):

  • editing/markup.cpp:

(WebCore::highestAncestorToWrapMarkup):

  • html/HTMLTableCellElement.cpp:

(WebCore::HTMLTableCellElement::cellAbove):

  • html/shadow/SliderThumbElement.cpp:

(WebCore::RenderSliderThumb::updateAppearance):
(WebCore::RenderSliderContainer::computeLogicalHeight):
(WebCore::RenderSliderContainer::layout):

  • page/Frame.cpp:

(WebCore::Frame::frameForWidget):

  • rendering/RenderBlock.cpp:

(WebCore::OverflowEventDispatcher::~OverflowEventDispatcher):
(WebCore::RenderBlock::RenderBlock):
(WebCore::RenderBlock::clone):
(WebCore::RenderBlock::createReplacementRunIn):
(WebCore::RenderBlock::paintObject):
(WebCore::RenderBlock::isSelectionRoot):
(WebCore::RenderBlock::nodeForHitTest):
(WebCore::RenderBlock::hasLineIfEmpty):
(WebCore::RenderBlock::addFocusRingRects):

  • rendering/RenderBlock.h:
  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::RenderBlockFlow):

  • rendering/RenderBlockFlow.h:
  • rendering/RenderBlockLineLayout.cpp:

(WebCore::RenderBlock::addOverflowFromInlineChildren):

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::RenderBox):
(WebCore::RenderBox::updateFromStyle):
(WebCore::RenderBox::scroll):
(WebCore::RenderBox::logicalScroll):
(WebCore::RenderBox::canBeProgramaticallyScrolled):
(WebCore::RenderBox::nodeAtPoint):
(WebCore::RenderBox::paintCustomHighlight):
(WebCore::RenderBox::computeLogicalWidthInRegion):
(WebCore::RenderBox::sizesLogicalWidthToFitContent):
(WebCore::RenderBox::localCaretRect):

  • rendering/RenderBox.h:
  • rendering/RenderBoxModelObject.cpp:

(WebCore::RenderBoxModelObject::RenderBoxModelObject):

  • rendering/RenderBoxModelObject.h:
  • rendering/RenderButton.cpp:

(WebCore::RenderButton::updateFromElement):
(WebCore::RenderButton::canHaveGeneratedChildren):

  • rendering/RenderButton.h:
  • rendering/RenderEmbeddedObject.cpp:

(WebCore::RenderEmbeddedObject::paintContents):
(WebCore::RenderEmbeddedObject::isReplacementObscured):
(WebCore::RenderEmbeddedObject::layout):
(WebCore::RenderEmbeddedObject::viewCleared):
(WebCore::RenderEmbeddedObject::handleUnavailablePluginIndicatorEvent):

  • rendering/RenderFileUploadControl.cpp:

(WebCore::RenderFileUploadControl::updateFromElement):
(WebCore::RenderFileUploadControl::maxFilenameWidth):
(WebCore::RenderFileUploadControl::paintObject):
(WebCore::RenderFileUploadControl::computeIntrinsicLogicalWidths):
(WebCore::RenderFileUploadControl::uploadButton):
(WebCore::RenderFileUploadControl::fileTextValue):

  • rendering/RenderFrame.cpp:

(WebCore::RenderFrame::edgeInfo):
(WebCore::RenderFrame::viewCleared):

  • rendering/RenderFrameBase.cpp:

(WebCore::RenderFrameBase::layoutWithFlattening):

  • rendering/RenderFrameSet.cpp:

(WebCore::RenderFrameSet::frameSet):

  • rendering/RenderHTMLCanvas.cpp:

(WebCore::RenderHTMLCanvas::requiresLayer):
(WebCore::RenderHTMLCanvas::paintReplaced):
(WebCore::RenderHTMLCanvas::canvasSizeChanged):

  • rendering/RenderIFrame.cpp:

(WebCore::RenderIFrame::isSeamless):
(WebCore::RenderIFrame::flattenFrame):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::imageChanged):
(WebCore::RenderImage::paintAreaElementFocusRing):
(WebCore::RenderImage::areaElementFocusChanged):
(WebCore::RenderImage::paintIntoRect):
(WebCore::RenderImage::imageMap):
(WebCore::RenderImage::nodeAtPoint):
(WebCore::RenderImage::updateAltText):

  • rendering/RenderInline.cpp:

(WebCore::RenderInline::clone):
(WebCore::RenderInline::hitTestCulledInline):
(WebCore::RenderInline::updateHitTestResult):

  • rendering/RenderInline.h:
  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::RenderLayer):
(WebCore::RenderLayer::~RenderLayer):
(WebCore::RenderLayer::name):
(WebCore::RenderLayer::isTransparent):
(WebCore::RenderLayer::scrollTo):
(WebCore::RenderLayer::resize):
(WebCore::RenderLayer::filterNeedsRepaint):

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
(WebCore::RenderLayerBacking::updateGraphicsLayerConfiguration):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::frameContentsCompositor):

  • rendering/RenderLayerFilterInfo.cpp:

(WebCore::RenderLayer::FilterInfo::notifyFinished):
(WebCore::RenderLayer::FilterInfo::updateReferenceFilterClients):
(WebCore::RenderLayer::FilterInfo::notifyCustomFilterProgramLoaded):

  • rendering/RenderLayerModelObject.cpp:

(WebCore::RenderLayerModelObject::RenderLayerModelObject):

  • rendering/RenderLayerModelObject.h:

(WebCore::RenderLayerModelObject::element):

  • rendering/RenderListBox.cpp:

(WebCore::RenderListBox::selectElement):
(WebCore::RenderListBox::paintItemForeground):
(WebCore::RenderListBox::paintItemBackground):
(WebCore::RenderListBox::scrollTo):
(WebCore::RenderListBox::createScrollbar):

  • rendering/RenderListItem.cpp:

(WebCore::isList):
(WebCore::enclosingList):
(WebCore::nextListItem):
(WebCore::previousListItem):
(WebCore::RenderListItem::calcValue):
(WebCore::RenderListItem::explicitValueChanged):
(WebCore::RenderListItem::setExplicitValue):
(WebCore::RenderListItem::clearExplicitValue):
(WebCore::previousOrNextItem):
(WebCore::RenderListItem::updateListMarkerNumbers):

  • rendering/RenderMarquee.cpp:

(WebCore::RenderMarquee::marqueeSpeed):

  • rendering/RenderMedia.cpp:

(WebCore::RenderMedia::mediaElement):

  • rendering/RenderMediaControlElements.cpp:

(WebCore::RenderMediaControlTimelineContainer::layout):
(WebCore::RenderTextTrackContainerElement::layout):

  • rendering/RenderMenuList.cpp:

(WebCore::RenderMenuList::selectElement):
(WebCore::RenderMenuList::valueChanged):
(WebCore::RenderMenuList::createScrollbar):

  • rendering/RenderMeter.cpp:

(WebCore::RenderMeter::meterElement):

  • rendering/RenderPart.cpp:

(WebCore::RenderPart::requiresAcceleratedCompositing):
(WebCore::RenderPart::embeddedContentBox):

  • rendering/RenderProgress.cpp:

(WebCore::RenderProgress::progressElement):

  • rendering/RenderReplaced.cpp:

(WebCore::RenderReplaced::positionForPoint):
(WebCore::RenderReplaced::isSelected):

  • rendering/RenderSearchField.cpp:

(WebCore::RenderSearchField::autosaveName):
(WebCore::RenderSearchField::createScrollbar):

  • rendering/RenderSlider.cpp:

(WebCore::RenderSlider::layout):
(WebCore::RenderSlider::inDragMode):

  • rendering/RenderSnapshottedPlugIn.cpp:

(WebCore::RenderSnapshottedPlugIn::plugInImageElement):

  • rendering/RenderTable.cpp:

(WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
(WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
(WebCore::RenderTable::nodeAtPoint):

  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::parseColSpanFromDOM):
(WebCore::RenderTableCell::parseRowSpanFromDOM):
(WebCore::RenderTableCell::updateColAndRowSpanFlags):
(WebCore::RenderTableCell::colSpanOrRowSpanChanged):
(WebCore::RenderTableCell::computePreferredLogicalWidths):

  • rendering/RenderTableCol.cpp:

(WebCore::RenderTableCol::updateFromElement):

  • rendering/RenderTextControl.cpp:

(WebCore::RenderTextControl::textFormControlElement):
(WebCore::RenderTextControl::adjustInnerTextStyle):
(WebCore::RenderTextControl::updateFromElement):
(WebCore::RenderTextControl::layoutSpecialExcludedChild):

  • rendering/RenderTextControlMultiLine.cpp:

(WebCore::RenderTextControlMultiLine::~RenderTextControlMultiLine):
(WebCore::RenderTextControlMultiLine::nodeAtPoint):
(WebCore::RenderTextControlMultiLine::preferredContentLogicalWidth):
(WebCore::RenderTextControlMultiLine::computeControlLogicalHeight):

  • rendering/RenderTextControlSingleLine.cpp:

(WebCore::RenderTextControlSingleLine::nodeAtPoint):
(WebCore::RenderTextControlSingleLine::capsLockStateMayHaveChanged):
(WebCore::RenderTextControlSingleLine::textShouldBeTruncated):
(WebCore::RenderTextControlSingleLine::inputElement):

  • rendering/RenderThemeMac.mm:

(WebCore::RenderThemeMac::paintSnapshottedPluginOverlay):

  • rendering/RenderTreeAsText.cpp:

(WebCore::writeRenderRegionList):

  • rendering/RenderVideo.cpp:

(WebCore::RenderVideo::updateIntrinsicSize):
(WebCore::RenderVideo::videoElement):

  • rendering/RenderWidget.cpp:

(WebCore::RenderWidget::setWidgetGeometry):
(WebCore::RenderWidget::updateWidgetPosition):
(WebCore::RenderWidget::nodeAtPoint):

  • rendering/mathml/RenderMathMLFenced.cpp:

(WebCore::RenderMathMLFenced::updateFromElement):
(WebCore::RenderMathMLFenced::createMathMLOperator):
(WebCore::RenderMathMLFenced::styleDidChange):

  • rendering/mathml/RenderMathMLFraction.cpp:

(WebCore::RenderMathMLFraction::updateFromElement):

  • rendering/mathml/RenderMathMLOperator.cpp:

(WebCore::RenderMathMLOperator::updateFromElement):
(WebCore::RenderMathMLOperator::createGlyph):

  • rendering/mathml/RenderMathMLSpace.cpp:

(WebCore::RenderMathMLSpace::updateFromElement):

  • rendering/svg/RenderSVGForeignObject.cpp:

(WebCore::RenderSVGForeignObject::layout):

  • rendering/svg/RenderSVGRoot.cpp:

(WebCore::RenderSVGRoot::computeIntrinsicRatioInformation):
(WebCore::RenderSVGRoot::isEmbeddedThroughSVGImage):
(WebCore::RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument):
(WebCore::RenderSVGRoot::computeReplacedLogicalWidth):
(WebCore::RenderSVGRoot::computeReplacedLogicalHeight):
(WebCore::RenderSVGRoot::layout):
(WebCore::RenderSVGRoot::paintReplaced):
(WebCore::RenderSVGRoot::buildLocalToBorderBoxTransform):
(WebCore::RenderSVGRoot::nodeAtPoint):
(WebCore::RenderSVGRoot::hasRelativeDimensions):
(WebCore::RenderSVGRoot::hasRelativeIntrinsicLogicalWidth):
(WebCore::RenderSVGRoot::hasRelativeLogicalHeight):

  • rendering/svg/RenderSVGText.cpp:

(WebCore::RenderSVGText::layout):
(WebCore::RenderSVGText::strokeBoundingBox):

  • rendering/svg/RenderSVGTextPath.cpp:

(WebCore::RenderSVGTextPath::layoutPath):
(WebCore::RenderSVGTextPath::startOffset):
(WebCore::RenderSVGTextPath::exactAlignment):
(WebCore::RenderSVGTextPath::stretchMethod):

Location:
trunk/Source/WebCore
Files:
67 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r155370 r155374  
     12013-09-09  Antti Koivisto  <antti@apple.com>
     2
     3        Hide node() below RenderLayerModelObject, use element() instead
     4        https://bugs.webkit.org/show_bug.cgi?id=121038
     5
     6        Reviewed by Dave Hyatt.
     7
     8        Switch all call sites to element(). Remove now unnecessary casts, type checks and dead code.
     9        Make constructors below RenderLayerModelObject take an Element instead of a ContainerNode.
     10       
     11        This also removes a branch from many hasTagName() and isFooElement() calls.
     12
     13        * accessibility/AccessibilityRenderObject.cpp:
     14        (WebCore::startOfContinuations):
     15        * accessibility/AccessibilityTable.cpp:
     16        (WebCore::AccessibilityTable::isDataTable):
     17        * accessibility/AccessibilityTableCell.cpp:
     18        (WebCore::AccessibilityTableCell::titleUIElement):
     19        * accessibility/AccessibilityTableColumn.cpp:
     20        (WebCore::AccessibilityTableColumn::headerObjectForSection):
     21        * editing/markup.cpp:
     22        (WebCore::highestAncestorToWrapMarkup):
     23        * html/HTMLTableCellElement.cpp:
     24        (WebCore::HTMLTableCellElement::cellAbove):
     25        * html/shadow/SliderThumbElement.cpp:
     26        (WebCore::RenderSliderThumb::updateAppearance):
     27        (WebCore::RenderSliderContainer::computeLogicalHeight):
     28        (WebCore::RenderSliderContainer::layout):
     29        * page/Frame.cpp:
     30        (WebCore::Frame::frameForWidget):
     31        * rendering/RenderBlock.cpp:
     32        (WebCore::OverflowEventDispatcher::~OverflowEventDispatcher):
     33        (WebCore::RenderBlock::RenderBlock):
     34        (WebCore::RenderBlock::clone):
     35        (WebCore::RenderBlock::createReplacementRunIn):
     36        (WebCore::RenderBlock::paintObject):
     37        (WebCore::RenderBlock::isSelectionRoot):
     38        (WebCore::RenderBlock::nodeForHitTest):
     39        (WebCore::RenderBlock::hasLineIfEmpty):
     40        (WebCore::RenderBlock::addFocusRingRects):
     41        * rendering/RenderBlock.h:
     42        * rendering/RenderBlockFlow.cpp:
     43        (WebCore::RenderBlockFlow::RenderBlockFlow):
     44        * rendering/RenderBlockFlow.h:
     45        * rendering/RenderBlockLineLayout.cpp:
     46        (WebCore::RenderBlock::addOverflowFromInlineChildren):
     47        * rendering/RenderBox.cpp:
     48        (WebCore::RenderBox::RenderBox):
     49        (WebCore::RenderBox::updateFromStyle):
     50        (WebCore::RenderBox::scroll):
     51        (WebCore::RenderBox::logicalScroll):
     52        (WebCore::RenderBox::canBeProgramaticallyScrolled):
     53        (WebCore::RenderBox::nodeAtPoint):
     54        (WebCore::RenderBox::paintCustomHighlight):
     55        (WebCore::RenderBox::computeLogicalWidthInRegion):
     56        (WebCore::RenderBox::sizesLogicalWidthToFitContent):
     57        (WebCore::RenderBox::localCaretRect):
     58        * rendering/RenderBox.h:
     59        * rendering/RenderBoxModelObject.cpp:
     60        (WebCore::RenderBoxModelObject::RenderBoxModelObject):
     61        * rendering/RenderBoxModelObject.h:
     62        * rendering/RenderButton.cpp:
     63        (WebCore::RenderButton::updateFromElement):
     64        (WebCore::RenderButton::canHaveGeneratedChildren):
     65        * rendering/RenderButton.h:
     66        * rendering/RenderEmbeddedObject.cpp:
     67        (WebCore::RenderEmbeddedObject::paintContents):
     68        (WebCore::RenderEmbeddedObject::isReplacementObscured):
     69        (WebCore::RenderEmbeddedObject::layout):
     70        (WebCore::RenderEmbeddedObject::viewCleared):
     71        (WebCore::RenderEmbeddedObject::handleUnavailablePluginIndicatorEvent):
     72        * rendering/RenderFileUploadControl.cpp:
     73        (WebCore::RenderFileUploadControl::updateFromElement):
     74        (WebCore::RenderFileUploadControl::maxFilenameWidth):
     75        (WebCore::RenderFileUploadControl::paintObject):
     76        (WebCore::RenderFileUploadControl::computeIntrinsicLogicalWidths):
     77        (WebCore::RenderFileUploadControl::uploadButton):
     78        (WebCore::RenderFileUploadControl::fileTextValue):
     79        * rendering/RenderFrame.cpp:
     80        (WebCore::RenderFrame::edgeInfo):
     81        (WebCore::RenderFrame::viewCleared):
     82        * rendering/RenderFrameBase.cpp:
     83        (WebCore::RenderFrameBase::layoutWithFlattening):
     84        * rendering/RenderFrameSet.cpp:
     85        (WebCore::RenderFrameSet::frameSet):
     86        * rendering/RenderHTMLCanvas.cpp:
     87        (WebCore::RenderHTMLCanvas::requiresLayer):
     88        (WebCore::RenderHTMLCanvas::paintReplaced):
     89        (WebCore::RenderHTMLCanvas::canvasSizeChanged):
     90        * rendering/RenderIFrame.cpp:
     91        (WebCore::RenderIFrame::isSeamless):
     92        (WebCore::RenderIFrame::flattenFrame):
     93        * rendering/RenderImage.cpp:
     94        (WebCore::RenderImage::imageChanged):
     95        (WebCore::RenderImage::paintAreaElementFocusRing):
     96        (WebCore::RenderImage::areaElementFocusChanged):
     97        (WebCore::RenderImage::paintIntoRect):
     98        (WebCore::RenderImage::imageMap):
     99        (WebCore::RenderImage::nodeAtPoint):
     100        (WebCore::RenderImage::updateAltText):
     101        * rendering/RenderInline.cpp:
     102        (WebCore::RenderInline::clone):
     103        (WebCore::RenderInline::hitTestCulledInline):
     104        (WebCore::RenderInline::updateHitTestResult):
     105        * rendering/RenderInline.h:
     106        * rendering/RenderLayer.cpp:
     107        (WebCore::RenderLayer::RenderLayer):
     108        (WebCore::RenderLayer::~RenderLayer):
     109        (WebCore::RenderLayer::name):
     110        (WebCore::RenderLayer::isTransparent):
     111        (WebCore::RenderLayer::scrollTo):
     112        (WebCore::RenderLayer::resize):
     113        (WebCore::RenderLayer::filterNeedsRepaint):
     114        * rendering/RenderLayerBacking.cpp:
     115        (WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
     116        (WebCore::RenderLayerBacking::updateGraphicsLayerConfiguration):
     117        * rendering/RenderLayerCompositor.cpp:
     118        (WebCore::RenderLayerCompositor::frameContentsCompositor):
     119        * rendering/RenderLayerFilterInfo.cpp:
     120        (WebCore::RenderLayer::FilterInfo::notifyFinished):
     121        (WebCore::RenderLayer::FilterInfo::updateReferenceFilterClients):
     122        (WebCore::RenderLayer::FilterInfo::notifyCustomFilterProgramLoaded):
     123        * rendering/RenderLayerModelObject.cpp:
     124        (WebCore::RenderLayerModelObject::RenderLayerModelObject):
     125        * rendering/RenderLayerModelObject.h:
     126        (WebCore::RenderLayerModelObject::element):
     127        * rendering/RenderListBox.cpp:
     128        (WebCore::RenderListBox::selectElement):
     129        (WebCore::RenderListBox::paintItemForeground):
     130        (WebCore::RenderListBox::paintItemBackground):
     131        (WebCore::RenderListBox::scrollTo):
     132        (WebCore::RenderListBox::createScrollbar):
     133        * rendering/RenderListItem.cpp:
     134        (WebCore::isList):
     135        (WebCore::enclosingList):
     136        (WebCore::nextListItem):
     137        (WebCore::previousListItem):
     138        (WebCore::RenderListItem::calcValue):
     139        (WebCore::RenderListItem::explicitValueChanged):
     140        (WebCore::RenderListItem::setExplicitValue):
     141        (WebCore::RenderListItem::clearExplicitValue):
     142        (WebCore::previousOrNextItem):
     143        (WebCore::RenderListItem::updateListMarkerNumbers):
     144        * rendering/RenderMarquee.cpp:
     145        (WebCore::RenderMarquee::marqueeSpeed):
     146        * rendering/RenderMedia.cpp:
     147        (WebCore::RenderMedia::mediaElement):
     148        * rendering/RenderMediaControlElements.cpp:
     149        (WebCore::RenderMediaControlTimelineContainer::layout):
     150        (WebCore::RenderTextTrackContainerElement::layout):
     151        * rendering/RenderMenuList.cpp:
     152        (WebCore::RenderMenuList::selectElement):
     153        (WebCore::RenderMenuList::valueChanged):
     154        (WebCore::RenderMenuList::createScrollbar):
     155        * rendering/RenderMeter.cpp:
     156        (WebCore::RenderMeter::meterElement):
     157        * rendering/RenderPart.cpp:
     158        (WebCore::RenderPart::requiresAcceleratedCompositing):
     159        (WebCore::RenderPart::embeddedContentBox):
     160        * rendering/RenderProgress.cpp:
     161        (WebCore::RenderProgress::progressElement):
     162        * rendering/RenderReplaced.cpp:
     163        (WebCore::RenderReplaced::positionForPoint):
     164        (WebCore::RenderReplaced::isSelected):
     165        * rendering/RenderSearchField.cpp:
     166        (WebCore::RenderSearchField::autosaveName):
     167        (WebCore::RenderSearchField::createScrollbar):
     168        * rendering/RenderSlider.cpp:
     169        (WebCore::RenderSlider::layout):
     170        (WebCore::RenderSlider::inDragMode):
     171        * rendering/RenderSnapshottedPlugIn.cpp:
     172        (WebCore::RenderSnapshottedPlugIn::plugInImageElement):
     173        * rendering/RenderTable.cpp:
     174        (WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
     175        (WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
     176        (WebCore::RenderTable::nodeAtPoint):
     177        * rendering/RenderTableCell.cpp:
     178        (WebCore::RenderTableCell::parseColSpanFromDOM):
     179        (WebCore::RenderTableCell::parseRowSpanFromDOM):
     180        (WebCore::RenderTableCell::updateColAndRowSpanFlags):
     181        (WebCore::RenderTableCell::colSpanOrRowSpanChanged):
     182        (WebCore::RenderTableCell::computePreferredLogicalWidths):
     183        * rendering/RenderTableCol.cpp:
     184        (WebCore::RenderTableCol::updateFromElement):
     185        * rendering/RenderTextControl.cpp:
     186        (WebCore::RenderTextControl::textFormControlElement):
     187        (WebCore::RenderTextControl::adjustInnerTextStyle):
     188        (WebCore::RenderTextControl::updateFromElement):
     189        (WebCore::RenderTextControl::layoutSpecialExcludedChild):
     190        * rendering/RenderTextControlMultiLine.cpp:
     191        (WebCore::RenderTextControlMultiLine::~RenderTextControlMultiLine):
     192        (WebCore::RenderTextControlMultiLine::nodeAtPoint):
     193        (WebCore::RenderTextControlMultiLine::preferredContentLogicalWidth):
     194        (WebCore::RenderTextControlMultiLine::computeControlLogicalHeight):
     195        * rendering/RenderTextControlSingleLine.cpp:
     196        (WebCore::RenderTextControlSingleLine::nodeAtPoint):
     197        (WebCore::RenderTextControlSingleLine::capsLockStateMayHaveChanged):
     198        (WebCore::RenderTextControlSingleLine::textShouldBeTruncated):
     199        (WebCore::RenderTextControlSingleLine::inputElement):
     200        * rendering/RenderThemeMac.mm:
     201        (WebCore::RenderThemeMac::paintSnapshottedPluginOverlay):
     202        * rendering/RenderTreeAsText.cpp:
     203        (WebCore::writeRenderRegionList):
     204        * rendering/RenderVideo.cpp:
     205        (WebCore::RenderVideo::updateIntrinsicSize):
     206        (WebCore::RenderVideo::videoElement):
     207        * rendering/RenderWidget.cpp:
     208        (WebCore::RenderWidget::setWidgetGeometry):
     209        (WebCore::RenderWidget::updateWidgetPosition):
     210        (WebCore::RenderWidget::nodeAtPoint):
     211        * rendering/mathml/RenderMathMLFenced.cpp:
     212        (WebCore::RenderMathMLFenced::updateFromElement):
     213        (WebCore::RenderMathMLFenced::createMathMLOperator):
     214        (WebCore::RenderMathMLFenced::styleDidChange):
     215        * rendering/mathml/RenderMathMLFraction.cpp:
     216        (WebCore::RenderMathMLFraction::updateFromElement):
     217        * rendering/mathml/RenderMathMLOperator.cpp:
     218        (WebCore::RenderMathMLOperator::updateFromElement):
     219        (WebCore::RenderMathMLOperator::createGlyph):
     220        * rendering/mathml/RenderMathMLSpace.cpp:
     221        (WebCore::RenderMathMLSpace::updateFromElement):
     222        * rendering/svg/RenderSVGForeignObject.cpp:
     223        (WebCore::RenderSVGForeignObject::layout):
     224        * rendering/svg/RenderSVGRoot.cpp:
     225        (WebCore::RenderSVGRoot::computeIntrinsicRatioInformation):
     226        (WebCore::RenderSVGRoot::isEmbeddedThroughSVGImage):
     227        (WebCore::RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument):
     228        (WebCore::RenderSVGRoot::computeReplacedLogicalWidth):
     229        (WebCore::RenderSVGRoot::computeReplacedLogicalHeight):
     230        (WebCore::RenderSVGRoot::layout):
     231        (WebCore::RenderSVGRoot::paintReplaced):
     232        (WebCore::RenderSVGRoot::buildLocalToBorderBoxTransform):
     233        (WebCore::RenderSVGRoot::nodeAtPoint):
     234        (WebCore::RenderSVGRoot::hasRelativeDimensions):
     235        (WebCore::RenderSVGRoot::hasRelativeIntrinsicLogicalWidth):
     236        (WebCore::RenderSVGRoot::hasRelativeLogicalHeight):
     237        * rendering/svg/RenderSVGText.cpp:
     238        (WebCore::RenderSVGText::layout):
     239        (WebCore::RenderSVGText::strokeBoundingBox):
     240        * rendering/svg/RenderSVGTextPath.cpp:
     241        (WebCore::RenderSVGTextPath::layoutPath):
     242        (WebCore::RenderSVGTextPath::startOffset):
     243        (WebCore::RenderSVGTextPath::exactAlignment):
     244        (WebCore::RenderSVGTextPath::stretchMethod):
     245
    12462013-09-09  Antti Koivisto  <antti@apple.com>
    2247

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r155370 r155374  
    266266    // Blocks with a previous continuation always have a next continuation
    267267    if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())
    268         return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->node()->renderer());
     268        return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->element()->renderer());
    269269
    270270    return 0;

  • trunk/Source/WebCore/accessibility/AccessibilityTable.cpp

    r154928 r155374  
    112112   
    113113    RenderTable* table = toRenderTable(m_renderer);
    114     Node* tableNode = table->node();
    115     if (!tableNode || !isHTMLTableElement(tableNode))
     114    if (!table->element() || !isHTMLTableElement(table->element()))
    116115        return false;
    117116
    118117    // if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table
    119     HTMLTableElement* tableElement = toHTMLTableElement(tableNode);
     118    HTMLTableElement* tableElement = toHTMLTableElement(table->element());
    120119    if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption())
    121120        return true;
    … …  
    179178            if (!cell)
    180179                continue;
    181             Node* cellNode = cell->node();
    182             if (!cellNode)
     180            if (!cell->element())
    183181                continue;
    184182           
    … …  
    188186            validCellCount++;
    189187           
    190             HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode);
     188            HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cell->element());
    191189           
    192190            bool isTHCell = cellElement->hasTagName(thTag);

  • trunk/Source/WebCore/accessibility/AccessibilityTableCell.cpp

    r152783 r155374  
    175175        return 0;
    176176
    177     Node* cellElement = headerCell->node();
    178     if (!cellElement || !cellElement->hasTagName(thTag))
     177    if (!headerCell->element() || !headerCell->element()->hasTagName(thTag))
    179178        return 0;
    180179   

  • trunk/Source/WebCore/accessibility/AccessibilityTableColumn.cpp

    r154339 r155374  
    137137            break;
    138138       
    139         Node* node = testCell->node();
    140         if (!node)
     139        if (!testCell->element())
    141140            continue;
    142141       
    143         if (thTagRequired && !node->hasTagName(thTag))
     142        if (thTagRequired && !testCell->element()->hasTagName(thTag))
    144143            continue;
    145144       

  • trunk/Source/WebCore/editing/markup.cpp

    r155320 r155374  
    525525    Node* checkAncestor = specialCommonAncestor ? specialCommonAncestor : commonAncestor;
    526526    if (checkAncestor->renderer() && checkAncestor->renderer()->containingBlock()) {
    527         Node* newSpecialCommonAncestor = highestEnclosingNodeOfType(firstPositionInNode(checkAncestor), &isElementPresentational, CanCrossEditingBoundary, checkAncestor->renderer()->containingBlock()->node());
     527        Node* newSpecialCommonAncestor = highestEnclosingNodeOfType(firstPositionInNode(checkAncestor), &isElementPresentational, CanCrossEditingBoundary, checkAncestor->renderer()->containingBlock()->element());
    528528        if (newSpecialCommonAncestor)
    529529            specialCommonAncestor = newSpecialCommonAncestor;

  • trunk/Source/WebCore/html/HTMLTableCellElement.cpp

    r154877 r155374  
    180180        return 0;
    181181
    182     return static_cast<HTMLTableCellElement*>(cellAboveRenderer->node());
     182    return static_cast<HTMLTableCellElement*>(cellAboveRenderer->element());
    183183}
    184184

  • trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp

    r155211 r155374  
    113113        style()->setAppearance(MediaFullScreenVolumeSliderThumbPart);
    114114    if (style()->hasAppearance())
    115         theme()->adjustSliderThumbSize(style(), toElement(node()));
     115        theme()->adjustSliderThumbSize(style(), element());
    116116}
    117117
    … …  
    138138void RenderSliderContainer::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
    139139{
    140     HTMLInputElement* input = node()->shadowHost()->toInputElement();
     140    HTMLInputElement* input = element()->shadowHost()->toInputElement();
    141141    bool isVertical = hasVerticalAppearance(input);
    142142
    … …  
    166166void RenderSliderContainer::layout()
    167167{
    168     HTMLInputElement* input = node()->shadowHost()->toInputElement();
     168    HTMLInputElement* input = element()->shadowHost()->toInputElement();
    169169    bool isVertical = hasVerticalAppearance(input);
    170170    style()->setFlexDirection(isVertical ? FlowColumn : FlowRow);

  • trunk/Source/WebCore/page/Frame.cpp

    r155344 r155374  
    586586
    587587    if (RenderWidget* renderer = RenderWidget::find(widget))
    588         if (Node* node = renderer->node())
    589             return node->document().frame();
     588        if (Element* element = renderer->element())
     589            return element->document().frame();
    590590
    591591    // Assume all widgets are either a FrameView or owned by a RenderWidget.

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r155370 r155374  
    149149        bool verticalLayoutOverflowChanged = hasVerticalLayoutOverflow != m_hadVerticalLayoutOverflow;
    150150        if (horizontalLayoutOverflowChanged || verticalLayoutOverflowChanged)
    151             m_block->view().frameView().scheduleEvent(OverflowEvent::create(horizontalLayoutOverflowChanged, hasHorizontalLayoutOverflow, verticalLayoutOverflowChanged, hasVerticalLayoutOverflow), m_block->node());
     151            m_block->view().frameView().scheduleEvent(OverflowEvent::create(horizontalLayoutOverflowChanged, hasHorizontalLayoutOverflow, verticalLayoutOverflowChanged, hasVerticalLayoutOverflow), m_block->element());
    152152    }
    153153
    … …  
    194194// -------------------------------------------------------------------------------------------------------
    195195
    196 RenderBlock::RenderBlock(ContainerNode* node)
    197     : RenderBox(node)
     196RenderBlock::RenderBlock(Element* element)
     197    : RenderBox(element)
    198198    , m_lineHeight(-1)
    199199    , m_hasMarginBeforeQuirk(false)
    … …  
    573573    }
    574574    else {
    575         RenderObject* cloneRenderer = toElement(node())->createRenderer(renderArena(), style());
     575        RenderObject* cloneRenderer = element()->createRenderer(renderArena(), style());
    576576        cloneBlock = toRenderBlock(cloneRenderer);
    577577        cloneBlock->setStyle(style());
    … …  
    20152015{
    20162016    ASSERT(runIn->isRunIn());
    2017     ASSERT(runIn->node());
     2017    ASSERT(runIn->element());
    20182018
    20192019    RenderBoxModelObject* newRunIn = 0;
    20202020    if (!runIn->isRenderBlock())
    2021         newRunIn = new (renderArena()) RenderBlock(runIn->node());
     2021        newRunIn = new (renderArena()) RenderBlock(runIn->element());
    20222022    else
    2023         newRunIn = new (renderArena()) RenderInline(toElement(runIn->node()));
    2024 
    2025     runIn->node()->setRenderer(newRunIn);
     2023        newRunIn = new (renderArena()) RenderInline(runIn->element());
     2024
     2025    runIn->element()->setRenderer(newRunIn);
    20262026    newRunIn->setStyle(runIn->style());
    20272027
    … …  
    33873387        RenderInline* inlineCont = inlineElementContinuation();
    33883388        if (inlineCont && inlineCont->hasOutline() && inlineCont->style()->visibility() == VISIBLE) {
    3389             RenderInline* inlineRenderer = toRenderInline(inlineCont->node()->renderer());
     3389            RenderInline* inlineRenderer = toRenderInline(inlineCont->element()->renderer());
    33903390            RenderBlock* cb = containingBlock();
    33913391
    … …  
    35463546    if (isPseudoElement())
    35473547        return false;
    3548     ASSERT(node() || isAnonymous());
     3548    ASSERT(element() || isAnonymous());
    35493549       
    35503550    // FIXME: Eventually tables should have to learn how to fill gaps between cells, at least in simple non-spanning cases.
    … …  
    35613561    if (view().selectionStart()) {
    35623562        Node* startElement = view().selectionStart()->node();
    3563         if (startElement && startElement->rootEditableElement() == node())
     3563        if (startElement && startElement->rootEditableElement() == element())
    35643564            return true;
    35653565    }
    … …  
    51685168    if (isRenderView())
    51695169        return &document();
    5170     return isAnonymousBlockContinuation() ? continuation()->node() : node();
     5170    return isAnonymousBlockContinuation() ? continuation()->element() : element();
    51715171}
    51725172
    … …  
    66496649bool RenderBlock::hasLineIfEmpty() const
    66506650{
    6651     if (!node())
     6651    if (!element())
    66526652        return false;
    66536653   
    6654     if (node()->isRootEditableElement())
    6655         return true;
    6656    
    6657     if (node()->isShadowRoot() && isHTMLInputElement(toShadowRoot(node())->hostElement()))
     6654    if (element()->isRootEditableElement())
    66586655        return true;
    66596656   
    … …  
    74817478        // FIXME: This is wrong for block-flows that are horizontal.
    74827479        // https://bugs.webkit.org/show_bug.cgi?id=46781
    7483         bool prevInlineHasLineBox = toRenderInline(inlineElementContinuation()->node()->renderer())->firstLineBox();
     7480        bool prevInlineHasLineBox = toRenderInline(inlineElementContinuation()->element()->renderer())->firstLineBox();
    74847481        float topMargin = prevInlineHasLineBox ? collapsedMarginBefore() : LayoutUnit();
    74857482        float bottomMargin = nextInlineHasLineBox ? collapsedMarginAfter() : LayoutUnit();

  • trunk/Source/WebCore/rendering/RenderBlock.h

    r155368 r155374  
    9191
    9292protected:
    93     explicit RenderBlock(ContainerNode*);
     93    explicit RenderBlock(Element*);
    9494    virtual ~RenderBlock();
    9595

  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r155211 r155374  
    2727namespace WebCore {
    2828
    29 RenderBlockFlow::RenderBlockFlow(ContainerNode* node)
    30     : RenderBlock(node)
     29RenderBlockFlow::RenderBlockFlow(Element* element)
     30    : RenderBlock(element)
    3131{
    3232}

  • trunk/Source/WebCore/rendering/RenderBlockFlow.h

    r155211 r155374  
    3030class RenderBlockFlow : public RenderBlock {
    3131public:
    32     explicit RenderBlockFlow(ContainerNode*);
     32    explicit RenderBlockFlow(Element*);
    3333    virtual ~RenderBlockFlow();
    3434   

  • trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

    r155318 r155374  
    35503550    LayoutUnit endPadding = hasOverflowClip() ? paddingEnd() : LayoutUnit();
    35513551    // FIXME: Need to find another way to do this, since scrollbars could show when we don't want them to.
    3552     if (hasOverflowClip() && !endPadding && node() && node()->isRootEditableElement() && style()->isLeftToRightDirection())
     3552    if (hasOverflowClip() && !endPadding && element() && element()->isRootEditableElement() && style()->isLeftToRightDirection())
    35533553        endPadding = 1;
    35543554    for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {

  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r155370 r155374  
    9696}
    9797
    98 RenderBox::RenderBox(ContainerNode* node)
    99     : RenderBoxModelObject(node)
     98RenderBox::RenderBox(Element* element)
     99    : RenderBoxModelObject(element)
    100100    , m_minPreferredLogicalWidth(-1)
    101101    , m_maxPreferredLogicalWidth(-1)
    … …  
    439439            // (3) The root element has visible overflow.
    440440            if (document().documentElement()->hasTagName(htmlTag)
    441                 && document().body() == node()
     441                && document().body() == element()
    442442                && document().documentElement()->renderer()->style()->overflowX() == OVISIBLE) {
    443443                boxHasOverflowClip = false;
    … …  
    752752    if (l && l->scroll(direction, granularity, multiplier)) {
    753753        if (stopNode)
    754             *stopNode = node();
     754            *stopNode = element();
    755755        return true;
    756756    }
    757757
    758     if (stopNode && *stopNode && *stopNode == node())
     758    if (stopNode && *stopNode && *stopNode == element())
    759759        return true;
    760760
    … …  
    781781        if (scrolled) {
    782782            if (stopNode)
    783                 *stopNode = node();
     783                *stopNode = element();
    784784            return true;
    785785        }
    786786    }
    787787
    788     if (stopNode && *stopNode && *stopNode == node())
     788    if (stopNode && *stopNode && *stopNode == element())
    789789        return true;
    790790
    … …  
    812812        return true;
    813813
    814     Node* node = this->node();
    815     return node && node->rendererIsEditable();
     814    return element() && element()->rendererIsEditable();
    816815}
    817816
    … …  
    10981097    if (visibleToHitTesting() && action == HitTestForeground && locationInContainer.intersects(boundsRect)) {
    10991098        updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));
    1100         if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
     1099        if (!result.addNodeToRectBasedTestResult(element(), request, locationInContainer, boundsRect))
    11011100            return true;
    11021101    }
    … …  
    15951594        FloatRect rootRect(paintOffset.x() + r->x(), paintOffset.y() + r->selectionTop(), r->logicalWidth(), r->selectionHeight());
    15961595        FloatRect imageRect(paintOffset.x() + x(), rootRect.y(), width(), rootRect.height());
    1597         page->chrome().client().paintCustomHighlight(node(), type, imageRect, rootRect, behindText, false);
     1596        page->chrome().client().paintCustomHighlight(element(), type, imageRect, rootRect, behindText, false);
    15981597    } else {
    15991598        FloatRect imageRect(paintOffset.x() + x(), paintOffset.y() + y(), width(), height());
    1600         page->chrome().client().paintCustomHighlight(node(), type, imageRect, imageRect, behindText, false);
     1599        page->chrome().client().paintCustomHighlight(element(), type, imageRect, imageRect, behindText, false);
    16011600    }
    16021601}
    … …  
    21762175
    21772176    // If layout is limited to a subtree, the subtree root's logical width does not change.
    2178     if (node() && view().frameView().layoutRoot(true) == this)
     2177    if (element() && view().frameView().layoutRoot(true) == this)
    21792178        return;
    21802179
    … …  
    23752374    // FIXME: Think about block-flow here.
    23762375    // https://bugs.webkit.org/show_bug.cgi?id=46473
    2377     if (logicalWidth.type() == Auto && !isStretchingColumnFlexItem(this) && node() && (isHTMLInputElement(node()) || node()->hasTagName(selectTag) || node()->hasTagName(buttonTag) || isHTMLTextAreaElement(node()) || node()->hasTagName(legendTag)))
     2376    if (logicalWidth.type() == Auto && !isStretchingColumnFlexItem(this) && element() && (isHTMLInputElement(element()) || element()->hasTagName(selectTag) || element()->hasTagName(buttonTag) || isHTMLTextAreaElement(element()) || element()->hasTagName(legendTag)))
    23782377        return true;
    23792378
    … …  
    40584057    // is needed because we use offsets inside an "atomic" element to represent
    40594058    // positions before and after the element in deprecated editing offsets.
    4060     if (node() && !(editingIgnoresContent(node()) || isTableElement(node()))) {
     4059    if (element() && !(editingIgnoresContent(element()) || isTableElement(element()))) {
    40614060        rect.setX(rect.x() + borderLeft() + paddingLeft());
    40624061        rect.setY(rect.y() + paddingTop() + borderTop());

  • trunk/Source/WebCore/rendering/RenderBox.h

    r155244 r155374  
    4545class RenderBox : public RenderBoxModelObject {
    4646public:
    47     explicit RenderBox(ContainerNode*);
     47    explicit RenderBox(Element*);
    4848    virtual ~RenderBox();
    4949

  • trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp

    r155370 r155374  
    160160}
    161161
    162 RenderBoxModelObject::RenderBoxModelObject(ContainerNode* node)
    163     : RenderLayerModelObject(node)
     162RenderBoxModelObject::RenderBoxModelObject(Element* element)
     163    : RenderLayerModelObject(element)
    164164{
    165165}

  • trunk/Source/WebCore/rendering/RenderBoxModelObject.h

    r155366 r155374  
    6262class RenderBoxModelObject : public RenderLayerModelObject {
    6363public:
    64     RenderBoxModelObject(ContainerNode*);
     64    RenderBoxModelObject(Element*);
    6565    virtual ~RenderBoxModelObject();
    6666   

  • trunk/Source/WebCore/rendering/RenderButton.cpp

    r154580 r155374  
    123123{
    124124    // If we're an input element, we may need to change our button text.
    125     if (isHTMLInputElement(node())) {
    126         HTMLInputElement* input = toHTMLInputElement(node());
     125    if (isHTMLInputElement(element())) {
     126        HTMLInputElement* input = toHTMLInputElement(element());
    127127        String value = input->valueWithDefault();
    128128        setText(value);
    … …  
    158158    // write the code assuming any other button types that might emerge in the future
    159159    // can also have children.
    160     return !isHTMLInputElement(node());
     160    return !isHTMLInputElement(element());
    161161}
    162162

  • trunk/Source/WebCore/rendering/RenderButton.h

    r154871 r155374  
    4141    virtual bool isRenderButton() const { return true; }
    4242
    43     virtual bool canBeSelectionLeaf() const OVERRIDE { return node() && node()->rendererIsEditable(); }
     43    virtual bool canBeSelectionLeaf() const OVERRIDE { return element() && element()->rendererIsEditable(); }
    4444
    4545    virtual void addChild(RenderObject* newChild, RenderObject *beforeChild = 0);
    … …  
    6262    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
    6363
    64     virtual bool hasLineIfEmpty() const { return node() && node()->toInputElement(); }
     64    virtual bool hasLineIfEmpty() const { return element() && element()->toInputElement(); }
    6565
    6666    virtual bool requiresForcedStyleRecalcPropagation() const { return true; }

  • trunk/Source/WebCore/rendering/RenderEmbeddedObject.cpp

    r155026 r155374  
    206206void RenderEmbeddedObject::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    207207{
    208     Element* element = toElement(node());
    209     if (!element || !element->isPluginElement())
    210         return;
    211 
    212     HTMLPlugInElement* plugInElement = toHTMLPlugInElement(element);
     208    if (!element() || !element()->isPluginElement())
     209        return;
     210
     211    HTMLPlugInElement* plugInElement = toHTMLPlugInElement(element());
    213212
    214213    if (plugInElement->displayState() > HTMLPlugInElement::DisplayingSnapshot) {
    … …  
    422421    location = LayoutPoint(x + width / 2, y + height / 2);
    423422    hit = rootRenderView->hitTest(request, location, result);
    424     if (!hit || result.innerNode() != node())
     423    if (!hit || result.innerNode() != element())
    425424        return true;
    426425   
    427426    location = LayoutPoint(x, y);
    428427    hit = rootRenderView->hitTest(request, location, result);
    429     if (!hit || result.innerNode() != node())
     428    if (!hit || result.innerNode() != element())
    430429        return true;
    431430   
    432431    location = LayoutPoint(x + width, y);
    433432    hit = rootRenderView->hitTest(request, location, result);
    434     if (!hit || result.innerNode() != node())
     433    if (!hit || result.innerNode() != element())
    435434        return true;
    436435   
    437436    location = LayoutPoint(x + width, y + height);
    438437    hit = rootRenderView->hitTest(request, location, result);
    439     if (!hit || result.innerNode() != node())
     438    if (!hit || result.innerNode() != element())
    440439        return true;
    441440   
    442441    location = LayoutPoint(x, y + height);
    443442    hit = rootRenderView->hitTest(request, location, result);
    444     if (!hit || result.innerNode() != node())
     443    if (!hit || result.innerNode() != element())
    445444        return true;
    446445
    … …  
    476475
    477476    if (!wasMissingWidget && newSize.width() >= oldSize.width() && newSize.height() >= oldSize.height()) {
    478         Element* element = toElement(node());
     477        Element* element = this->element();
    479478        if (element && element->isPluginElement() && toHTMLPlugInElement(element)->isPlugInImageElement()) {
    480479            HTMLPlugInImageElement* plugInImageElement = toHTMLPlugInImageElement(element);
    … …  
    521520{
    522521    // This is required for <object> elements whose contents are rendered by WebCore (e.g. src="foo.html").
    523     if (node() && widget() && widget()->isFrameView()) {
     522    if (element() && widget() && widget()->isFrameView()) {
    524523        FrameView* view = toFrameView(widget());
    525524        int marginWidth = -1;
    526525        int marginHeight = -1;
    527         if (node()->hasTagName(iframeTag)) {
    528             HTMLIFrameElement* frame = toHTMLIFrameElement(node());
     526        if (element()->hasTagName(iframeTag)) {
     527            HTMLIFrameElement* frame = toHTMLIFrameElement(element());
    529528            marginWidth = frame->marginWidth();
    530529            marginHeight = frame->marginHeight();
    … …  
    607606
    608607    MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
    609     HTMLPlugInElement* element = toHTMLPlugInElement(node());
     608    HTMLPlugInElement* element = toHTMLPlugInElement(this->element());
    610609    if (event->type() == eventNames().mousedownEvent && static_cast<MouseEvent*>(event)->button() == LeftButton) {
    611610        m_mouseDownWasInUnavailablePluginIndicator = isInUnavailablePluginIndicator(mouseEvent);

  • trunk/Source/WebCore/rendering/RenderFileUploadControl.cpp

    r155211 r155374  
    6868void RenderFileUploadControl::updateFromElement()
    6969{
    70     HTMLInputElement* input = toHTMLInputElement(node());
     70    HTMLInputElement* input = toHTMLInputElement(element());
    7171    ASSERT(input->isFileUpload());
    7272
    … …  
    9494int RenderFileUploadControl::maxFilenameWidth() const
    9595{
    96     HTMLInputElement* input = toHTMLInputElement(node());
     96    HTMLInputElement* input = toHTMLInputElement(element());
    9797    return max(0, contentBoxRect().pixelSnappedWidth() - nodeWidth(uploadButton()) - afterButtonSpacing
    9898        - (input->icon() ? iconWidth + iconFilenameSpacing : 0));
    … …  
    127127            return;
    128128
    129         HTMLInputElement* input = toHTMLInputElement(node());
     129        HTMLInputElement* input = toHTMLInputElement(element());
    130130        LayoutUnit buttonWidth = nodeWidth(button);
    131131        LayoutUnit buttonAndIconWidth = buttonWidth + afterButtonSpacing
    … …  
    179179    float minDefaultLabelWidth = defaultWidthNumChars * font.width(constructTextRun(renderer, font, characterAsString, style(), TextRun::AllowTrailingExpansion));
    180180
    181     const String label = theme()->fileListDefaultLabel(node()->toInputElement()->multiple());
     181    const String label = theme()->fileListDefaultLabel(element()->toInputElement()->multiple());
    182182    float defaultLabelWidth = font.width(constructTextRun(renderer, font, label, style(), TextRun::AllowTrailingExpansion));
    183183    if (HTMLInputElement* button = uploadButton())
    … …  
    226226HTMLInputElement* RenderFileUploadControl::uploadButton() const
    227227{
    228     HTMLInputElement* input = toHTMLInputElement(node());
     228    HTMLInputElement* input = toHTMLInputElement(element());
    229229
    230230    ASSERT(input->shadowRoot());
    … …  
    244244String RenderFileUploadControl::fileTextValue() const
    245245{
    246     HTMLInputElement* input = toHTMLInputElement(node());
     246    HTMLInputElement* input = toHTMLInputElement(element());
    247247    ASSERT(input->files());
    248248    return theme()->fileListNameForWidth(input->files(), style()->font(), maxFilenameWidth(), input->multiple());

  • trunk/Source/WebCore/rendering/RenderFrame.cpp

    r145913 r155374  
    3939FrameEdgeInfo RenderFrame::edgeInfo() const
    4040{
    41     HTMLFrameElement* element = static_cast<HTMLFrameElement*>(node());
    42     return FrameEdgeInfo(element->noResize(), element->hasFrameBorder());
     41    HTMLFrameElement* frameElement = static_cast<HTMLFrameElement*>(element());
     42    return FrameEdgeInfo(frameElement->noResize(), frameElement->hasFrameBorder());
    4343}
    4444
    … …  
    5151void RenderFrame::viewCleared()
    5252{
    53     HTMLFrameElement* element = static_cast<HTMLFrameElement*>(node());
    54     if (!element || !widget() || !widget()->isFrameView())
     53    HTMLFrameElement* frameElement = static_cast<HTMLFrameElement*>(element());
     54    if (!frameElement || !widget() || !widget()->isFrameView())
    5555        return;
    5656
    5757    FrameView* view = toFrameView(widget());
    5858
    59     int marginWidth = element->marginWidth();
    60     int marginHeight = element->marginHeight();
     59    int marginWidth = frameElement->marginWidth();
     60    int marginHeight = frameElement->marginHeight();
    6161
    6262    if (marginWidth != -1)

  • trunk/Source/WebCore/rendering/RenderFrameBase.cpp

    r154184 r155374  
    7373    // no subframe much ever become scrollable.
    7474
    75     bool isScrollable = toHTMLFrameElementBase(node())->scrollingMode() != ScrollbarAlwaysOff;
     75    bool isScrollable = toHTMLFrameElementBase(element())->scrollingMode() != ScrollbarAlwaysOff;
    7676
    7777    // consider iframe inset border

  • trunk/Source/WebCore/rendering/RenderFrameSet.cpp

    r154580 r155374  
    6464inline HTMLFrameSetElement* RenderFrameSet::frameSet() const
    6565{
    66     return toHTMLFrameSetElement(node());
     66    return toHTMLFrameSetElement(element());
    6767}
    6868

  • trunk/Source/WebCore/rendering/RenderHTMLCanvas.cpp

    r154858 r155374  
    5454        return true;
    5555   
    56     HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(node());
     56    HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(element());
    5757    return canvas && canvas->renderingContext() && canvas->renderingContext()->isAccelerated();
    5858}
    … …  
    7979
    8080    bool useLowQualityScale = style()->imageRendering() == ImageRenderingCrispEdges || style()->imageRendering() == ImageRenderingOptimizeSpeed;
    81     static_cast<HTMLCanvasElement*>(node())->paint(context, paintRect, useLowQualityScale);
     81    static_cast<HTMLCanvasElement*>(element())->paint(context, paintRect, useLowQualityScale);
    8282}
    8383
    8484void RenderHTMLCanvas::canvasSizeChanged()
    8585{
    86     IntSize canvasSize = static_cast<HTMLCanvasElement*>(node())->size();
     86    IntSize canvasSize = static_cast<HTMLCanvasElement*>(element())->size();
    8787    LayoutSize zoomedSize(canvasSize.width() * style()->effectiveZoom(), canvasSize.height() * style()->effectiveZoom());
    8888

  • trunk/Source/WebCore/rendering/RenderIFrame.cpp

    r155026 r155374  
    8282bool RenderIFrame::isSeamless() const
    8383{
    84     return node() && node()->hasTagName(iframeTag) && toHTMLIFrameElement(node())->shouldDisplaySeamlessly();
     84    return element() && element()->hasTagName(iframeTag) && toHTMLIFrameElement(element())->shouldDisplaySeamlessly();
    8585}
    8686
    … …  
    100100bool RenderIFrame::flattenFrame() const
    101101{
    102     if (!node() || !node()->hasTagName(iframeTag))
     102    if (!element() || !element()->hasTagName(iframeTag))
    103103        return false;
    104104
    105     HTMLIFrameElement* element = toHTMLIFrameElement(node());
    106     Frame* frame = element->document().frame();
     105    HTMLIFrameElement* iFrameElement = toHTMLIFrameElement(element());
     106    Frame* frame = iFrameElement->document().frame();
    107107
    108108    if (isSeamless())
    … …  
    116116    if (style()->width().isFixed() && style()->height().isFixed()) {
    117117        // Do not flatten iframes with scrolling="no".
    118         if (element->scrollingMode() == ScrollbarAlwaysOff)
     118        if (iFrameElement->scrollingMode() == ScrollbarAlwaysOff)
    119119            return false;
    120120        if (style()->width().value() <= 0 || style()->height().value() <= 0)

  • trunk/Source/WebCore/rendering/RenderImage.cpp

    r154858 r155374  
    184184    if (m_imageResource->errorOccurred()) {
    185185        if (!m_altText.isEmpty() && document().hasPendingStyleRecalc()) {
    186             ASSERT(node());
    187             if (node()) {
     186            ASSERT(element());
     187            if (element()) {
    188188                m_needsToSetSizeForAltText = true;
    189                 node()->setNeedsStyleRecalc(SyntheticStyleChange);
     189                element()->setNeedsStyleRecalc(SyntheticStyleChange);
    190190            }
    191191            return;
    … …  
    459459
    460460    HTMLAreaElement* areaElement = toHTMLAreaElement(focusedElement);
    461     if (areaElement->imageElement() != node())
     461    if (areaElement->imageElement() != element())
    462462        return;
    463463
    … …  
    483483void RenderImage::areaElementFocusChanged(HTMLAreaElement* element)
    484484{
    485     ASSERT_UNUSED(element, element->imageElement() == node());
     485    ASSERT_UNUSED(element, element->imageElement() == this->element());
    486486
    487487    // It would be more efficient to only repaint the focus ring rectangle
    … …  
    501501        return;
    502502
    503     HTMLImageElement* imageElt = (node() && isHTMLImageElement(node())) ? toHTMLImageElement(node()) : 0;
     503    HTMLImageElement* imageElt = (element() && isHTMLImageElement(element())) ? toHTMLImageElement(element()) : 0;
    504504    CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
    505505    Image* image = m_imageResource->image().get();
    … …  
    563563HTMLMapElement* RenderImage::imageMap() const
    564564{
    565     HTMLImageElement* i = node() && isHTMLImageElement(node()) ? toHTMLImageElement(node()) : 0;
     565    HTMLImageElement* i = element() && isHTMLImageElement(element()) ? toHTMLImageElement(element()) : 0;
    566566    return i ? i->treeScope()->getImageMap(i->fastGetAttribute(usemapAttr)) : 0;
    567567}
    … …  
    572572    bool inside = RenderReplaced::nodeAtPoint(request, tempResult, locationInContainer, accumulatedOffset, hitTestAction);
    573573
    574     if (tempResult.innerNode() && node()) {
     574    if (tempResult.innerNode() && element()) {
    575575        if (HTMLMapElement* map = imageMap()) {
    576576            LayoutRect contentBox = contentBoxRect();
    … …  
    580580
    581581            if (map->mapMouseEvent(mapLocation, contentBox.size(), tempResult))
    582                 tempResult.setInnerNonSharedNode(node());
     582                tempResult.setInnerNonSharedNode(element());
    583583        }
    584584    }
    … …  
    593593void RenderImage::updateAltText()
    594594{
    595     if (!node())
    596         return;
    597 
    598     if (isHTMLInputElement(node()))
    599         m_altText = toHTMLInputElement(node())->altText();
    600     else if (isHTMLImageElement(node()))
    601         m_altText = toHTMLImageElement(node())->altText();
     595    if (!element())
     596        return;
     597
     598    if (isHTMLInputElement(element()))
     599        m_altText = toHTMLInputElement(element())->altText();
     600    else if (isHTMLImageElement(element()))
     601        m_altText = toHTMLImageElement(element())->altText();
    602602}
    603603

  • trunk/Source/WebCore/rendering/RenderInline.cpp

    r155366 r155374  
    335335RenderInline* RenderInline::clone() const
    336336{
    337     RenderInline* cloneInline = new (renderArena()) RenderInline(node());
     337    RenderInline* cloneInline = new (renderArena()) RenderInline(element());
    338338    cloneInline->setStyle(style());
    339339    cloneInline->setFlowThreadState(flowThreadState());
    … …  
    803803        // We can not use addNodeToRectBasedTestResult to determine if we fully enclose the hit-test area
    804804        // because it can only handle rectangular targets.
    805         result.addNodeToRectBasedTestResult(node(), request, locationInContainer);
     805        result.addNodeToRectBasedTestResult(element(), request, locationInContainer);
    806806        return regionResult.contains(tmpLocation.boundingBox());
    807807    }
    … …  
    12511251        return;
    12521252
    1253     Node* n = node();
    12541253    LayoutPoint localPoint(point);
    1255     if (n) {
     1254    if (Element* element = this->element()) {
    12561255        if (isInlineElementContinuation()) {
    12571256            // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
    12581257            // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
    1259             RenderBlock* firstBlock = n->renderer()->containingBlock();
     1258            RenderBlock* firstBlock = element->renderer()->containingBlock();
    12601259           
    12611260            // Get our containing block.
    … …  
    12641263        }
    12651264
    1266         result.setInnerNode(n);
     1265        result.setInnerNode(element);
    12671266        if (!result.innerNonSharedNode())
    1268             result.setInnerNonSharedNode(n);
     1267            result.setInnerNonSharedNode(element);
    12691268        result.setLocalPoint(localPoint);
    12701269    }

  • trunk/Source/WebCore/rendering/RenderInline.h

    r155302 r155374  
    4242
    4343    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
    44 
    45     Element* node() const { return toElement(RenderBoxModelObject::node()); }
    4644
    4745    virtual LayoutUnit marginLeft() const OVERRIDE FINAL;

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r155356 r155374  
    222222    }
    223223
    224     Node* node = renderer().node();
    225     if (node && node->isElementNode()) {
     224    if (Element* element = renderer().element()) {
    226225        // We save and restore only the scrollOffset as the other scroll values are recalculated.
    227         Element* element = toElement(node);
    228226        m_scrollOffset = element->savedLayerScrollOffset();
    229227        if (!m_scrollOffset.isZero())
    … …  
    241239
    242240    if (!renderer().documentBeingDestroyed()) {
    243         Node* node = renderer().node();
    244         if (node && node->isElementNode())
    245             toElement(node)->setSavedLayerScrollOffset(m_scrollOffset);
     241        if (Element* element = renderer().element())
     242            element->setSavedLayerScrollOffset(m_scrollOffset);
    246243    }
    247244
    … …  
    279276    name.append(renderer().renderName());
    280277
    281     if (Element* element = renderer().node() && renderer().node()->isElementNode() ? toElement(renderer().node()) : 0) {
     278    if (Element* element = renderer().element()) {
    282279        name.append(' ');
    283280        name.append(element->tagName());
    … …  
    15801577{
    15811578#if ENABLE(SVG)
    1582     if (renderer().node() && renderer().node()->namespaceURI() == SVGNames::svgNamespaceURI)
     1579    if (renderer().element() && renderer().element()->namespaceURI() == SVGNames::svgNamespaceURI)
    15831580        return false;
    15841581#endif
    … …  
    22632260
    22642261    // Schedule the scroll DOM event.
    2265     if (Node* node = renderer().node())
    2266         node->document().eventQueue().enqueueOrDispatchScrollEvent(*node);
     2262    if (Node* element = renderer().element())
     2263        element->document().eventQueue().enqueueOrDispatchScrollEvent(*element);
    22672264
    22682265    InspectorInstrumentation::didScrollLayer(&frame);
    … …  
    24832480{
    24842481    // FIXME: This should be possible on generated content but is not right now.
    2485     if (!inResizeMode() || !canResize() || !renderer().node())
    2486         return;
    2487 
    2488     ASSERT(renderer().node()->isElementNode());
    2489     Element* element = toElement(renderer().node());
     2482    if (!inResizeMode() || !canResize() || !renderer().element())
     2483        return;
     2484
     2485    // FIXME: The only case where renderer->element()->renderer() != renderer is with continuations. Do they matter here?
     2486    // If they do it would still be better to deal with them explicitly.
     2487    Element* element = renderer().element();
    24902488    RenderBox* renderer = toRenderBox(element->renderer());
    24912489
    … …  
    64816479void RenderLayer::filterNeedsRepaint()
    64826480{
    6483     renderer().node()->setNeedsStyleRecalc(SyntheticStyleChange);
     6481    renderer().element()->setNeedsStyleRecalc(SyntheticStyleChange);
    64846482    renderer().repaint();
    64856483}

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r155370 r155374  
    314314#if PLATFORM(MAC) && USE(CA)
    315315    if (!compositor().acceleratedDrawingEnabled() && renderer().isCanvas()) {
    316         const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer().node());
     316        const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer().element());
    317317        if (canvas->shouldAccelerate(canvas->size()))
    318318            m_graphicsLayer->setAcceleratesDrawing(true);
    … …  
    557557#if ENABLE(VIDEO)
    558558    else if (renderer().isVideo()) {
    559         HTMLMediaElement* mediaElement = toHTMLMediaElement(renderer().node());
     559        HTMLMediaElement* mediaElement = toHTMLMediaElement(renderer().element());
    560560        m_graphicsLayer->setContentsToMedia(mediaElement->platformLayer());
    561561    }
    … …  
    563563#if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
    564564    else if (isAcceleratedCanvas(&renderer())) {
    565         const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer().node());
     565        const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer().element());
    566566        if (CanvasRenderingContext* context = canvas->renderingContext())
    567567            m_graphicsLayer->setContentsToCanvas(context->platformLayer());

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r154973 r155374  
    14101410RenderLayerCompositor* RenderLayerCompositor::frameContentsCompositor(RenderPart* renderer)
    14111411{
    1412     if (!renderer->node()->isFrameOwnerElement())
     1412    if (!renderer->element()->isFrameOwnerElement())
    14131413        return 0;
    14141414       
    1415     HTMLFrameOwnerElement* element = toFrameOwnerElement(renderer->node());
     1415    HTMLFrameOwnerElement* element = toFrameOwnerElement(renderer->element());
    14161416    if (Document* contentDocument = element->contentDocument()) {
    14171417        if (RenderView* view = contentDocument->renderView())

  • trunk/Source/WebCore/rendering/RenderLayerFilterInfo.cpp

    r155047 r155374  
    103103void RenderLayer::FilterInfo::notifyFinished(CachedResource*)
    104104{
    105     m_layer.renderer().node()->setNeedsStyleRecalc(SyntheticStyleChange);
     105    m_layer.renderer().element()->setNeedsStyleRecalc(SyntheticStyleChange);
    106106    m_layer.renderer().repaint();
    107107}
    … …  
    125125            // Reference is internal; add layer as a client so we can trigger
    126126            // filter repaint on SVG attribute change.
    127             Element* filter = m_layer.renderer().node()->document().getElementById(referenceFilterOperation->fragment());
     127            Element* filter = m_layer.renderer().element()->document().getElementById(referenceFilterOperation->fragment());
    128128            if (!filter || !filter->renderer() || !filter->renderer()->isSVGResourceFilter())
    129129                continue;
    … …  
    154154void RenderLayer::FilterInfo::notifyCustomFilterProgramLoaded(CustomFilterProgram*)
    155155{
    156     m_layer.renderer().node()->setNeedsStyleRecalc(SyntheticStyleChange);
     156    m_layer.renderer().element()->setNeedsStyleRecalc(SyntheticStyleChange);
    157157    m_layer.renderer().repaint();
    158158}

  • trunk/Source/WebCore/rendering/RenderLayerModelObject.cpp

    r154583 r155374  
    3838bool RenderLayerModelObject::s_layerWasSelfPainting = false;
    3939
    40 RenderLayerModelObject::RenderLayerModelObject(ContainerNode* node)
    41     : RenderObject(node)
     40RenderLayerModelObject::RenderLayerModelObject(Element* element)
     41    : RenderObject(element)
    4242    , m_layer(0)
    4343{

  • trunk/Source/WebCore/rendering/RenderLayerModelObject.h

    r154072 r155374  
    3232class RenderLayerModelObject : public RenderObject {
    3333public:
    34     explicit RenderLayerModelObject(ContainerNode*);
     34    explicit RenderLayerModelObject(Element*);
    3535    virtual ~RenderLayerModelObject();
    3636
    … …  
    5252
    5353    // This is null for anonymous renderers.
    54     ContainerNode* node() const { return toContainerNode(RenderObject::node()); }
     54    Element* element() const { return toElement(RenderObject::node()); }
    5555
    5656protected:
    … …  
    6262private:
    6363    virtual bool isLayerModelObject() const OVERRIDE FINAL { return true; }
     64
     65    void node() const WTF_DELETED_FUNCTION;
    6466
    6567    RenderLayer* m_layer;

  • trunk/Source/WebCore/rendering/RenderListBox.cpp

    r155356 r155374  
    106106inline HTMLSelectElement* RenderListBox::selectElement() const
    107107{
    108     return toHTMLSelectElement(node());
     108    return toHTMLSelectElement(element());
    109109}
    110110
    … …  
    392392
    393393    const Vector<HTMLElement*>& listItems = select->listItems();
    394     HTMLElement* element = listItems[listIndex];
    395 
    396     RenderStyle* itemStyle = element->renderStyle();
     394    HTMLElement* listItemElement = listItems[listIndex];
     395
     396    RenderStyle* itemStyle = listItemElement->renderStyle();
    397397    if (!itemStyle)
    398398        itemStyle = style();
    … …  
    402402
    403403    String itemText;
    404     bool isOptionElement = isHTMLOptionElement(element);
     404    bool isOptionElement = isHTMLOptionElement(listItemElement);
    405405    if (isOptionElement)
    406         itemText = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
    407     else if (isHTMLOptGroupElement(element))
    408         itemText = toHTMLOptGroupElement(element)->groupLabelText();
     406        itemText = toHTMLOptionElement(listItemElement)->textIndentedToRespectGroupLabel();
     407    else if (isHTMLOptGroupElement(listItemElement))
     408        itemText = toHTMLOptGroupElement(listItemElement)->groupLabelText();
    409409    applyTextTransform(style(), itemText, ' ');
    410410
    411     Color textColor = element->renderStyle() ? element->renderStyle()->visitedDependentColor(CSSPropertyColor) : style()->visitedDependentColor(CSSPropertyColor);
    412     if (isOptionElement && toHTMLOptionElement(element)->selected()) {
    413         if (frame().selection().isFocusedAndActive() && document().focusedElement() == node())
     411    Color textColor = listItemElement->renderStyle() ? listItemElement->renderStyle()->visitedDependentColor(CSSPropertyColor) : style()->visitedDependentColor(CSSPropertyColor);
     412    if (isOptionElement && toHTMLOptionElement(listItemElement)->selected()) {
     413        if (frame().selection().isFocusedAndActive() && document().focusedElement() == element())
    414414            textColor = theme()->activeListBoxSelectionForegroundColor();
    415415        // Honor the foreground color for disabled items
    416         else if (!element->isDisabledFormControl() && !select->isDisabledFormControl())
     416        else if (!listItemElement->isDisabledFormControl() && !select->isDisabledFormControl())
    417417            textColor = theme()->inactiveListBoxSelectionForegroundColor();
    418418    }
    … …  
    426426    r.move(itemOffsetForAlignment(textRun, itemStyle, itemFont, r));
    427427
    428     if (isHTMLOptGroupElement(element)) {
     428    if (isHTMLOptGroupElement(listItemElement)) {
    429429        FontDescription d = itemFont.fontDescription();
    430430        d.setWeight(d.bolderWeight());
    … …  
    440440{
    441441    const Vector<HTMLElement*>& listItems = selectElement()->listItems();
    442     HTMLElement* element = listItems[listIndex];
     442    HTMLElement* listItemElement = listItems[listIndex];
    443443
    444444    Color backColor;
    445     if (isHTMLOptionElement(element) && toHTMLOptionElement(element)->selected()) {
    446         if (frame().selection().isFocusedAndActive() && document().focusedElement() == node())
     445    if (isHTMLOptionElement(listItemElement) && toHTMLOptionElement(listItemElement)->selected()) {
     446        if (frame().selection().isFocusedAndActive() && document().focusedElement() == element())
    447447            backColor = theme()->activeListBoxSelectionBackgroundColor();
    448448        else
    449449            backColor = theme()->inactiveListBoxSelectionBackgroundColor();
    450450    } else
    451         backColor = element->renderStyle() ? element->renderStyle()->visitedDependentColor(CSSPropertyBackgroundColor) : style()->visitedDependentColor(CSSPropertyBackgroundColor);
     451        backColor = listItemElement->renderStyle() ? listItemElement->renderStyle()->visitedDependentColor(CSSPropertyBackgroundColor) : style()->visitedDependentColor(CSSPropertyBackgroundColor);
    452452
    453453    // Draw the background for this list box item
    454     if (!element->renderStyle() || element->renderStyle()->visibility() != HIDDEN) {
    455         ColorSpace colorSpace = element->renderStyle() ? element->renderStyle()->colorSpace() : style()->colorSpace();
     454    if (!listItemElement->renderStyle() || listItemElement->renderStyle()->visibility() != HIDDEN) {
     455        ColorSpace colorSpace = listItemElement->renderStyle() ? listItemElement->renderStyle()->colorSpace() : style()->colorSpace();
    456456        LayoutRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
    457457        itemRect.intersect(controlClipRect(paintOffset));
    … …  
    646646    m_indexOffset = newOffset;
    647647    repaint();
    648     node()->document().eventQueue().enqueueOrDispatchScrollEvent(*node());
     648    element()->document().eventQueue().enqueueOrDispatchScrollEvent(*element());
    649649}
    650650
    … …  
    831831    bool hasCustomScrollbarStyle = style()->hasPseudoStyle(SCROLLBAR);
    832832    if (hasCustomScrollbarStyle)
    833         widget = RenderScrollbar::createCustomScrollbar(this, VerticalScrollbar, this->node());
     833        widget = RenderScrollbar::createCustomScrollbar(this, VerticalScrollbar, element());
    834834    else {
    835835        widget = Scrollbar::createNativeScrollbar(this, VerticalScrollbar, theme()->scrollbarControlSizeForPart(ListboxPart));

  • trunk/Source/WebCore/rendering/RenderListItem.cpp

    r155318 r155374  
    9494}
    9595
    96 static bool isList(const Node* node)
    97 {
    98     return (node->hasTagName(ulTag) || node->hasTagName(olTag));
     96static bool isList(const Element* element)
     97{
     98    return element->hasTagName(ulTag) || element->hasTagName(olTag);
    9999}
    100100
    101101// Returns the enclosing list with respect to the DOM order.
    102 static Node* enclosingList(const RenderListItem* listItem)
    103 {
    104     Node* listItemNode = listItem->node();
    105     Node* firstNode = 0;
    106     Node* parent = listItemNode->isPseudoElement() ? toPseudoElement(listItemNode)->hostElement() : listItemNode->parentNode();
     102static Element* enclosingList(const RenderListItem* listItem)
     103{
     104    Element* listItemNode = listItem->element();
     105    Element* firstNode = 0;
     106    Element* parent = listItemNode->isPseudoElement() ? toPseudoElement(listItemNode)->hostElement() : listItemNode->parentElement();
    107107    // We use parentNode because the enclosing list could be a ShadowRoot that's not Element.
    108     for (; parent; parent = parent->parentNode()) {
     108    for (; parent; parent = parent->parentElement()) {
    109109        if (isList(parent))
    110110            return parent;
    … …  
    120120
    121121// Returns the next list item with respect to the DOM order.
    122 static RenderListItem* nextListItem(const Node* listNode, const RenderListItem* item = 0)
     122static RenderListItem* nextListItem(const Element* listNode, const RenderListItem* item = 0)
    123123{
    124124    if (!listNode)
    125125        return 0;
    126126
    127     const Node* current = item ? item->node() : listNode;
     127    const Element* current = item ? item->element() : listNode;
    128128    current = ElementTraversal::nextIncludingPseudo(current, listNode);
    129129
    … …  
    147147
    148148// Returns the previous list item with respect to the DOM order.
    149 static RenderListItem* previousListItem(const Node* listNode, const RenderListItem* item)
    150 {
    151     Node* current = item->node();
     149static RenderListItem* previousListItem(const Element* listNode, const RenderListItem* item)
     150{
     151    Element* current = item->element();
    152152    for (current = ElementTraversal::previousIncludingPseudo(current, listNode); current; current = ElementTraversal::previousIncludingPseudo(current, listNode)) {
    153153        RenderObject* renderer = current->renderer();
    … …  
    192192        return m_explicitValue;
    193193
    194     Node* list = enclosingList(this);
     194    Element* list = enclosingList(this);
    195195    HTMLOListElement* oListElement = (list && list->hasTagName(olTag)) ? static_cast<HTMLOListElement*>(list) : 0;
    196196    int valueStep = 1;
    … …  
    465465    if (m_marker)
    466466        m_marker->setNeedsLayoutAndPrefWidthsRecalc();
    467     Node* listNode = enclosingList(this);
     467    Element* listNode = enclosingList(this);
    468468    for (RenderListItem* item = this; item; item = nextListItem(listNode, item))
    469469        item->updateValue();
    … …  
    472472void RenderListItem::setExplicitValue(int value)
    473473{
    474     ASSERT(node());
     474    ASSERT(element());
    475475
    476476    if (m_hasExplicitValue && m_explicitValue == value)
    … …  
    484484void RenderListItem::clearExplicitValue()
    485485{
    486     ASSERT(node());
     486    ASSERT(element());
    487487
    488488    if (!m_hasExplicitValue)
    … …  
    493493}
    494494
    495 static RenderListItem* previousOrNextItem(bool isListReversed, Node* list, RenderListItem* item)
     495static RenderListItem* previousOrNextItem(bool isListReversed, Element* list, RenderListItem* item)
    496496{
    497497    return isListReversed ? previousListItem(list, item) : nextListItem(list, item);
    … …  
    500500void RenderListItem::updateListMarkerNumbers()
    501501{
    502     Node* listNode = enclosingList(this);
     502    Element* listNode = enclosingList(this);
    503503    // The list node can be the shadow root which has no renderer.
    504504    ASSERT(listNode);

  • trunk/Source/WebCore/rendering/RenderMarquee.cpp

    r154583 r155374  
    7575{
    7676    int result = m_layer->renderer().style()->marqueeSpeed();
    77     Node* n = m_layer->renderer().node();
    78     if (n && n->hasTagName(marqueeTag)) {
    79         HTMLMarqueeElement* marqueeElt = static_cast<HTMLMarqueeElement*>(n);
    80         result = max(result, marqueeElt->minimumDelay());
     77    Element* element = m_layer->renderer().element();
     78    if (element && element->hasTagName(marqueeTag)) {
     79        HTMLMarqueeElement* marqueeElement = static_cast<HTMLMarqueeElement*>(element);
     80        result = max(result, marqueeElement->minimumDelay());
    8181    }
    8282    return result;

  • trunk/Source/WebCore/rendering/RenderMedia.cpp

    r154546 r155374  
    5555HTMLMediaElement* RenderMedia::mediaElement() const
    5656{
    57     return toHTMLMediaElement(node());
     57    return toHTMLMediaElement(element());
    5858}
    5959

  • trunk/Source/WebCore/rendering/RenderMediaControlElements.cpp

    r154546 r155374  
    7474
    7575    LayoutStateDisabler layoutStateDisabler(&view());
    76     MediaControlTimelineContainerElement* container = static_cast<MediaControlTimelineContainerElement*>(node());
     76    MediaControlTimelineContainerElement* container = static_cast<MediaControlTimelineContainerElement*>(element());
    7777    container->setTimeDisplaysHidden(width().toInt() < minWidthToDisplayTimeDisplays);
    7878}
    … …  
    9393        return;
    9494
    95     ASSERT(mediaControlElementType(node()) == MediaTextTrackDisplayContainer);
     95    ASSERT(mediaControlElementType(element()) == MediaTextTrackDisplayContainer);
    9696
    9797    LayoutStateDisabler layoutStateDisabler(&view());
    98     static_cast<MediaControlTextTrackContainerElement*>(node())->updateSizes();
     98    static_cast<MediaControlTextTrackContainerElement*>(element())->updateSizes();
    9999}
    100100

  • trunk/Source/WebCore/rendering/RenderMenuList.cpp

    r155074 r155374  
    135135inline HTMLSelectElement* RenderMenuList::selectElement() const
    136136{
    137     return toHTMLSelectElement(node());
     137    return toHTMLSelectElement(element());
    138138}
    139139
    … …  
    357357    // Check to ensure a page navigation has not occurred while
    358358    // the popup was up.
    359     Document& document = toElement(node())->document();
     359    Document& document = element()->document();
    360360    if (&document != document.frame()->document())
    361361        return;
    … …  
    540540    bool hasCustomScrollbarStyle = style()->hasPseudoStyle(SCROLLBAR);
    541541    if (hasCustomScrollbarStyle)
    542         widget = RenderScrollbar::createCustomScrollbar(scrollableArea, orientation, this->node());
     542        widget = RenderScrollbar::createCustomScrollbar(scrollableArea, orientation, element());
    543543    else
    544544        widget = Scrollbar::createNativeScrollbar(scrollableArea, orientation, controlSize);

  • trunk/Source/WebCore/rendering/RenderMeter.cpp

    r155211 r155374  
    4444HTMLMeterElement* RenderMeter::meterElement() const
    4545{
    46     ASSERT(node());
     46    ASSERT(element());
    4747
    48     if (isHTMLMeterElement(node()))
    49         return toHTMLMeterElement(node());
     48    if (isHTMLMeterElement(element()))
     49        return toHTMLMeterElement(element());
    5050
    51     ASSERT(node()->shadowHost());
    52     return toHTMLMeterElement(node()->shadowHost());
     51    ASSERT(element()->shadowHost());
     52    return toHTMLMeterElement(element()->shadowHost());
    5353}
    5454

  • trunk/Source/WebCore/rendering/RenderPart.cpp

    r148188 r155374  
    8484        return true;
    8585
    86     if (!node() || !node()->isFrameOwnerElement())
     86    if (!element() || !element()->isFrameOwnerElement())
    8787        return false;
    8888
    89     HTMLFrameOwnerElement* element = toFrameOwnerElement(node());
    90     if (Document* contentDocument = element->contentDocument()) {
     89    HTMLFrameOwnerElement* frameOwnerElement = toFrameOwnerElement(element());
     90    if (Document* contentDocument = frameOwnerElement->contentDocument()) {
    9191        if (RenderView* view = contentDocument->renderView())
    9292            return view->usesCompositing();
    … …  
    106106RenderBox* RenderPart::embeddedContentBox() const
    107107{
    108     if (!node() || !widget() || !widget()->isFrameView())
     108    if (!element() || !widget() || !widget()->isFrameView())
    109109        return 0;
    110110    return toFrameView(widget())->embeddedContentBox();

  • trunk/Source/WebCore/rendering/RenderProgress.cpp

    r155211 r155374  
    103103HTMLProgressElement* RenderProgress::progressElement() const
    104104{
    105     if (!node())
     105    if (!element())
    106106        return 0;
    107107
    108     if (isHTMLProgressElement(node()))
    109         return toHTMLProgressElement(node());
     108    if (isHTMLProgressElement(element()))
     109        return toHTMLProgressElement(element());
    110110
    111     ASSERT(node()->shadowHost());
    112     return toHTMLProgressElement(node()->shadowHost());
     111    ASSERT(element()->shadowHost());
     112    return toHTMLProgressElement(element()->shadowHost());
    113113}   
    114114

  • trunk/Source/WebCore/rendering/RenderReplaced.cpp

    r155318 r155374  
    506506        return createVisiblePosition(caretMaxOffset(), DOWNSTREAM); // coordinates are below
    507507   
    508     if (node()) {
     508    if (element()) {
    509509        if (lineDirectionPosition <= logicalLeft() + (logicalWidth() / 2))
    510510            return createVisiblePosition(0, DOWNSTREAM);
    … …  
    569569        return selectionStart == 0;
    570570       
    571     int end = node()->hasChildNodes() ? node()->childNodeCount() : 1;
     571    int end = element()->hasChildNodes() ? element()->childNodeCount() : 1;
    572572    if (s == SelectionEnd)
    573573        return selectionEnd == end;

  • trunk/Source/WebCore/rendering/RenderSearchField.cpp

    r154580 r155374  
    200200const AtomicString& RenderSearchField::autosaveName() const
    201201{
    202     return toElement(node())->getAttribute(autosaveAttr);
     202    return element()->getAttribute(autosaveAttr);
    203203}
    204204
    … …  
    358358    bool hasCustomScrollbarStyle = style()->hasPseudoStyle(SCROLLBAR);
    359359    if (hasCustomScrollbarStyle)
    360         widget = RenderScrollbar::createCustomScrollbar(scrollableArea, orientation, this->node());
     360        widget = RenderScrollbar::createCustomScrollbar(scrollableArea, orientation, element());
    361361    else
    362362        widget = Scrollbar::createNativeScrollbar(scrollableArea, orientation, controlSize);

  • trunk/Source/WebCore/rendering/RenderSlider.cpp

    r154871 r155374  
    111111    // FIXME: Find a way to cascade appearance.
    112112    // http://webkit.org/b/62535
    113     RenderBox* thumbBox = sliderThumbElementOf(node())->renderBox();
     113    RenderBox* thumbBox = sliderThumbElementOf(element())->renderBox();
    114114    if (thumbBox && thumbBox->isSliderThumb())
    115115        static_cast<RenderSliderThumb*>(thumbBox)->updateAppearance(style());
    … …  
    120120bool RenderSlider::inDragMode() const
    121121{
    122     return sliderThumbElementOf(node())->active();
     122    return sliderThumbElementOf(element())->active();
    123123}
    124124

  • trunk/Source/WebCore/rendering/RenderSnapshottedPlugIn.cpp

    r154580 r155374  
    6363HTMLPlugInImageElement* RenderSnapshottedPlugIn::plugInImageElement() const
    6464{
    65     return toHTMLPlugInImageElement(node());
     65    return toHTMLPlugInImageElement(element());
    6666}
    6767

  • trunk/Source/WebCore/rendering/RenderTable.cpp

    r154580 r155374  
    321321    // HTML tables' width styles already include borders and paddings, but CSS tables' width styles do not.
    322322    LayoutUnit borders = 0;
    323     bool isCSSTable = !node() || !isHTMLTableElement(node());
     323    bool isCSSTable = !element() || !isHTMLTableElement(element());
    324324    if (isCSSTable && styleLogicalWidth.isSpecified() && styleLogicalWidth.isPositive() && style()->boxSizing() == CONTENT_BOX)
    325325        borders = borderStart() + borderEnd() + (collapseBorders() ? LayoutUnit() : paddingStart() + paddingEnd());
    … …  
    335335        LayoutUnit borders = LayoutUnit();
    336336        // FIXME: We cannot apply box-sizing: content-box on <table> which other browsers allow.
    337         if ((node() && isHTMLTableElement(node())) || style()->boxSizing() == BORDER_BOX) {
     337        if ((element() && isHTMLTableElement(element())) || style()->boxSizing() == BORDER_BOX) {
    338338            LayoutUnit borderAndPaddingBefore = borderBefore() + (collapseBorders() ? LayoutUnit() : paddingBefore());
    339339            LayoutUnit borderAndPaddingAfter = borderAfter() + (collapseBorders() ? LayoutUnit() : paddingAfter());
    … …  
    14071407    if (visibleToHitTesting() && (action == HitTestBlockBackground || action == HitTestChildBlockBackground) && locationInContainer.intersects(boundsRect)) {
    14081408        updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(adjustedLocation)));
    1409         if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
     1409        if (!result.addNodeToRectBasedTestResult(element(), request, locationInContainer, boundsRect))
    14101410            return true;
    14111411    }

  • trunk/Source/WebCore/rendering/RenderTableCell.cpp

    r155211 r155374  
    7979unsigned RenderTableCell::parseColSpanFromDOM() const
    8080{
    81     ASSERT(node());
    82     if (node()->hasTagName(tdTag) || node()->hasTagName(thTag))
    83         return min<unsigned>(toHTMLTableCellElement(node())->colSpan(), maxColumnIndex);
     81    ASSERT(element());
     82    if (element()->hasTagName(tdTag) || element()->hasTagName(thTag))
     83        return min<unsigned>(toHTMLTableCellElement(element())->colSpan(), maxColumnIndex);
    8484#if ENABLE(MATHML)
    85     if (node()->hasTagName(MathMLNames::mtdTag))
    86         return min<unsigned>(toMathMLElement(node())->colSpan(), maxColumnIndex);
     85    if (element()->hasTagName(MathMLNames::mtdTag))
     86        return min<unsigned>(toMathMLElement(element())->colSpan(), maxColumnIndex);
    8787#endif
    8888    return 1;
    … …  
    9191unsigned RenderTableCell::parseRowSpanFromDOM() const
    9292{
    93     ASSERT(node());
    94     if (node()->hasTagName(tdTag) || node()->hasTagName(thTag))
    95         return min<unsigned>(toHTMLTableCellElement(node())->rowSpan(), maxRowIndex);
     93    ASSERT(element());
     94    if (element()->hasTagName(tdTag) || element()->hasTagName(thTag))
     95        return min<unsigned>(toHTMLTableCellElement(element())->rowSpan(), maxRowIndex);
    9696#if ENABLE(MATHML)
    97     if (node()->hasTagName(MathMLNames::mtdTag))
    98         return min<unsigned>(toMathMLElement(node())->rowSpan(), maxRowIndex);
     97    if (element()->hasTagName(MathMLNames::mtdTag))
     98        return min<unsigned>(toMathMLElement(element())->rowSpan(), maxRowIndex);
    9999#endif
    100100    return 1;
    … …  
    105105    // The vast majority of table cells do not have a colspan or rowspan,
    106106    // so we keep a bool to know if we need to bother reading from the DOM.
    107     m_hasColSpan = node() && parseColSpanFromDOM() != 1;
    108     m_hasRowSpan = node() && parseRowSpanFromDOM() != 1;
     107    m_hasColSpan = element() && parseColSpanFromDOM() != 1;
     108    m_hasRowSpan = element() && parseRowSpanFromDOM() != 1;
    109109}
    110110
    111111void RenderTableCell::colSpanOrRowSpanChanged()
    112112{
    113     ASSERT(node());
     113    ASSERT(element());
    114114#if ENABLE(MATHML)
    115     ASSERT(node()->hasTagName(tdTag) || node()->hasTagName(thTag) || node()->hasTagName(MathMLNames::mtdTag));
     115    ASSERT(element()->hasTagName(tdTag) || element()->hasTagName(thTag) || element()->hasTagName(MathMLNames::mtdTag));
    116116#else
    117     ASSERT(node()->hasTagName(tdTag) || node()->hasTagName(thTag));
     117    ASSERT(element()->hasTagName(tdTag) || element()->hasTagName(thTag));
    118118#endif
    119119
    … …  
    167167
    168168    RenderBlock::computePreferredLogicalWidths();
    169     if (node() && style()->autoWrap()) {
     169    if (element() && style()->autoWrap()) {
    170170        // See if nowrap was set.
    171171        Length w = styleOrColLogicalWidth();
    172         String nowrap = toElement(node())->getAttribute(nowrapAttr);
     172        String nowrap = element()->getAttribute(nowrapAttr);
    173173        if (!nowrap.isNull() && w.isFixed())
    174174            // Nowrap is set, but we didn't actually use it because of the

  • trunk/Source/WebCore/rendering/RenderTableCol.cpp

    r148921 r155374  
    6060{
    6161    unsigned oldSpan = m_span;
    62     Node* n = node();
    63     if (n && (n->hasTagName(colTag) || n->hasTagName(colgroupTag))) {
    64         HTMLTableColElement* tc = static_cast<HTMLTableColElement*>(n);
     62    Element* element = this->element();
     63    if (element && (element->hasTagName(colTag) || element->hasTagName(colgroupTag))) {
     64        HTMLTableColElement* tc = static_cast<HTMLTableColElement*>(element);
    6565        m_span = tc->span();
    6666    } else

  • trunk/Source/WebCore/rendering/RenderTextControl.cpp

    r155211 r155374  
    4949HTMLTextFormControlElement* RenderTextControl::textFormControlElement() const
    5050{
    51     return toHTMLTextFormControlElement(node());
     51    return toHTMLTextFormControlElement(element());
    5252}
    5353
    … …  
    9797    textBlockStyle->setUnicodeBidi(style()->unicodeBidi());
    9898
    99     bool disabled = updateUserModifyProperty(node(), textBlockStyle);
     99    bool disabled = updateUserModifyProperty(element(), textBlockStyle);
    100100    if (disabled)
    101101        textBlockStyle->setColor(theme()->disabledTextColor(textBlockStyle->visitedDependentColor(CSSPropertyColor), startStyle->visitedDependentColor(CSSPropertyBackgroundColor)));
    … …  
    123123    Element* innerText = innerTextElement();
    124124    if (innerText && innerText->renderer())
    125         updateUserModifyProperty(node(), innerText->renderer()->style());
     125        updateUserModifyProperty(element(), innerText->renderer()->style());
    126126}
    127127
    … …  
    298298RenderObject* RenderTextControl::layoutSpecialExcludedChild(bool relayoutChildren)
    299299{
    300     HTMLElement* placeholder = toHTMLTextFormControlElement(node())->placeholderElement();
     300    HTMLElement* placeholder = toHTMLTextFormControlElement(element())->placeholderElement();
    301301    RenderObject* placeholderRenderer = placeholder ? placeholder->renderer() : 0;
    302302    if (!placeholderRenderer)

  • trunk/Source/WebCore/rendering/RenderTextControlMultiLine.cpp

    r152218 r155374  
    4040RenderTextControlMultiLine::~RenderTextControlMultiLine()
    4141{
    42     if (node() && node()->inDocument())
    43         toHTMLTextAreaElement(node())->rendererWillBeDestroyed();
     42    if (element() && element()->inDocument())
     43        toHTMLTextAreaElement(element())->rendererWillBeDestroyed();
    4444}
    4545
    … …  
    4949        return false;
    5050
    51     if (result.innerNode() == node() || result.innerNode() == innerTextElement())
     51    if (result.innerNode() == element() || result.innerNode() == innerTextElement())
    5252        hitInnerTextElement(result, locationInContainer.point(), accumulatedOffset);
    5353
    … …  
    6868LayoutUnit RenderTextControlMultiLine::preferredContentLogicalWidth(float charWidth) const
    6969{
    70     int factor = toHTMLTextAreaElement(node())->cols();
     70    int factor = toHTMLTextAreaElement(element())->cols();
    7171    return static_cast<LayoutUnit>(ceilf(charWidth * factor)) + scrollbarThickness();
    7272}
    … …  
    7474LayoutUnit RenderTextControlMultiLine::computeControlLogicalHeight(LayoutUnit lineHeight, LayoutUnit nonContentHeight) const
    7575{
    76     return lineHeight * toHTMLTextAreaElement(node())->rows() + nonContentHeight;
     76    return lineHeight * toHTMLTextAreaElement(element())->rows() + nonContentHeight;
    7777}
    7878

  • trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp

    r154580 r155374  
    234234    //  - we hit regions not in any decoration buttons.
    235235    HTMLElement* container = containerElement();
    236     if (result.innerNode()->isDescendantOf(innerTextElement()) || result.innerNode() == node() || (container && container == result.innerNode())) {
     236    if (result.innerNode()->isDescendantOf(innerTextElement()) || result.innerNode() == element() || (container && container == result.innerNode())) {
    237237        LayoutPoint pointInParent = locationInContainer.point();
    238238        if (container && innerBlockElement()) {
    … …  
    274274void RenderTextControlSingleLine::capsLockStateMayHaveChanged()
    275275{
    276     if (!node())
     276    if (!element())
    277277        return;
    278278
    … …  
    285285        inputElement()->isPasswordField()
    286286        && frame().selection().isFocusedAndActive()
    287         && document().focusedElement() == node()
     287        && document().focusedElement() == element()
    288288        && PlatformKeyboardEvent::currentCapsLockState();
    289289
    … …  
    405405bool RenderTextControlSingleLine::textShouldBeTruncated() const
    406406{
    407     return document().focusedElement() != node()
     407    return document().focusedElement() != element()
    408408        && style()->textOverflow() == TextOverflowEllipsis;
    409409}
    … …  
    480480HTMLInputElement* RenderTextControlSingleLine::inputElement() const
    481481{
    482     return node()->toInputElement();
    483 }
    484 
    485 }
     482    return element()->toInputElement();
     483}
     484
     485}

  • trunk/Source/WebCore/rendering/RenderThemeMac.mm

    r154546 r155374  
    20462046    // plugin itself by asking for the shadow root parent, and then its parent.
    20472047
    2048     if (!renderBlock->node()->isHTMLElement())
     2048    if (!renderBlock->element()->isHTMLElement())
    20492049        return true;
    20502050
    2051     HTMLElement* plugInOverlay = toHTMLElement(renderBlock->node());
     2051    HTMLElement* plugInOverlay = toHTMLElement(renderBlock->element());
    20522052    Element* parent = plugInOverlay->parentOrShadowHostElement();
    20532053    while (parent && !parent->isPluginElement())

  • trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

    r155370 r155374  
    671671        ts << "RenderRegion";
    672672        if (renderRegion->generatingElement()) {
    673             String tagName = getTagName(renderRegion->node());
     673            String tagName = getTagName(renderRegion->element());
    674674            if (!tagName.isEmpty())
    675675                ts << " {" << tagName << "}";

  • trunk/Source/WebCore/rendering/RenderVideo.cpp

    r154921 r155374  
    8585
    8686    // Never set the element size to zero when in a media document.
    87     if (size.isEmpty() && node()->ownerDocument() && node()->ownerDocument()->isMediaDocument())
     87    if (size.isEmpty() && element()->document().isMediaDocument())
    8888        return;
    8989
    … …  
    214214HTMLVideoElement* RenderVideo::videoElement() const
    215215{
    216     return toHTMLVideoElement(node());
     216    return toHTMLVideoElement(element());
    217217}
    218218

  • trunk/Source/WebCore/rendering/RenderWidget.cpp

    r154962 r155374  
    141141bool RenderWidget::setWidgetGeometry(const LayoutRect& frame)
    142142{
    143     if (!node())
     143    if (!element())
    144144        return false;
    145145
    … …  
    155155
    156156    RenderWidgetProtector protector(this);
    157     Ref<Node> protectNode(*node());
     157    Ref<Element> protectNode(*element());
    158158    m_widget->setFrameRect(newFrame);
    159159
    … …  
    343343void RenderWidget::updateWidgetPosition()
    344344{
    345     if (!m_widget || !node()) // Check the node in case destroy() has been called.
     345    if (!m_widget || !element()) // Check the node in case destroy() has been called.
    346346        return;
    347347
    … …  
    398398
    399399    // Check to see if we are really over the widget itself (and not just in the border/padding area).
    400     if ((inside || result.isRectBasedTest()) && !hadResult && result.innerNode() == node())
     400    if ((inside || result.isRectBasedTest()) && !hadResult && result.innerNode() == element())
    401401        result.setIsOverWidget(contentBoxRect().contains(result.localPoint()));
    402402    return inside;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFenced.cpp

    r145562 r155374  
    5656void RenderMathMLFenced::updateFromElement()
    5757{
    58     Element* fenced = toElement(node());
     58    Element* fenced = element();
    5959 
    6060    // FIXME: Handle open/close values with more than one character (they should be treated like text).
    … …  
    9090    if (operatorType == RenderMathMLOperator::Fence)
    9191        newStyle->setMarginStart(Length(gFenceMarginEms * style()->fontSize(), Fixed));
    92     RenderMathMLOperator* newOperator = new (renderArena()) RenderMathMLOperator(toElement(node()), uChar);
     92    RenderMathMLOperator* newOperator = new (renderArena()) RenderMathMLOperator(element(), uChar);
    9393    newOperator->setOperatorType(operatorType);
    9494    newOperator->setStyle(newStyle.release());
    … …  
    157157   
    158158    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
    159         if (child->node() == node()) {
     159        if (child->node() == element()) {
    160160            ASSERT(child->style()->refCount() == 1);
    161161            child->style()->inheritFrom(style());

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp

    r153088 r155374  
    6464        return;
    6565   
    66     Element* fraction = toElement(node());
     66    Element* fraction = element();
    6767   
    6868    RenderObject* numeratorWrapper = firstChild();

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp

    r155211 r155374  
    137137void RenderMathMLOperator::updateFromElement()
    138138{
    139     RenderObject* savedRenderer = node()->renderer();
     139    RenderObject* savedRenderer = element()->renderer();
    140140
    141141    // Destroy our current children
    … …  
    144144    // Since we share a node with our children, destroying our children may set our node's
    145145    // renderer to 0, so we need to restore it.
    146     node()->setRenderer(savedRenderer);
     146    element()->setRenderer(savedRenderer);
    147147   
    148148    // If the operator is fixed, it will be contained in m_operator
    … …  
    153153   
    154154    // We may need the element later if we can't stretch.
    155     if (node()->isElementNode()) {
    156         if (Element* mo = toElement(node())) {
    157             AtomicString stretchyAttr = mo->getAttribute(MathMLNames::stretchyAttr);
    158             stretchDisabled = equalIgnoringCase(stretchyAttr, "false");
    159            
    160             // If stretching isn't disabled, get the character from the text content.
    161             if (!stretchDisabled && !firstChar) {
    162                 String opText = mo->textContent();
    163                 for (unsigned int i = 0; !firstChar && i < opText.length(); i++) {
    164                     if (!isSpaceOrNewline(opText[i]))
    165                         firstChar = opText[i];
    166                 }
    167             }
    168         }
    169     }
    170    
     155    Element* mo = element();
     156    AtomicString stretchyAttr = mo->getAttribute(MathMLNames::stretchyAttr);
     157    stretchDisabled = equalIgnoringCase(stretchyAttr, "false");
     158   
     159    // If stretching isn't disabled, get the character from the text content.
     160    if (!stretchDisabled && !firstChar) {
     161        String opText = mo->textContent();
     162        for (unsigned i = 0; !firstChar && i < opText.length(); i++) {
     163            if (!isSpaceOrNewline(opText[i]))
     164                firstChar = opText[i];
     165        }
     166    }
     167
    171168    // The 'index' holds the stretchable character's glyph information
    172169    int index = -1;
    … …  
    209206    if (stretchDisabled || !shouldStack) {
    210207        m_isStacked = false;
    211         RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
     208        RenderBlock* container = new (renderArena()) RenderMathMLBlock(element());
    212209        // This container doesn't offer any useful information to accessibility.
    213210        toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
    … …  
    233230        RenderText* text = 0;
    234231        if (m_operator)
    235             text = new (renderArena()) RenderText(node(), StringImpl::create(&m_operator, 1));
    236         else if (node()->isElementNode())
    237             if (Element* mo = toElement(node()))
    238                 text = new (renderArena()) RenderText(node(), mo->textContent().replace(hyphenMinus, minusSign).impl());
     232            text = new (renderArena()) RenderText(element(), StringImpl::create(&m_operator, 1));
     233        else
     234            text = new (renderArena()) RenderText(element(), element()->textContent().replace(hyphenMinus, minusSign).impl());
    239235        // If we can't figure out the text, leave it blank.
    240236        if (text) {
    … …  
    303299RenderBlock* RenderMathMLOperator::createGlyph(UChar glyph, int maxHeightForRenderer, int charRelative)
    304300{
    305     RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
     301    RenderBlock* container = new (renderArena()) RenderMathMLBlock(element());
    306302    toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
    307303    container->setStyle(createStackableStyle(maxHeightForRenderer));
    … …  
    309305    RenderBlock* parent = container;
    310306    if (charRelative) {
    311         RenderBlock* charBlock = new (renderArena()) RenderBlockFlow(node());
     307        RenderBlock* charBlock = new (renderArena()) RenderBlockFlow(element());
    312308        RefPtr<RenderStyle> charStyle = RenderStyle::create();
    313309        charStyle->inheritFrom(container->style());
    … …  
    320316    }
    321317   
    322     RenderText* text = new (renderArena()) RenderText(node(), StringImpl::create(&glyph, 1));
     318    RenderText* text = new (renderArena()) RenderText(element(), StringImpl::create(&glyph, 1));
    323319    text->setStyle(container->style());
    324320    parent->addChild(text);

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSpace.cpp

    r152840 r155374  
    5353void RenderMathMLSpace::updateFromElement()
    5454{
    55     Element* space = toElement(node());
     55    Element* space = element();
    5656
    5757    // This parses the mspace attributes, using 0 as the default values.

  • trunk/Source/WebCore/rendering/svg/RenderSVGForeignObject.cpp

    r154546 r155374  
    130130
    131131    LayoutRepainter repainter(*this, SVGRenderSupport::checkForSVGRepaintDuringLayout(this));
    132     SVGForeignObjectElement* foreign = static_cast<SVGForeignObjectElement*>(node());
     132    SVGForeignObjectElement* foreign = static_cast<SVGForeignObjectElement*>(element());
    133133
    134134    bool updateCachedBoundariesInParents = false;

  • trunk/Source/WebCore/rendering/svg/RenderSVGRoot.cpp

    r155370 r155374  
    8080    // and do not indicate a percentage of the containing block. Rather, once the viewport is established, they indicate the portion
    8181    // of the viewport that is actually covered by image data.
    82     SVGSVGElement* svg = toSVGSVGElement(node());
     82    SVGSVGElement* svg = toSVGSVGElement(element());
    8383    ASSERT(svg);
    8484    Length intrinsicWidthAttribute = svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties);
    … …  
    124124bool RenderSVGRoot::isEmbeddedThroughSVGImage() const
    125125{
    126     if (!node())
     126    if (!element())
    127127        return false;
    128     return isInSVGImage(toSVGSVGElement(node()));
     128    return isInSVGImage(toSVGSVGElement(element()));
    129129}
    130130
    131131bool RenderSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const
    132132{
    133     if (!node())
     133    if (!element())
    134134        return false;
    135135
    … …  
    148148LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
    149149{
    150     SVGSVGElement* svg = toSVGSVGElement(node());
     150    SVGSVGElement* svg = toSVGSVGElement(element());
    151151    ASSERT(svg);
    152152
    … …  
    171171LayoutUnit RenderSVGRoot::computeReplacedLogicalHeight() const
    172172{
    173     SVGSVGElement* svg = toSVGSVGElement(node());
     173    SVGSVGElement* svg = toSVGSVGElement(element());
    174174    ASSERT(svg);
    175175
    … …  
    222222    buildLocalToBorderBoxTransform();
    223223
    224     SVGSVGElement* svg = toSVGSVGElement(node());
     224    SVGSVGElement* svg = toSVGSVGElement(element());
    225225    ASSERT(svg);
    226226    m_isLayoutSizeChanged = needsLayout || (svg->hasRelativeLengths() && oldSize != size());
    … …  
    263263    // An empty viewBox also disables rendering.
    264264    // (http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute)
    265     SVGSVGElement* svg = toSVGSVGElement(node());
     265    SVGSVGElement* svg = toSVGSVGElement(element());
    266266    ASSERT(svg);
    267267    if (svg->hasEmptyViewBox())
    … …  
    349349void RenderSVGRoot::buildLocalToBorderBoxTransform()
    350350{
    351     SVGSVGElement* svg = toSVGSVGElement(node());
     351    SVGSVGElement* svg = toSVGSVGElement(element());
    352352    ASSERT(svg);
    353353    float scale = style()->effectiveZoom();
    … …  
    449449        if (locationInContainer.intersects(boundsRect)) {
    450450            updateHitTestResult(result, pointInBorderBox);
    451             if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
     451            if (!result.addNodeToRectBasedTestResult(element(), request, locationInContainer, boundsRect))
    452452                return true;
    453453        }
    … …  
    459459bool RenderSVGRoot::hasRelativeDimensions() const
    460460{
    461     SVGSVGElement* svg = toSVGSVGElement(node());
     461    SVGSVGElement* svg = toSVGSVGElement(element());
    462462    ASSERT(svg);
    463463
    … …  
    467467bool RenderSVGRoot::hasRelativeIntrinsicLogicalWidth() const
    468468{
    469     SVGSVGElement* svg = toSVGSVGElement(node());
     469    SVGSVGElement* svg = toSVGSVGElement(element());
    470470    ASSERT(svg);
    471471    return svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties).isPercent();
    … …  
    474474bool RenderSVGRoot::hasRelativeLogicalHeight() const
    475475{
    476     SVGSVGElement* svg = toSVGSVGElement(node());
     476    SVGSVGElement* svg = toSVGSVGElement(element());
    477477    ASSERT(svg);
    478478

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp

    r154937 r155374  
    355355    bool updateCachedBoundariesInParents = false;
    356356    if (m_needsTransformUpdate) {
    357         SVGTextElement* text = static_cast<SVGTextElement*>(node());
     357        SVGTextElement* text = static_cast<SVGTextElement*>(element());
    358358        m_localTransform = text->animatedLocalTransform();
    359359        m_needsTransformUpdate = false;
    … …  
    513513        return strokeBoundaries;
    514514
    515     ASSERT(node());
    516     ASSERT(node()->isSVGElement());
    517     SVGLengthContext lengthContext(toSVGElement(node()));
     515    ASSERT(element());
     516    ASSERT(element()->isSVGElement());
     517    SVGLengthContext lengthContext(toSVGElement(element()));
    518518    strokeBoundaries.inflate(svgStyle->strokeWidth().value(lengthContext));
    519519    return strokeBoundaries;

  • trunk/Source/WebCore/rendering/svg/RenderSVGTextPath.cpp

    r154877 r155374  
    4242Path RenderSVGTextPath::layoutPath() const
    4343{
    44     SVGTextPathElement* textPathElement = toSVGTextPathElement(node());
     44    SVGTextPathElement* textPathElement = toSVGTextPathElement(element());
    4545    Element* targetElement = SVGURIReference::targetElementFromIRIString(textPathElement->href(), &textPathElement->document());
    4646    if (!targetElement || !targetElement->hasTagName(SVGNames::pathTag))
    … …  
    6363float RenderSVGTextPath::startOffset() const
    6464{
    65     return toSVGTextPathElement(node())->startOffset().valueAsPercentage();
     65    return toSVGTextPathElement(element())->startOffset().valueAsPercentage();
    6666}
    6767
    6868bool RenderSVGTextPath::exactAlignment() const
    6969{
    70     return toSVGTextPathElement(node())->spacing() == SVGTextPathSpacingExact;
     70    return toSVGTextPathElement(element())->spacing() == SVGTextPathSpacingExact;
    7171}
    7272
    7373bool RenderSVGTextPath::stretchMethod() const
    7474{
    75     return toSVGTextPathElement(node())->method() == SVGTextPathMethodStretch;
     75    return toSVGTextPathElement(element())->method() == SVGTextPathMethodStretch;
    7676}
    7777
Note: See TracChangeset for help on using the changeset viewer.