Changeset 140039 in webkit


Ignore:
Timestamp:
Jan 17, 2013 2:06:13 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r140023.
​http://trac.webkit.org/changeset/140023
​https://bugs.webkit.org/show_bug.cgi?id=107176

Broke some tests (Requested by anttik on #webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2013-01-17

Source/WebCore:

  • page/FrameView.cpp:

(WebCore::FrameView::updateScrollCorner):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::createReplacementRunIn):
(WebCore::RenderBlock::updateFirstLetterStyle):
(WebCore::RenderBlock::createFirstLetterRenderer):
(WebCore::RenderBlock::createAnonymousWithParentRendererAndDisplay):
(WebCore::RenderBlock::createAnonymousColumnsWithParentRenderer):
(WebCore::RenderBlock::createAnonymousColumnSpanWithParentRenderer):

  • rendering/RenderBlock.h:

(RenderBlock):

  • rendering/RenderDeprecatedFlexibleBox.cpp:

(WebCore::RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox):

  • rendering/RenderDeprecatedFlexibleBox.h:

(RenderDeprecatedFlexibleBox):

  • rendering/RenderDetailsMarker.cpp:

(WebCore::RenderDetailsMarker::RenderDetailsMarker):

  • rendering/RenderDetailsMarker.h:

(RenderDetailsMarker):

  • rendering/RenderDialog.h:

(WebCore::RenderDialog::RenderDialog):

  • rendering/RenderFieldset.cpp:

(WebCore::RenderFieldset::RenderFieldset):

  • rendering/RenderFieldset.h:

(RenderFieldset):

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::RenderFlexibleBox):

  • rendering/RenderFlexibleBox.h:

(RenderFlexibleBox):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::RenderFlowThread):

  • rendering/RenderFlowThread.h:
  • rendering/RenderFullScreen.cpp:

(RenderFullScreenPlaceholder::RenderFullScreenPlaceholder):
(RenderFullScreen::RenderFullScreen):
(RenderFullScreen::wrapRenderer):

  • rendering/RenderFullScreen.h:

(RenderFullScreen):

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::RenderGrid):

  • rendering/RenderGrid.h:

(RenderGrid):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::RenderImage):

  • rendering/RenderImage.h:

(RenderImage):

  • rendering/RenderInline.cpp:

(WebCore::RenderInline::RenderInline):
(WebCore::RenderInline::addChildIgnoringContinuation):

  • rendering/RenderInline.h:

(RenderInline):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::updateScrollCornerStyle):
(WebCore::RenderLayer::updateResizerStyle):
(WebCore::RenderLayer::createReflection):

  • rendering/RenderListItem.cpp:

(WebCore::RenderListItem::RenderListItem):
(WebCore::RenderListItem::styleDidChange):

  • rendering/RenderListItem.h:

(RenderListItem):

  • rendering/RenderListMarker.cpp:

(WebCore::RenderListMarker::RenderListMarker):

  • rendering/RenderListMarker.h:

(RenderListMarker):

  • rendering/RenderMediaControlElements.cpp:

(WebCore::RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer):
(WebCore::RenderMediaControlTimeDisplay::RenderMediaControlTimeDisplay):
(WebCore::RenderTextTrackContainerElement::RenderTextTrackContainerElement):

  • rendering/RenderMediaControlElements.h:

(RenderMediaVolumeSliderContainer):
(RenderMediaControlTimeDisplay):
(RenderTextTrackContainerElement):

  • rendering/RenderMultiColumnBlock.cpp:

(WebCore::RenderMultiColumnBlock::RenderMultiColumnBlock):
(WebCore::RenderMultiColumnBlock::ensureColumnSets):

  • rendering/RenderMultiColumnBlock.h:

(RenderMultiColumnBlock):

  • rendering/RenderMultiColumnFlowThread.cpp:

(WebCore::RenderMultiColumnFlowThread::RenderMultiColumnFlowThread):

  • rendering/RenderMultiColumnFlowThread.h:

(RenderMultiColumnFlowThread):

  • rendering/RenderMultiColumnSet.cpp:

(WebCore::RenderMultiColumnSet::RenderMultiColumnSet):

  • rendering/RenderMultiColumnSet.h:

(RenderMultiColumnSet):

  • rendering/RenderNamedFlowThread.cpp:

(WebCore::RenderNamedFlowThread::RenderNamedFlowThread):

  • rendering/RenderNamedFlowThread.h:

(RenderNamedFlowThread):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::RenderObject):

  • rendering/RenderObject.h:

(WebCore::RenderObject::setIsAnonymous):
(RenderObject):
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):

  • rendering/RenderRegion.cpp:

(WebCore::RenderRegion::RenderRegion):

  • rendering/RenderRegion.h:

(RenderRegion):

  • rendering/RenderRegionSet.cpp:

(WebCore::RenderRegionSet::RenderRegionSet):

  • rendering/RenderRegionSet.h:

(RenderRegionSet):

  • rendering/RenderReplaced.cpp:

(WebCore::RenderReplaced::RenderReplaced):

  • rendering/RenderReplaced.h:

(RenderReplaced):

  • rendering/RenderReplica.cpp:

(WebCore::RenderReplica::RenderReplica):

  • rendering/RenderReplica.h:

(RenderReplica):

  • rendering/RenderRuby.cpp:

(WebCore::createAnonymousRubyInlineBlock):
(WebCore::RenderRubyAsInline::RenderRubyAsInline):
(WebCore):
(WebCore::RenderRubyAsBlock::RenderRubyAsBlock):

  • rendering/RenderRuby.h:

(RenderRubyAsInline):
(RenderRubyAsBlock):

  • rendering/RenderRubyBase.cpp:

(WebCore::RenderRubyBase::RenderRubyBase):

  • rendering/RenderRubyBase.h:

(RenderRubyBase):

  • rendering/RenderRubyRun.cpp:

(WebCore::RenderRubyRun::RenderRubyRun):
(WebCore::RenderRubyRun::createRubyBase):
(WebCore::RenderRubyRun::staticCreateRubyRun):

  • rendering/RenderRubyRun.h:

(RenderRubyRun):

  • rendering/RenderRubyText.cpp:

(WebCore::RenderRubyText::RenderRubyText):

  • rendering/RenderRubyText.h:

(RenderRubyText):

  • rendering/RenderScrollbar.cpp:

(WebCore::RenderScrollbar::updateScrollbarPart):

  • rendering/RenderScrollbarPart.cpp:

(WebCore::RenderScrollbarPart::RenderScrollbarPart):

  • rendering/RenderScrollbarPart.h:

(RenderScrollbarPart):

  • rendering/RenderSearchField.cpp:

(WebCore::RenderSearchField::RenderSearchField):

  • rendering/RenderSearchField.h:

(RenderSearchField):

  • rendering/RenderTable.cpp:

(WebCore::RenderTable::RenderTable):
(WebCore::RenderTable::createAnonymousWithParentRenderer):

  • rendering/RenderTable.h:

(RenderTable):

  • rendering/RenderTableCaption.cpp:

(WebCore::RenderTableCaption::RenderTableCaption):

  • rendering/RenderTableCaption.h:

(RenderTableCaption):

  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::RenderTableCell):
(WebCore::RenderTableCell::createAnonymousWithParentRenderer):

  • rendering/RenderTableCell.h:

(RenderTableCell):

  • rendering/RenderTableCol.cpp:

(WebCore::RenderTableCol::RenderTableCol):

  • rendering/RenderTableCol.h:

(RenderTableCol):

  • rendering/RenderTableRow.cpp:

(WebCore::RenderTableRow::RenderTableRow):
(WebCore::RenderTableRow::createAnonymousWithParentRenderer):

  • rendering/RenderTableRow.h:

(RenderTableRow):

  • rendering/RenderTableSection.cpp:

(WebCore::RenderTableSection::RenderTableSection):
(WebCore::RenderTableSection::createAnonymousWithParentRenderer):

  • rendering/RenderTableSection.h:

(RenderTableSection):

  • rendering/RenderTextControl.cpp:

(WebCore::RenderTextControl::RenderTextControl):

  • rendering/RenderTextControl.h:

(RenderTextControl):

  • rendering/RenderTextControlMultiLine.cpp:

(WebCore::RenderTextControlMultiLine::RenderTextControlMultiLine):

  • rendering/RenderTextControlMultiLine.h:

(RenderTextControlMultiLine):

  • rendering/RenderTextControlSingleLine.cpp:

(WebCore::RenderTextControlSingleLine::RenderTextControlSingleLine):

  • rendering/RenderTextControlSingleLine.h:

(RenderTextControlSingleLine):
(WebCore::RenderTextControlInnerBlock::RenderTextControlInnerBlock):

  • rendering/RenderTextTrackCue.cpp:

(WebCore::RenderTextTrackCue::RenderTextTrackCue):

  • rendering/RenderView.cpp:

(WebCore::RenderView::RenderView):

  • rendering/RenderWidget.cpp:

(WebCore::RenderWidget::RenderWidget):

  • rendering/RenderWidget.h:

(RenderWidget):

  • rendering/mathml/RenderMathMLBlock.cpp:

(WebCore::RenderMathMLBlock::RenderMathMLBlock):
(WebCore::RenderMathMLBlock::createAnonymousMathMLBlock):

  • rendering/mathml/RenderMathMLBlock.h:

(RenderMathMLBlock):

  • rendering/mathml/RenderMathMLFenced.cpp:

(WebCore::RenderMathMLFenced::createMathMLOperator):

  • rendering/mathml/RenderMathMLOperator.cpp:

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

  • rendering/mathml/RenderMathMLOperator.h:

(RenderMathMLOperator):

  • rendering/mathml/RenderMathMLRow.cpp:

(WebCore::RenderMathMLRow::RenderMathMLRow):
(WebCore::RenderMathMLRow::createAnonymousWithParentRenderer):

  • rendering/mathml/RenderMathMLRow.h:

(RenderMathMLRow):

  • rendering/style/ContentData.cpp:

(WebCore::ImageContentData::createRenderer):

  • rendering/svg/RenderSVGBlock.cpp:

(WebCore::RenderSVGBlock::RenderSVGBlock):

  • rendering/svg/RenderSVGInline.cpp:

(WebCore::RenderSVGInline::RenderSVGInline):

  • rendering/svg/RenderSVGInline.h:

(RenderSVGInline):

  • rendering/svg/RenderSVGTSpan.cpp:

(WebCore::RenderSVGTSpan::RenderSVGTSpan):

  • rendering/svg/RenderSVGTSpan.h:

(RenderSVGTSpan):

  • rendering/svg/RenderSVGTextPath.cpp:

(WebCore::RenderSVGTextPath::RenderSVGTextPath):

  • rendering/svg/RenderSVGTextPath.h:

(RenderSVGTextPath):

Source/WebKit/chromium:

  • tests/RenderTableCellTest.cpp:
  • tests/RenderTableRowTest.cpp:
Location:
trunk/Source
Files:
101 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r140037 r140039  
     12013-01-17  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r140023.
     4        http://trac.webkit.org/changeset/140023
     5        https://bugs.webkit.org/show_bug.cgi?id=107176
     6
     7        Broke some tests (Requested by anttik on #webkit).
     8
     9        * page/FrameView.cpp:
     10        (WebCore::FrameView::updateScrollCorner):
     11        * rendering/RenderBlock.cpp:
     12        (WebCore::RenderBlock::createReplacementRunIn):
     13        (WebCore::RenderBlock::updateFirstLetterStyle):
     14        (WebCore::RenderBlock::createFirstLetterRenderer):
     15        (WebCore::RenderBlock::createAnonymousWithParentRendererAndDisplay):
     16        (WebCore::RenderBlock::createAnonymousColumnsWithParentRenderer):
     17        (WebCore::RenderBlock::createAnonymousColumnSpanWithParentRenderer):
     18        * rendering/RenderBlock.h:
     19        (RenderBlock):
     20        * rendering/RenderDeprecatedFlexibleBox.cpp:
     21        (WebCore::RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox):
     22        * rendering/RenderDeprecatedFlexibleBox.h:
     23        (RenderDeprecatedFlexibleBox):
     24        * rendering/RenderDetailsMarker.cpp:
     25        (WebCore::RenderDetailsMarker::RenderDetailsMarker):
     26        * rendering/RenderDetailsMarker.h:
     27        (RenderDetailsMarker):
     28        * rendering/RenderDialog.h:
     29        (WebCore::RenderDialog::RenderDialog):
     30        * rendering/RenderFieldset.cpp:
     31        (WebCore::RenderFieldset::RenderFieldset):
     32        * rendering/RenderFieldset.h:
     33        (RenderFieldset):
     34        * rendering/RenderFlexibleBox.cpp:
     35        (WebCore::RenderFlexibleBox::RenderFlexibleBox):
     36        * rendering/RenderFlexibleBox.h:
     37        (RenderFlexibleBox):
     38        * rendering/RenderFlowThread.cpp:
     39        (WebCore::RenderFlowThread::RenderFlowThread):
     40        * rendering/RenderFlowThread.h:
     41        * rendering/RenderFullScreen.cpp:
     42        (RenderFullScreenPlaceholder::RenderFullScreenPlaceholder):
     43        (RenderFullScreen::RenderFullScreen):
     44        (RenderFullScreen::wrapRenderer):
     45        * rendering/RenderFullScreen.h:
     46        (RenderFullScreen):
     47        * rendering/RenderGrid.cpp:
     48        (WebCore::RenderGrid::RenderGrid):
     49        * rendering/RenderGrid.h:
     50        (RenderGrid):
     51        * rendering/RenderImage.cpp:
     52        (WebCore::RenderImage::RenderImage):
     53        * rendering/RenderImage.h:
     54        (RenderImage):
     55        * rendering/RenderInline.cpp:
     56        (WebCore::RenderInline::RenderInline):
     57        (WebCore::RenderInline::addChildIgnoringContinuation):
     58        * rendering/RenderInline.h:
     59        (RenderInline):
     60        * rendering/RenderLayer.cpp:
     61        (WebCore::RenderLayer::updateScrollCornerStyle):
     62        (WebCore::RenderLayer::updateResizerStyle):
     63        (WebCore::RenderLayer::createReflection):
     64        * rendering/RenderListItem.cpp:
     65        (WebCore::RenderListItem::RenderListItem):
     66        (WebCore::RenderListItem::styleDidChange):
     67        * rendering/RenderListItem.h:
     68        (RenderListItem):
     69        * rendering/RenderListMarker.cpp:
     70        (WebCore::RenderListMarker::RenderListMarker):
     71        * rendering/RenderListMarker.h:
     72        (RenderListMarker):
     73        * rendering/RenderMediaControlElements.cpp:
     74        (WebCore::RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer):
     75        (WebCore::RenderMediaControlTimeDisplay::RenderMediaControlTimeDisplay):
     76        (WebCore::RenderTextTrackContainerElement::RenderTextTrackContainerElement):
     77        * rendering/RenderMediaControlElements.h:
     78        (RenderMediaVolumeSliderContainer):
     79        (RenderMediaControlTimeDisplay):
     80        (RenderTextTrackContainerElement):
     81        * rendering/RenderMultiColumnBlock.cpp:
     82        (WebCore::RenderMultiColumnBlock::RenderMultiColumnBlock):
     83        (WebCore::RenderMultiColumnBlock::ensureColumnSets):
     84        * rendering/RenderMultiColumnBlock.h:
     85        (RenderMultiColumnBlock):
     86        * rendering/RenderMultiColumnFlowThread.cpp:
     87        (WebCore::RenderMultiColumnFlowThread::RenderMultiColumnFlowThread):
     88        * rendering/RenderMultiColumnFlowThread.h:
     89        (RenderMultiColumnFlowThread):
     90        * rendering/RenderMultiColumnSet.cpp:
     91        (WebCore::RenderMultiColumnSet::RenderMultiColumnSet):
     92        * rendering/RenderMultiColumnSet.h:
     93        (RenderMultiColumnSet):
     94        * rendering/RenderNamedFlowThread.cpp:
     95        (WebCore::RenderNamedFlowThread::RenderNamedFlowThread):
     96        * rendering/RenderNamedFlowThread.h:
     97        (RenderNamedFlowThread):
     98        * rendering/RenderObject.cpp:
     99        (WebCore::RenderObject::RenderObject):
     100        * rendering/RenderObject.h:
     101        (WebCore::RenderObject::setIsAnonymous):
     102        (RenderObject):
     103        (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
     104        * rendering/RenderRegion.cpp:
     105        (WebCore::RenderRegion::RenderRegion):
     106        * rendering/RenderRegion.h:
     107        (RenderRegion):
     108        * rendering/RenderRegionSet.cpp:
     109        (WebCore::RenderRegionSet::RenderRegionSet):
     110        * rendering/RenderRegionSet.h:
     111        (RenderRegionSet):
     112        * rendering/RenderReplaced.cpp:
     113        (WebCore::RenderReplaced::RenderReplaced):
     114        * rendering/RenderReplaced.h:
     115        (RenderReplaced):
     116        * rendering/RenderReplica.cpp:
     117        (WebCore::RenderReplica::RenderReplica):
     118        * rendering/RenderReplica.h:
     119        (RenderReplica):
     120        * rendering/RenderRuby.cpp:
     121        (WebCore::createAnonymousRubyInlineBlock):
     122        (WebCore::RenderRubyAsInline::RenderRubyAsInline):
     123        (WebCore):
     124        (WebCore::RenderRubyAsBlock::RenderRubyAsBlock):
     125        * rendering/RenderRuby.h:
     126        (RenderRubyAsInline):
     127        (RenderRubyAsBlock):
     128        * rendering/RenderRubyBase.cpp:
     129        (WebCore::RenderRubyBase::RenderRubyBase):
     130        * rendering/RenderRubyBase.h:
     131        (RenderRubyBase):
     132        * rendering/RenderRubyRun.cpp:
     133        (WebCore::RenderRubyRun::RenderRubyRun):
     134        (WebCore::RenderRubyRun::createRubyBase):
     135        (WebCore::RenderRubyRun::staticCreateRubyRun):
     136        * rendering/RenderRubyRun.h:
     137        (RenderRubyRun):
     138        * rendering/RenderRubyText.cpp:
     139        (WebCore::RenderRubyText::RenderRubyText):
     140        * rendering/RenderRubyText.h:
     141        (RenderRubyText):
     142        * rendering/RenderScrollbar.cpp:
     143        (WebCore::RenderScrollbar::updateScrollbarPart):
     144        * rendering/RenderScrollbarPart.cpp:
     145        (WebCore::RenderScrollbarPart::RenderScrollbarPart):
     146        * rendering/RenderScrollbarPart.h:
     147        (RenderScrollbarPart):
     148        * rendering/RenderSearchField.cpp:
     149        (WebCore::RenderSearchField::RenderSearchField):
     150        * rendering/RenderSearchField.h:
     151        (RenderSearchField):
     152        * rendering/RenderTable.cpp:
     153        (WebCore::RenderTable::RenderTable):
     154        (WebCore::RenderTable::createAnonymousWithParentRenderer):
     155        * rendering/RenderTable.h:
     156        (RenderTable):
     157        * rendering/RenderTableCaption.cpp:
     158        (WebCore::RenderTableCaption::RenderTableCaption):
     159        * rendering/RenderTableCaption.h:
     160        (RenderTableCaption):
     161        * rendering/RenderTableCell.cpp:
     162        (WebCore::RenderTableCell::RenderTableCell):
     163        (WebCore::RenderTableCell::createAnonymousWithParentRenderer):
     164        * rendering/RenderTableCell.h:
     165        (RenderTableCell):
     166        * rendering/RenderTableCol.cpp:
     167        (WebCore::RenderTableCol::RenderTableCol):
     168        * rendering/RenderTableCol.h:
     169        (RenderTableCol):
     170        * rendering/RenderTableRow.cpp:
     171        (WebCore::RenderTableRow::RenderTableRow):
     172        (WebCore::RenderTableRow::createAnonymousWithParentRenderer):
     173        * rendering/RenderTableRow.h:
     174        (RenderTableRow):
     175        * rendering/RenderTableSection.cpp:
     176        (WebCore::RenderTableSection::RenderTableSection):
     177        (WebCore::RenderTableSection::createAnonymousWithParentRenderer):
     178        * rendering/RenderTableSection.h:
     179        (RenderTableSection):
     180        * rendering/RenderTextControl.cpp:
     181        (WebCore::RenderTextControl::RenderTextControl):
     182        * rendering/RenderTextControl.h:
     183        (RenderTextControl):
     184        * rendering/RenderTextControlMultiLine.cpp:
     185        (WebCore::RenderTextControlMultiLine::RenderTextControlMultiLine):
     186        * rendering/RenderTextControlMultiLine.h:
     187        (RenderTextControlMultiLine):
     188        * rendering/RenderTextControlSingleLine.cpp:
     189        (WebCore::RenderTextControlSingleLine::RenderTextControlSingleLine):
     190        * rendering/RenderTextControlSingleLine.h:
     191        (RenderTextControlSingleLine):
     192        (WebCore::RenderTextControlInnerBlock::RenderTextControlInnerBlock):
     193        * rendering/RenderTextTrackCue.cpp:
     194        (WebCore::RenderTextTrackCue::RenderTextTrackCue):
     195        * rendering/RenderView.cpp:
     196        (WebCore::RenderView::RenderView):
     197        * rendering/RenderWidget.cpp:
     198        (WebCore::RenderWidget::RenderWidget):
     199        * rendering/RenderWidget.h:
     200        (RenderWidget):
     201        * rendering/mathml/RenderMathMLBlock.cpp:
     202        (WebCore::RenderMathMLBlock::RenderMathMLBlock):
     203        (WebCore::RenderMathMLBlock::createAnonymousMathMLBlock):
     204        * rendering/mathml/RenderMathMLBlock.h:
     205        (RenderMathMLBlock):
     206        * rendering/mathml/RenderMathMLFenced.cpp:
     207        (WebCore::RenderMathMLFenced::createMathMLOperator):
     208        * rendering/mathml/RenderMathMLOperator.cpp:
     209        (WebCore::RenderMathMLOperator::RenderMathMLOperator):
     210        (WebCore::RenderMathMLOperator::updateFromElement):
     211        (WebCore::RenderMathMLOperator::createGlyph):
     212        * rendering/mathml/RenderMathMLOperator.h:
     213        (RenderMathMLOperator):
     214        * rendering/mathml/RenderMathMLRow.cpp:
     215        (WebCore::RenderMathMLRow::RenderMathMLRow):
     216        (WebCore::RenderMathMLRow::createAnonymousWithParentRenderer):
     217        * rendering/mathml/RenderMathMLRow.h:
     218        (RenderMathMLRow):
     219        * rendering/style/ContentData.cpp:
     220        (WebCore::ImageContentData::createRenderer):
     221        * rendering/svg/RenderSVGBlock.cpp:
     222        (WebCore::RenderSVGBlock::RenderSVGBlock):
     223        * rendering/svg/RenderSVGInline.cpp:
     224        (WebCore::RenderSVGInline::RenderSVGInline):
     225        * rendering/svg/RenderSVGInline.h:
     226        (RenderSVGInline):
     227        * rendering/svg/RenderSVGTSpan.cpp:
     228        (WebCore::RenderSVGTSpan::RenderSVGTSpan):
     229        * rendering/svg/RenderSVGTSpan.h:
     230        (RenderSVGTSpan):
     231        * rendering/svg/RenderSVGTextPath.cpp:
     232        (WebCore::RenderSVGTextPath::RenderSVGTextPath):
     233        * rendering/svg/RenderSVGTextPath.h:
     234        (RenderSVGTextPath):
     235
    12362013-01-17  Alexey Proskuryakov  <ap@apple.com>
    2237

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

    r140023 r140039  
    30163016    if (cornerStyle) {
    30173017        if (!m_scrollCorner)
    3018             m_scrollCorner = RenderScrollbarPart::createAnonymous(renderer->document());
     3018            m_scrollCorner = new (renderer->renderArena()) RenderScrollbarPart(renderer->document());
    30193019        m_scrollCorner->setStyle(cornerStyle.release());
    30203020        invalidateScrollCorner(cornerRect);

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

    r140024 r140039  
    239239}
    240240
    241 RenderBlock* RenderBlock::createAnonymous(Document* document)
    242 {
    243     RenderBlock* renderer = new (document->renderArena()) RenderBlock(0);
    244     renderer->setDocumentForAnonymous(document);
    245     return renderer;
    246 }
    247 
    248241void RenderBlock::willBeDestroyed()
    249242{
    … …  
    18551848        newRunIn = new (renderArena()) RenderBlock(runIn->node());
    18561849    else
    1857         newRunIn = new (renderArena()) RenderInline(toElement(runIn->node()));
     1850        newRunIn = new (renderArena()) RenderInline(runIn->node());
    18581851
    18591852    runIn->node()->setRenderer(newRunIn);
    … …  
    64376430        RenderObject* newFirstLetter;
    64386431        if (pseudoStyle->display() == INLINE)
    6439             newFirstLetter = RenderInline::createAnonymous(document());
     6432            newFirstLetter = new (renderArena()) RenderInline(document());
    64406433        else
    6441             newFirstLetter = RenderBlock::createAnonymous(document());
     6434            newFirstLetter = new (renderArena()) RenderBlock(document());
    64426435        newFirstLetter->setStyle(pseudoStyle);
    64436436
    … …  
    64836476    RenderObject* firstLetter = 0;
    64846477    if (pseudoStyle->display() == INLINE)
    6485         firstLetter = RenderInline::createAnonymous(document());
     6478        firstLetter = new (renderArena()) RenderInline(document());
    64866479    else
    6487         firstLetter = RenderBlock::createAnonymous(document());
     6480        firstLetter = new (renderArena()) RenderBlock(document());
    64886481    firstLetter->setStyle(pseudoStyle);
    64896482    firstLetterContainer->addChild(firstLetter, currentChild);
    … …  
    77327725    RenderBlock* newBox = 0;
    77337726    if (display == BOX || display == INLINE_BOX) {
    7734         newBox = RenderDeprecatedFlexibleBox::createAnonymous(parent->document());
     7727        newBox = new (parent->renderArena()) RenderDeprecatedFlexibleBox(parent->document() /* anonymous box */);
    77357728        newDisplay = BOX;
    77367729    } else {
    7737         newBox = RenderBlock::createAnonymous(parent->document());
     7730        newBox = new (parent->renderArena()) RenderBlock(parent->document() /* anonymous box */);
    77387731        newDisplay = BLOCK;
    77397732    }
    … …  
    77497742    newStyle->inheritColumnPropertiesFrom(parent->style());
    77507743
    7751     RenderBlock* newBox = RenderBlock::createAnonymous(parent->document());
     7744    RenderBlock* newBox = new (parent->renderArena()) RenderBlock(parent->document() /* anonymous box */);
    77527745    newBox->setStyle(newStyle.release());
    77537746    return newBox;
    … …  
    77597752    newStyle->setColumnSpan(ColumnSpanAll);
    77607753
    7761     RenderBlock* newBox = RenderBlock::createAnonymous(parent->document());
     7754    RenderBlock* newBox = new (parent->renderArena()) RenderBlock(parent->document() /* anonymous box */);
    77627755    newBox->setStyle(newStyle.release());
    77637756    return newBox;

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

    r140024 r140039  
    9292    virtual ~RenderBlock();
    9393
    94     static RenderBlock* createAnonymous(Document*);
    95 
    9694    RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }
    9795    RenderObject* lastChild() const { ASSERT(children() == virtualChildren()); return children()->lastChild(); }

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

    r140023 r140039  
    120120};
    121121
    122 RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox(Element* element)
    123     : RenderBlock(element)
     122RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox(ContainerNode* node)
     123    : RenderBlock(node)
    124124{
    125125    setChildrenInline(false); // All of our children must be block-level
    … …  
    129129RenderDeprecatedFlexibleBox::~RenderDeprecatedFlexibleBox()
    130130{
    131 }
    132 
    133 RenderDeprecatedFlexibleBox* RenderDeprecatedFlexibleBox::createAnonymous(Document* document)
    134 {
    135     RenderDeprecatedFlexibleBox* renderer = new (document->renderArena()) RenderDeprecatedFlexibleBox(0);
    136     renderer->setDocumentForAnonymous(document);
    137     return renderer;
    138131}
    139132

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

    r140023 r140039  
    3232class RenderDeprecatedFlexibleBox : public RenderBlock {
    3333public:
    34     RenderDeprecatedFlexibleBox(Element*);
     34    RenderDeprecatedFlexibleBox(ContainerNode*);
    3535    virtual ~RenderDeprecatedFlexibleBox();
    36 
    37     static RenderDeprecatedFlexibleBox* createAnonymous(Document*);
    3836
    3937    virtual const char* renderName() const;

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

    r140023 r140039  
    3232using namespace HTMLNames;
    3333
    34 RenderDetailsMarker::RenderDetailsMarker(Element* element)
    35     : RenderBlock(element)
     34RenderDetailsMarker::RenderDetailsMarker(ContainerNode* node)
     35    : RenderBlock(node)
    3636{
    3737}

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

    r140023 r140039  
    2929class RenderDetailsMarker : public RenderBlock {
    3030public:
    31     RenderDetailsMarker(Element*);
     31    RenderDetailsMarker(ContainerNode*);
    3232
    3333    enum Orientation { Up, Down, Left, Right };

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

    r140023 r140039  
    3737class RenderDialog : public RenderBlock {
    3838public:
    39     explicit RenderDialog(Element* element)
    40         : RenderBlock(element)
     39    explicit RenderDialog(ContainerNode* node)
     40        : RenderBlock(node)
    4141    { }
    4242

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

    r140023 r140039  
    3737using namespace HTMLNames;
    3838
    39 RenderFieldset::RenderFieldset(Element* element)
     39RenderFieldset::RenderFieldset(ContainerNode* element)
    4040    : RenderBlock(element)
    4141{

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

    r140023 r140039  
    3131class RenderFieldset : public RenderBlock {
    3232public:
    33     explicit RenderFieldset(Element*);
     33    explicit RenderFieldset(ContainerNode*);
    3434
    3535    enum FindLegendOption { IgnoreFloatingOrOutOfFlow, IncludeFloatingOrOutOfFlow };

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

    r140023 r140039  
    124124
    125125
    126 RenderFlexibleBox::RenderFlexibleBox(Element* element)
    127     : RenderBlock(element)
     126RenderFlexibleBox::RenderFlexibleBox(ContainerNode* node)
     127    : RenderBlock(node)
    128128    , m_orderIterator(this)
    129129    , m_numberOfInFlowChildrenOnFirstLine(-1)

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

    r140023 r140039  
    3838class RenderFlexibleBox : public RenderBlock {
    3939public:
    40     RenderFlexibleBox(Element*);
     40    RenderFlexibleBox(ContainerNode*);
    4141    virtual ~RenderFlexibleBox();
    4242

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

    r140023 r140039  
    4646namespace WebCore {
    4747
    48 // FIXME: RenderFlowThread should either be anonymous or be associated with some Element.
    49 // It should not be constructed as a renderer for the Document.
    50 RenderFlowThread::RenderFlowThread(Document* document)
    51     : RenderBlock(document)
     48RenderFlowThread::RenderFlowThread(ContainerNode* node)
     49    : RenderBlock(node)
    5250    , m_regionsInvalidated(false)
    5351    , m_regionsHaveUniformLogicalWidth(true)
    … …  
    5856    , m_pageLogicalHeightChanged(false)
    5957{
    60     ASSERT(document->cssRegionsEnabled());
     58    ASSERT(node->document()->cssRegionsEnabled());
     59    setIsAnonymous(false);
    6160    setInRenderFlowThread();
    6261}

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

    r140023 r140039  
    5454class RenderFlowThread: public RenderBlock {
    5555public:
    56     RenderFlowThread(Document*);
     56    RenderFlowThread(ContainerNode*);
    5757    virtual ~RenderFlowThread() { };
    5858   

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

    r140023 r140039  
    4040public:
    4141    RenderFullScreenPlaceholder(RenderFullScreen* owner)
    42         : RenderBlock(0)
     42        : RenderBlock(owner->document())
    4343        , m_owner(owner)
    44     {
    45         setDocumentForAnonymous(owner->document());
     44    {
    4645    }
    4746private:
    … …  
    5756}
    5857
    59 RenderFullScreen::RenderFullScreen()
    60     : RenderDeprecatedFlexibleBox(0)
     58RenderFullScreen::RenderFullScreen(Document* document)
     59    : RenderDeprecatedFlexibleBox(document)
    6160    , m_placeholder(0)
    62 {
     61{ 
    6362    setReplaced(false);
    64 }
    65 
    66 RenderFullScreen* RenderFullScreen::createAnonymous(Document* document)
    67 {
    68     RenderFullScreen* renderer = new (document->renderArena()) RenderFullScreen();
    69     renderer->setDocumentForAnonymous(document);
    70     return renderer;
    7163}
    7264
    … …  
    116108RenderObject* RenderFullScreen::wrapRenderer(RenderObject* object, RenderObject* parent, Document* document)
    117109{
    118     RenderFullScreen* fullscreenRenderer = RenderFullScreen::createAnonymous(document);
     110    RenderFullScreen* fullscreenRenderer = new (document->renderArena()) RenderFullScreen(document);
    119111    fullscreenRenderer->setStyle(createFullScreenStyle());
    120112    if (parent && !parent->isChildAllowed(fullscreenRenderer, fullscreenRenderer->style())) {

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

    r140023 r140039  
    3535class RenderFullScreen : public RenderDeprecatedFlexibleBox {
    3636public:
    37     static RenderFullScreen* createAnonymous(Document*);
    38 
     37    RenderFullScreen(Document*);
    3938    virtual bool isRenderFullScreen() const { return true; }
    4039    virtual const char* renderName() const { return "RenderFullScreen"; }
    … …  
    4948
    5049private:
    51     RenderFullScreen();
    5250    virtual void willBeDestroyed();
    53 
     51   
    5452protected:
    5553    RenderBlock* m_placeholder;

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

    r140023 r140039  
    4646};
    4747
    48 RenderGrid::RenderGrid(Element* element)
    49     : RenderBlock(element)
     48RenderGrid::RenderGrid(ContainerNode* node)
     49    : RenderBlock(node)
    5050{
    5151    // All of our children must be block level.

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

    r140023 r140039  
    3535class RenderGrid : public RenderBlock {
    3636public:
    37     RenderGrid(Element*);
     37    RenderGrid(ContainerNode*);
    3838    virtual ~RenderGrid();
    3939

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

    r140023 r140039  
    5353using namespace HTMLNames;
    5454
    55 RenderImage::RenderImage(Element* element)
    56     : RenderReplaced(element, IntSize())
     55RenderImage::RenderImage(ContainerNode* node)
     56    : RenderReplaced(node, IntSize())
    5757    , m_needsToSetSizeForAltText(false)
    5858    , m_didIncrementVisuallyNonEmptyPixelCount(false)
    … …  
    6060{
    6161    updateAltText();
    62 }
    63 
    64 RenderImage* RenderImage::createAnonymous(Document* document)
    65 {
    66     RenderImage* image = new (document->renderArena()) RenderImage(0);
    67     image->setDocumentForAnonymous(document);
    68     return image;
    6962}
    7063

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

    r140023 r140039  
    3737class RenderImage : public RenderReplaced {
    3838public:
    39     RenderImage(Element*);
     39    RenderImage(ContainerNode*);
    4040    virtual ~RenderImage();
    41 
    42     static RenderImage* createAnonymous(Document*);
    4341
    4442    void setImageResource(PassOwnPtr<RenderImageResource>);

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

    r140023 r140039  
    5050namespace WebCore {
    5151
    52 RenderInline::RenderInline(Element* element)
    53     : RenderBoxModelObject(element)
     52RenderInline::RenderInline(ContainerNode* node)
     53    : RenderBoxModelObject(node)
    5454    , m_alwaysCreateLineBoxes(false)
    5555{
    5656    setChildrenInline(true);
    57 }
    58 
    59 RenderInline* RenderInline::createAnonymous(Document* document)
    60 {
    61     RenderInline* renderer = new (document->renderArena()) RenderInline(0);
    62     renderer->setDocumentForAnonymous(document);
    63     return renderer;
    6457}
    6558
    … …  
    318311            newStyle->setPosition(positionedAncestor->style()->position());
    319312
    320         RenderBlock* newBox = RenderBlock::createAnonymous(document());
     313        RenderBlock* newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
    321314        newBox->setStyle(newStyle.release());
    322315        RenderBoxModelObject* oldContinuation = continuation();

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

    r140023 r140039  
    3434class RenderInline : public RenderBoxModelObject {
    3535public:
    36     explicit RenderInline(Element*);
    37 
    38     static RenderInline* createAnonymous(Document*);
     36    explicit RenderInline(ContainerNode*);
    3937
    4038    RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }
    … …  
    4240
    4341    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
    44 
    45     Element* node() const { return toElement(RenderBoxModelObject::node()); }
    4642
    4743    virtual LayoutUnit marginLeft() const;

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

    r140023 r140039  
    55585558    if (corner) {
    55595559        if (!m_scrollCorner) {
    5560             m_scrollCorner = RenderScrollbarPart::createAnonymous(renderer()->document());
     5560            m_scrollCorner = new (renderer()->renderArena()) RenderScrollbarPart(renderer()->document());
    55615561            m_scrollCorner->setParent(renderer());
    55625562        }
    … …  
    55745574    if (resizer) {
    55755575        if (!m_resizer) {
    5576             m_resizer = RenderScrollbarPart::createAnonymous(renderer()->document());
     5576            m_resizer = new (renderer()->renderArena()) RenderScrollbarPart(renderer()->document());
    55775577            m_resizer->setParent(renderer());
    55785578        }
    … …  
    55925592{
    55935593    ASSERT(!m_reflection);
    5594     m_reflection = RenderReplica::createAnonymous(renderer()->document());
     5594    m_reflection = new (renderer()->renderArena()) RenderReplica(renderer()->document());
    55955595    m_reflection->setParent(renderer()); // We create a 1-way connection.
    55965596}

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

    r140023 r140039  
    4040using namespace HTMLNames;
    4141
    42 RenderListItem::RenderListItem(Element* element)
    43     : RenderBlock(element)
     42RenderListItem::RenderListItem(ContainerNode* node)
     43    : RenderBlock(node)
    4444    , m_marker(0)
    4545    , m_hasExplicitValue(false)
    … …  
    6161        newStyle->inheritFrom(style());
    6262        if (!m_marker)
    63             m_marker = RenderListMarker::createAnonymous(this);
     63            m_marker = new (renderArena()) RenderListMarker(this);
    6464        m_marker->setStyle(newStyle.release());
    6565    } else if (m_marker) {

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

    r140023 r140039  
    3232class RenderListItem : public RenderBlock {
    3333public:
    34     explicit RenderListItem(Element*);
     34    explicit RenderListItem(ContainerNode*);
    3535
    3636    int value() const { if (!m_isValueUpToDate) updateValueNow(); return m_value; }

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

    r140023 r140039  
    10561056
    10571057RenderListMarker::RenderListMarker(RenderListItem* item)
    1058     : RenderBox(0)
     1058    : RenderBox(item->document())
    10591059    , m_listItem(item)
    10601060{
    … …  
    10681068    if (m_image)
    10691069        m_image->removeClient(this);
    1070 }
    1071 
    1072 RenderListMarker* RenderListMarker::createAnonymous(RenderListItem* item)
    1073 {
    1074     Document* document = item->document();
    1075     RenderListMarker* renderer = new (document->renderArena()) RenderListMarker(item);
    1076     renderer->setDocumentForAnonymous(document);
    1077     return renderer;
    10781070}
    10791071

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

    r140023 r140039  
    3636class RenderListMarker : public RenderBox {
    3737public:
    38     static RenderListMarker* createAnonymous(RenderListItem*);
    39 
     38    RenderListMarker(RenderListItem*);
    4039    virtual ~RenderListMarker();
    4140
    … …  
    5049
    5150private:
    52     RenderListMarker(RenderListItem*);
    53 
    5451    virtual const char* renderName() const { return "RenderListMarker"; }
    5552    virtual void computePreferredLogicalWidths() OVERRIDE;

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

    r140023 r140039  
    3636namespace WebCore {
    3737
    38 RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer(Element* element)
    39     : RenderBlock(element)
     38RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer(ContainerNode* node)
     39    : RenderBlock(node)
    4040{
    4141}
    … …  
    6060// ----------------------------
    6161
    62 RenderMediaControlTimeDisplay::RenderMediaControlTimeDisplay(Element* element)
    63     : RenderDeprecatedFlexibleBox(element)
     62RenderMediaControlTimeDisplay::RenderMediaControlTimeDisplay(ContainerNode* node)
     63    : RenderDeprecatedFlexibleBox(node)
    6464{
    6565}
    … …  
    8484#if ENABLE(VIDEO_TRACK)
    8585
    86 RenderTextTrackContainerElement::RenderTextTrackContainerElement(Element* element)
    87     : RenderBlock(element)
     86RenderTextTrackContainerElement::RenderTextTrackContainerElement(ContainerNode* node)
     87    : RenderBlock(node)
    8888{
    8989}

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

    r140023 r140039  
    3939class RenderMediaVolumeSliderContainer : public RenderBlock {
    4040public:
    41     RenderMediaVolumeSliderContainer(Element*);
     41    RenderMediaVolumeSliderContainer(ContainerNode*);
    4242
    4343private:
    … …  
    4949class RenderMediaControlTimeDisplay : public RenderDeprecatedFlexibleBox {
    5050public:
    51     RenderMediaControlTimeDisplay(Element*);
     51    RenderMediaControlTimeDisplay(ContainerNode*);
    5252
    5353private:
    … …  
    6161class RenderTextTrackContainerElement : public RenderBlock {
    6262public:
    63     RenderTextTrackContainerElement(Element*);
     63    RenderTextTrackContainerElement(ContainerNode*);
    6464
    6565private:

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

    r140023 r140039  
    3434namespace WebCore {
    3535
    36 RenderMultiColumnBlock::RenderMultiColumnBlock(Element* element)
    37     : RenderBlock(element)
     36RenderMultiColumnBlock::RenderMultiColumnBlock(ContainerNode* node)
     37    : RenderBlock(node)
    3838    , m_flowThread(0)
    3939    , m_columnCount(1)
    … …  
    145145    RenderMultiColumnSet* columnSet = firstChild()->isRenderMultiColumnSet() ? toRenderMultiColumnSet(firstChild()) : 0;
    146146    if (!columnSet) {
    147         columnSet = RenderMultiColumnSet::createAnonymous(flowThread());
     147        columnSet = new (renderArena()) RenderMultiColumnSet(document(), flowThread());
    148148        columnSet->setStyle(RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
    149149        RenderBlock::addChild(columnSet, firstChild());

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

    r140023 r140039  
    3636class RenderMultiColumnBlock : public RenderBlock {
    3737public:
    38     RenderMultiColumnBlock(Element*);
    39 
     38    RenderMultiColumnBlock(ContainerNode*);
     39   
    4040    LayoutUnit columnHeight() const { return m_columnHeight; }
    4141    void setColumnHeight(LayoutUnit columnHeight) { m_columnHeight = columnHeight; }

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

    r140023 r140039  
    2929namespace WebCore {
    3030
    31 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document* document)
    32     : RenderFlowThread(document)
     31RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(ContainerNode* node)
     32    : RenderFlowThread(node)
    3333{
    3434}

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

    r140023 r140039  
    3434class RenderMultiColumnFlowThread : public RenderFlowThread {
    3535public:
    36     RenderMultiColumnFlowThread(Document*);
     36    RenderMultiColumnFlowThread(ContainerNode*);
    3737    ~RenderMultiColumnFlowThread();
    3838

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

    r140023 r140039  
    3737namespace WebCore {
    3838
    39 RenderMultiColumnSet::RenderMultiColumnSet(RenderFlowThread* flowThread)
    40     : RenderRegionSet(0, flowThread)
     39RenderMultiColumnSet::RenderMultiColumnSet(ContainerNode* node, RenderFlowThread* flowThread)
     40    : RenderRegionSet(node, flowThread)
    4141    , m_computedColumnCount(1)
    4242    , m_computedColumnWidth(0)
    … …  
    4848    , m_forcedBreakOffset(0)
    4949{
    50 }
    51 
    52 RenderMultiColumnSet* RenderMultiColumnSet::createAnonymous(RenderFlowThread* flowThread)
    53 {
    54     Document* document = flowThread->document();
    55     RenderMultiColumnSet* renderer = new (document->renderArena()) RenderMultiColumnSet(flowThread);
    56     renderer->setDocumentForAnonymous(document);
    57     return renderer;
    5850}
    5951

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

    r140023 r140039  
    4444class RenderMultiColumnSet : public RenderRegionSet {
    4545public:
    46     static RenderMultiColumnSet* createAnonymous(RenderFlowThread*);
    47 
     46    RenderMultiColumnSet(ContainerNode*, RenderFlowThread*);
     47   
    4848    virtual bool isRenderMultiColumnSet() const OVERRIDE { return true; }
    4949
    … …  
    8989
    9090private:
    91     RenderMultiColumnSet(RenderFlowThread*);
    92 
    9391    virtual void updateLogicalWidth() OVERRIDE;
    9492    virtual void updateLogicalHeight() OVERRIDE;

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

    r140023 r140039  
    4141namespace WebCore {
    4242
    43 RenderNamedFlowThread::RenderNamedFlowThread(Document* document, PassRefPtr<WebKitNamedFlow> namedFlow)
    44     : RenderFlowThread(document)
     43RenderNamedFlowThread::RenderNamedFlowThread(ContainerNode* node, PassRefPtr<WebKitNamedFlow> namedFlow)
     44    : RenderFlowThread(node)
    4545    , m_namedFlow(namedFlow)
    4646    , m_regionLayoutUpdateEventTimer(this, &RenderNamedFlowThread::regionLayoutUpdateEventTimerFired)

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

    r140023 r140039  
    4646class RenderNamedFlowThread : public RenderFlowThread {
    4747public:
    48     RenderNamedFlowThread(Document*, PassRefPtr<WebKitNamedFlow>);
     48    RenderNamedFlowThread(ContainerNode*, PassRefPtr<WebKitNamedFlow>);
    4949    virtual ~RenderNamedFlowThread();
    5050

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

    r140024 r140039  
    233233    renderObjectCounter.increment();
    234234#endif
     235    ASSERT(node);
    235236}
    236237

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

    r140024 r140039  
    499499
    500500    bool isAnonymous() const { return m_bitfields.isAnonymous(); }
     501    void setIsAnonymous(bool b) { m_bitfields.setIsAnonymous(b); }
    501502    bool isAnonymousBlock() const
    502503    {
    … …  
    987988    virtual void insertedIntoTree();
    988989    virtual void willBeRemovedFromTree();
    989 
    990     void setDocumentForAnonymous(Document* document) { ASSERT(isAnonymous()); m_node = document; }
    991990
    992991private:
    … …  
    10421041            , m_floating(false)
    10431042            , m_paintBackground(false)
    1044             , m_isAnonymous(!node)
     1043            , m_isAnonymous(node == node->document())
    10451044            , m_isText(false)
    10461045            , m_isBox(false)

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

    r140023 r140039  
    4444namespace WebCore {
    4545
    46 RenderRegion::RenderRegion(Element* element, RenderFlowThread* flowThread)
    47     : RenderReplaced(element, IntSize())
     46RenderRegion::RenderRegion(ContainerNode* node, RenderFlowThread* flowThread)
     47    : RenderReplaced(node, IntSize())
    4848    , m_flowThread(flowThread)
    4949    , m_parentNamedFlowThread(0)

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

    r140023 r140039  
    4343class RenderRegion : public RenderReplaced {
    4444public:
    45     explicit RenderRegion(Element*, RenderFlowThread*);
     45    explicit RenderRegion(ContainerNode*, RenderFlowThread*);
    4646
    4747    virtual bool isRenderRegion() const { return true; }

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

    r140023 r140039  
    3131namespace WebCore {
    3232
    33 RenderRegionSet::RenderRegionSet(Element* element, RenderFlowThread* flowThread)
    34     : RenderRegion(element, flowThread)
     33RenderRegionSet::RenderRegionSet(ContainerNode* node, RenderFlowThread* flowThread)
     34    : RenderRegion(node, flowThread)
    3535{
    3636}

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

    r140023 r140039  
    4848class RenderRegionSet : public RenderRegion {
    4949public:
    50     RenderRegionSet(Element*, RenderFlowThread*);
     50    RenderRegionSet(ContainerNode*, RenderFlowThread*);
    5151   
    5252private:

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

    r140023 r140039  
    4343const int cDefaultHeight = 150;
    4444
    45 RenderReplaced::RenderReplaced(Element* element)
    46     : RenderBox(element)
     45RenderReplaced::RenderReplaced(ContainerNode* node)
     46    : RenderBox(node)
    4747    , m_intrinsicSize(cDefaultWidth, cDefaultHeight)
    4848{
    … …  
    5050}
    5151
    52 RenderReplaced::RenderReplaced(Element* element, const LayoutSize& intrinsicSize)
    53     : RenderBox(element)
     52RenderReplaced::RenderReplaced(ContainerNode* node, const LayoutSize& intrinsicSize)
     53    : RenderBox(node)
    5454    , m_intrinsicSize(intrinsicSize)
    5555{

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

    r140023 r140039  
    2929class RenderReplaced : public RenderBox {
    3030public:
    31     RenderReplaced(Element*);
    32     RenderReplaced(Element*, const LayoutSize& intrinsicSize);
     31    RenderReplaced(ContainerNode*);
     32    RenderReplaced(ContainerNode*, const LayoutSize& intrinsicSize);
    3333    virtual ~RenderReplaced();
    3434

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

    r140023 r140039  
    3434namespace WebCore {
    3535
    36 RenderReplica::RenderReplica()
    37     : RenderBox(0)
     36RenderReplica::RenderReplica(ContainerNode* node)
     37    : RenderBox(node)
    3838{
    3939    // This is a hack. Replicas are synthetic, and don't pick up the attributes of the
    … …  
    4242    // the if (!isInline() || isReplaced()) check before setHasTransform().
    4343    setReplaced(true);
    44 }
    45 
    46 RenderReplica* RenderReplica::createAnonymous(Document* document)
    47 {
    48     RenderReplica* renderer = new (document->renderArena()) RenderReplica();
    49     renderer->setDocumentForAnonymous(document);
    50     return renderer;
    5144}
    5245

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

    r140023 r140039  
    3636class RenderReplica : public RenderBox {
    3737public:
    38     static RenderReplica* createAnonymous(Document*);
    39 
     38    RenderReplica(ContainerNode*);
    4039    virtual ~RenderReplica();
    4140
    … …  
    4948
    5049private:
    51     RenderReplica();
    52 
    5350    virtual bool isReplica() const { return true; }
    5451    virtual void computePreferredLogicalWidths();

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

    r140023 r140039  
    8787{
    8888    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(ruby->style(), INLINE_BLOCK);
    89     RenderBlock* newBlock = RenderBlock::createAnonymous(ruby->document());
     89    RenderBlock* newBlock = new (ruby->renderArena()) RenderBlock(ruby->document() /* anonymous box */);
    9090    newBlock->setStyle(newStyle.release());
    9191    return newBlock;
    … …  
    110110//=== ruby as inline object ===
    111111
    112 RenderRubyAsInline::RenderRubyAsInline(Element* element)
    113     : RenderInline(element)
     112RenderRubyAsInline::RenderRubyAsInline(ContainerNode* node)
     113    : RenderInline(node)
    114114{
    115115}
    … …  
    214214}
    215215
     216
    216217//=== ruby as block object ===
    217218
    218 RenderRubyAsBlock::RenderRubyAsBlock(Element* element)
    219     : RenderBlock(element)
     219RenderRubyAsBlock::RenderRubyAsBlock(ContainerNode* node)
     220    : RenderBlock(node)
    220221{
    221222}

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

    r140023 r140039  
    5454class RenderRubyAsInline : public RenderInline {
    5555public:
    56     RenderRubyAsInline(Element*);
     56    RenderRubyAsInline(ContainerNode*);
    5757    virtual ~RenderRubyAsInline();
    5858
    … …  
    7373class RenderRubyAsBlock : public RenderBlock {
    7474public:
    75     RenderRubyAsBlock(Element*);
     75    RenderRubyAsBlock(ContainerNode*);
    7676    virtual ~RenderRubyAsBlock();
    7777

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

    r140023 r140039  
    3939namespace WebCore {
    4040
    41 RenderRubyBase::RenderRubyBase()
    42     : RenderBlock(0)
     41RenderRubyBase::RenderRubyBase(ContainerNode* node)
     42    : RenderBlock(node)
    4343{
    4444    setInline(false);
    … …  
    4747RenderRubyBase::~RenderRubyBase()
    4848{
    49 }
    50 
    51 RenderRubyBase* RenderRubyBase::createAnonymous(Document* document)
    52 {
    53     RenderRubyBase* renderer = new (document->renderArena()) RenderRubyBase();
    54     renderer->setDocumentForAnonymous(document);
    55     return renderer;
    5649}
    5750

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

    r140023 r140039  
    4040class RenderRubyBase : public RenderBlock {
    4141public:
     42    RenderRubyBase(ContainerNode*);
    4243    virtual ~RenderRubyBase();
    43    
    44     static RenderRubyBase* createAnonymous(Document*);
    4544
    4645    virtual const char* renderName() const { return "RenderRubyBase (anonymous)"; }
    … …  
    5150
    5251private:
    53     RenderRubyBase();
    54 
    5552    virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
    5653    virtual void adjustInlineDirectionLineBounds(int expansionOpportunityCount, float& logicalLeft, float& logicalWidth) const;

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

    r140023 r140039  
    4343namespace WebCore {
    4444
    45 RenderRubyRun::RenderRubyRun()
    46     : RenderBlock(0)
     45RenderRubyRun::RenderRubyRun(ContainerNode* node)
     46    : RenderBlock(node)
    4747{
    4848    setReplaced(true);
    … …  
    200200RenderRubyBase* RenderRubyRun::createRubyBase() const
    201201{
    202     RenderRubyBase* renderer = RenderRubyBase::createAnonymous(document());
     202    RenderRubyBase* rb = new (renderArena()) RenderRubyBase(document() /* anonymous */);
    203203    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
    204204    newStyle->setTextAlign(CENTER); // FIXME: use WEBKIT_CENTER?
    205     renderer->setStyle(newStyle.release());
    206     return renderer;
     205    rb->setStyle(newStyle.release());
     206    return rb;
    207207}
    208208
    … …  
    210210{
    211211    ASSERT(parentRuby && parentRuby->isRuby());
    212     RenderRubyRun* rr = new (parentRuby->renderArena()) RenderRubyRun();
    213     rr->setDocumentForAnonymous(parentRuby->document());
     212    RenderRubyRun* rr = new (parentRuby->renderArena()) RenderRubyRun(parentRuby->document() /* anonymous */);
    214213    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parentRuby->style(), INLINE_BLOCK);
    215214    rr->setStyle(newStyle.release());

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

    r140023 r140039  
    4444class RenderRubyRun : public RenderBlock {
    4545public:
     46    RenderRubyRun(ContainerNode*);
    4647    virtual ~RenderRubyRun();
    4748
    … …  
    7172
    7273private:
    73     RenderRubyRun();
    74 
    7574    virtual bool isRubyRun() const { return true; }
    7675    virtual const char* renderName() const { return "RenderRubyRun (anonymous)"; }

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

    r140023 r140039  
    3838namespace WebCore {
    3939
    40 RenderRubyText::RenderRubyText(Element* element)
    41     : RenderBlock(element)
     40RenderRubyText::RenderRubyText(ContainerNode* node)
     41    : RenderBlock(node)
    4242{
    4343}

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

    r140023 r140039  
    3838class RenderRubyText : public RenderBlock {
    3939public:
    40     RenderRubyText(Element*);
     40    RenderRubyText(ContainerNode*);
    4141    virtual ~RenderRubyText();
    4242

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

    r140023 r140039  
    271271    RenderScrollbarPart* partRenderer = m_parts.get(partType);
    272272    if (!partRenderer && needRenderer) {
    273         partRenderer = RenderScrollbarPart::createAnonymous(owningRenderer()->document(), this, partType);
     273        partRenderer = new (owningRenderer()->renderArena()) RenderScrollbarPart(owningRenderer()->document(), this, partType);
    274274        m_parts.set(partType, partRenderer);
    275275    } else if (partRenderer && !needRenderer) {

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

    r140023 r140039  
    3636namespace WebCore {
    3737
    38 RenderScrollbarPart::RenderScrollbarPart(RenderScrollbar* scrollbar, ScrollbarPart part)
    39     : RenderBlock(0)
     38RenderScrollbarPart::RenderScrollbarPart(ContainerNode* node, RenderScrollbar* scrollbar, ScrollbarPart part)
     39    : RenderBlock(node)
    4040    , m_scrollbar(scrollbar)
    4141    , m_part(part)
    … …  
    4545RenderScrollbarPart::~RenderScrollbarPart()
    4646{
    47 }
    48 
    49 RenderScrollbarPart* RenderScrollbarPart::createAnonymous(Document* document, RenderScrollbar* scrollbar, ScrollbarPart part)
    50 {
    51     RenderScrollbarPart* renderer = new (document->renderArena()) RenderScrollbarPart(scrollbar, part);
    52     renderer->setDocumentForAnonymous(document);
    53     return renderer;
    5447}
    5548

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

    r140023 r140039  
    3636class RenderScrollbarPart : public RenderBlock {
    3737public:
    38     static RenderScrollbarPart* createAnonymous(Document*, RenderScrollbar* = 0, ScrollbarPart = NoPart);
    39    
     38    RenderScrollbarPart(ContainerNode*, RenderScrollbar* = 0, ScrollbarPart = NoPart);
    4039    virtual ~RenderScrollbarPart();
    4140
    … …  
    6362
    6463private:
    65     RenderScrollbarPart(RenderScrollbar*, ScrollbarPart);
    66 
    6764    virtual void computePreferredLogicalWidths();
    6865

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

    r140023 r140039  
    5454// ----------------------------
    5555
    56 RenderSearchField::RenderSearchField(Element* element)
    57     : RenderTextControlSingleLine(element)
     56RenderSearchField::RenderSearchField(ContainerNode* node)
     57    : RenderTextControlSingleLine(node)
    5858    , m_searchPopupIsVisible(false)
    5959    , m_searchPopup(0)
    6060{
    61     ASSERT(element->isHTMLElement());
    62     ASSERT(element->toInputElement());
    63     ASSERT(element->toInputElement()->isSearchField());
     61    ASSERT(node->isHTMLElement());
     62    ASSERT(node->toInputElement());
     63    ASSERT(node->toInputElement()->isSearchField());
    6464}
    6565

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

    r140023 r140039  
    3434class RenderSearchField : public RenderTextControlSingleLine, private PopupMenuClient {
    3535public:
    36     RenderSearchField(Element*);
     36    RenderSearchField(ContainerNode*);
    3737    virtual ~RenderSearchField();
    3838

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

    r140023 r140039  
    5050using namespace HTMLNames;
    5151
    52 RenderTable::RenderTable(Element* element)
    53     : RenderBlock(element)
     52RenderTable::RenderTable(ContainerNode* node)
     53    : RenderBlock(node)
    5454    , m_head(0)
    5555    , m_foot(0)
    … …  
    13631363{
    13641364    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE);
    1365     RenderTable* newTable = new (parent->renderArena()) RenderTable(0);
    1366     newTable->setDocumentForAnonymous(parent->document());
     1365    RenderTable* newTable = new (parent->renderArena()) RenderTable(parent->document() /* is anonymous */);
    13671366    newTable->setStyle(newStyle.release());
    13681367    return newTable;

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

    r140023 r140039  
    4343class RenderTable : public RenderBlock {
    4444public:
    45     explicit RenderTable(Element*);
     45    explicit RenderTable(ContainerNode*);
    4646    virtual ~RenderTable();
    4747

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

    r140023 r140039  
    2525namespace WebCore {
    2626
    27 RenderTableCaption::RenderTableCaption(Element* element)
    28     : RenderBlock(element)
     27RenderTableCaption::RenderTableCaption(ContainerNode* node)
     28    : RenderBlock(node)
    2929{
    3030}

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

    r140023 r140039  
    2929class RenderTableCaption : public RenderBlock {
    3030public:
    31     explicit RenderTableCaption(Element*);
     31    explicit RenderTableCaption(ContainerNode*);
    3232    virtual ~RenderTableCaption();
    3333    virtual LayoutUnit containingBlockLogicalWidthForContent() const OVERRIDE;

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

    r140023 r140039  
    5656COMPILE_ASSERT(sizeof(CollapsedBorderValue) == 8, CollapsedBorderValue_should_stay_small);
    5757
    58 RenderTableCell::RenderTableCell(Element* element)
    59     : RenderBlock(element)
     58RenderTableCell::RenderTableCell(ContainerNode* node)
     59    : RenderBlock(node)
    6060    , m_column(unsetColumnIndex)
    6161    , m_cellWidthChanged(false)
    … …  
    12471247}
    12481248
    1249 RenderTableCell* RenderTableCell::createAnonymous(Document* document)
    1250 {
    1251     RenderTableCell* renderer = new (document->renderArena()) RenderTableCell(0);
    1252     renderer->setDocumentForAnonymous(document);
    1253     return renderer;
    1254 }
    1255 
    12561249RenderTableCell* RenderTableCell::createAnonymousWithParentRenderer(const RenderObject* parent)
    12571250{
    1258     RenderTableCell* newCell = RenderTableCell::createAnonymous(parent->document());
    12591251    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_CELL);
     1252    RenderTableCell* newCell = new (parent->renderArena()) RenderTableCell(parent->document() /* is anonymous */);
    12601253    newCell->setStyle(newStyle.release());
    12611254    return newCell;

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

    r140023 r140039  
    3838class RenderTableCell : public RenderBlock {
    3939public:
    40     explicit RenderTableCell(Element*);
    41 
     40    explicit RenderTableCell(ContainerNode*);
     41   
    4242    unsigned colSpan() const
    4343    {
    … …  
    152152    void setCellWidthChanged(bool b = true) { m_cellWidthChanged = b; }
    153153
    154     static RenderTableCell* createAnonymous(Document*);
    155154    static RenderTableCell* createAnonymousWithParentRenderer(const RenderObject*);
    156155    virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE

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

    r140023 r140039  
    3838using namespace HTMLNames;
    3939
    40 RenderTableCol::RenderTableCol(Element* element)
    41     : RenderBox(element)
     40RenderTableCol::RenderTableCol(ContainerNode* node)
     41    : RenderBox(node)
    4242    , m_span(1)
    4343{

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

    r140023 r140039  
    3636class RenderTableCol : public RenderBox {
    3737public:
    38     explicit RenderTableCol(Element*);
     38    explicit RenderTableCol(ContainerNode*);
    3939
    4040    RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }

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

    r140023 r140039  
    4040using namespace HTMLNames;
    4141
    42 RenderTableRow::RenderTableRow(Element* element)
    43     : RenderBox(element)
     42RenderTableRow::RenderTableRow(ContainerNode* node)
     43    : RenderBox(node)
    4444    , m_rowIndex(unsetRowIndex)
    4545{
    … …  
    247247}
    248248
    249 RenderTableRow* RenderTableRow::createAnonymous(Document* document)
    250 {
    251     RenderTableRow* renderer = new (document->renderArena()) RenderTableRow(0);
    252     renderer->setDocumentForAnonymous(document);
    253     return renderer;
    254 }
    255 
    256249RenderTableRow* RenderTableRow::createAnonymousWithParentRenderer(const RenderObject* parent)
    257250{
    258     RenderTableRow* newRow = RenderTableRow::createAnonymous(parent->document());
    259251    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_ROW);
     252    RenderTableRow* newRow = new (parent->renderArena()) RenderTableRow(parent->document() /* is anonymous */);
    260253    newRow->setStyle(newStyle.release());
    261254    return newRow;

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

    r140023 r140039  
    3535class RenderTableRow : public RenderBox {
    3636public:
    37     explicit RenderTableRow(Element*);
     37    explicit RenderTableRow(ContainerNode*);
    3838
    3939    RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }
    … …  
    4848    void paintOutlineForRowIfNeeded(PaintInfo&, const LayoutPoint&);
    4949
    50     static RenderTableRow* createAnonymous(Document*);
    5150    static RenderTableRow* createAnonymousWithParentRenderer(const RenderObject*);
    5251    virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE

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

    r140023 r140039  
    9090
    9191
    92 RenderTableSection::RenderTableSection(Element* element)
    93     : RenderBox(element)
     92RenderTableSection::RenderTableSection(ContainerNode* node)
     93    : RenderBox(node)
    9494    , m_cCol(0)
    9595    , m_cRow(0)
    … …  
    14161416{
    14171417    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_ROW_GROUP);
    1418     RenderTableSection* newSection = new (parent->renderArena()) RenderTableSection(0);
    1419     newSection->setDocumentForAnonymous(parent->document());
     1418    RenderTableSection* newSection = new (parent->renderArena()) RenderTableSection(parent->document() /* is anonymous */);
    14201419    newSection->setStyle(newStyle.release());
    14211420    return newSection;

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

    r140023 r140039  
    6363class RenderTableSection : public RenderBox {
    6464public:
    65     RenderTableSection(Element*);
     65    RenderTableSection(ContainerNode*);
    6666    virtual ~RenderTableSection();
    6767

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

    r140023 r140039  
    3737namespace WebCore {
    3838
    39 RenderTextControl::RenderTextControl(Element* element)
    40     : RenderBlock(element)
    41 {
    42     ASSERT(toTextFormControl(element));
     39RenderTextControl::RenderTextControl(ContainerNode* node)
     40    : RenderBlock(node)
     41{
     42    ASSERT(toTextFormControl(node));
    4343}
    4444

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

    r140023 r140039  
    3939
    4040protected:
    41     RenderTextControl(Element*);
     41    RenderTextControl(ContainerNode*);
    4242
    4343    // This convenience function should not be made public because innerTextElement may outlive the render tree.

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

    r140023 r140039  
    3333namespace WebCore {
    3434
    35 RenderTextControlMultiLine::RenderTextControlMultiLine(Element* element)
    36     : RenderTextControl(element)
     35RenderTextControlMultiLine::RenderTextControlMultiLine(ContainerNode* node)
     36    : RenderTextControl(node)
    3737{
    3838}

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

    r140023 r140039  
    2929class RenderTextControlMultiLine : public RenderTextControl {
    3030public:
    31     RenderTextControlMultiLine(Element*);
     31    RenderTextControlMultiLine(ContainerNode*);
    3232    virtual ~RenderTextControlMultiLine();
    3333

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

    r140023 r140039  
    5050using namespace HTMLNames;
    5151
    52 RenderTextControlSingleLine::RenderTextControlSingleLine(Element* element)
    53     : RenderTextControl(element)
     52RenderTextControlSingleLine::RenderTextControlSingleLine(ContainerNode* node)
     53    : RenderTextControl(node)
    5454    , m_shouldDrawCapsLockIndicator(false)
    5555    , m_desiredInnerTextHeight(-1)
    5656{
    57     ASSERT(element->isHTMLElement());
    58     ASSERT(element->toInputElement());
     57    ASSERT(node->isHTMLElement());
     58    ASSERT(node->toInputElement());
    5959}
    6060

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

    r140023 r140039  
    3333class RenderTextControlSingleLine : public RenderTextControl {
    3434public:
    35     RenderTextControlSingleLine(Element*);
     35    RenderTextControlSingleLine(ContainerNode*);
    3636    virtual ~RenderTextControlSingleLine();
    3737    // FIXME: Move create*Style() to their classes.
    … …  
    111111class RenderTextControlInnerBlock : public RenderBlock {
    112112public:
    113     RenderTextControlInnerBlock(Element* element) : RenderBlock(element) { }
     113    RenderTextControlInnerBlock(ContainerNode* node) : RenderBlock(node) { }
    114114
    115115private:

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

    r140023 r140039  
    3434namespace WebCore {
    3535
    36 RenderTextTrackCue::RenderTextTrackCue(TextTrackCueBox* element)
    37     : RenderBlock(element)
    38     , m_cue(element->getCue())
     36RenderTextTrackCue::RenderTextTrackCue(TextTrackCueBox* node)
     37    : RenderBlock(node)
     38    , m_cue(node->getCue())
    3939{
    4040}

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

    r140023 r140039  
    7070    , m_layoutPhase(RenderViewNormalLayout)
    7171{
     72    // Clear our anonymous bit, set because RenderObject assumes
     73    // any renderer with document as the node is anonymous.
     74    setIsAnonymous(false);
     75
    7276    // init RenderObject attributes
    7377    setInline(false);

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

    r140023 r140039  
    8686}
    8787
    88 RenderWidget::RenderWidget(Element* element)
    89     : RenderReplaced(element)
     88RenderWidget::RenderWidget(ContainerNode* node)
     89    : RenderReplaced(node)
    9090    , m_widget(0)
    91     , m_frameView(element->document()->view())
     91    , m_frameView(node->document()->view())
    9292    // Reference counting is used to prevent the widget from being
    9393    // destroyed while inside the Widget code, which might not be

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

    r140023 r140039  
    7474
    7575protected:
    76     RenderWidget(Element*);
     76    RenderWidget(ContainerNode*);
    7777
    7878    FrameView* frameView() const { return m_frameView; }

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

    r140032 r140039  
    4343using namespace MathMLNames;
    4444   
    45 RenderMathMLBlock::RenderMathMLBlock(Element* container)
     45RenderMathMLBlock::RenderMathMLBlock(ContainerNode* container)
    4646    : RenderFlexibleBox(container)
    4747    , m_ignoreInAccessibilityTree(false)
    … …  
    6565{
    6666    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), display);
    67     RenderMathMLBlock* newBlock = new (renderArena()) RenderMathMLBlock(0);
    68     newBlock->setDocumentForAnonymous(document());
     67    RenderMathMLBlock* newBlock = new (renderArena()) RenderMathMLBlock(document() /* is anonymous */);
    6968    newBlock->setStyle(newStyle.release());
    7069    return newBlock;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h

    r140032 r140039  
    4242class RenderMathMLBlock : public RenderFlexibleBox {
    4343public:
    44     RenderMathMLBlock(Element* container);
    45 
     44    RenderMathMLBlock(ContainerNode*);
    4645    virtual bool isChildAllowed(RenderObject*, RenderStyle*) const;
    4746   

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

    r140023 r140039  
    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(node() /* "almost anonymous" */, uChar);
    9393    newOperator->setOperatorType(operatorType);
    9494    newOperator->setStyle(newStyle.release());

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

    r140023 r140039  
    4848}
    4949
    50 RenderMathMLOperator::RenderMathMLOperator(Element* element, UChar operatorChar)
    51     : RenderMathMLBlock(element)
     50RenderMathMLOperator::RenderMathMLOperator(ContainerNode* node, UChar operatorChar)
     51    : RenderMathMLBlock(node)
    5252    , m_stretchHeight(0)
    5353    , m_operator(convertHyphenMinusToMinusSign(operatorChar))
    … …  
    147147   
    148148    // We may need the element later if we can't stretch.
    149     if (node()->isElementNode()) {
     149    if (node()->nodeType() == Node::ELEMENT_NODE) {
    150150        if (Element* mo = static_cast<Element*>(node())) {
    151151            AtomicString stretchyAttr = mo->getAttribute(MathMLNames::stretchyAttr);
    … …  
    203203    if (stretchDisabled || !shouldStack) {
    204204        m_isStacked = false;
    205         RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
     205        RenderBlock* container = new (renderArena()) RenderMathMLBlock(node());
    206206        // This container doesn't offer any useful information to accessibility.
    207207        toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
    … …  
    228228        if (m_operator)
    229229            text = new (renderArena()) RenderText(node(), StringImpl::create(&m_operator, 1));
    230         else if (node()->isElementNode())
     230        else if (node()->nodeType() == Node::ELEMENT_NODE)
    231231            if (Element* mo = static_cast<Element*>(node()))
    232232                text = new (renderArena()) RenderText(node(), mo->textContent().replace(hyphenMinus, minusSign).impl());
    … …  
    297297RenderBlock* RenderMathMLOperator::createGlyph(UChar glyph, int maxHeightForRenderer, int charRelative)
    298298{
    299     RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
     299    RenderBlock* container = new (renderArena()) RenderMathMLBlock(node());
    300300    toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
    301301    container->setStyle(createStackableStyle(maxHeightForRenderer));

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

    r140023 r140039  
    3737public:
    3838    RenderMathMLOperator(Element*);
    39     RenderMathMLOperator(Element*, UChar operatorChar);
    40 
     39    RenderMathMLOperator(ContainerNode*, UChar operatorChar);
    4140    virtual bool isRenderMathMLOperator() const { return true; }
    4241   

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

    r140023 r140039  
    3737using namespace MathMLNames;
    3838
    39 RenderMathMLRow::RenderMathMLRow(Element* element)
    40     : RenderMathMLBlock(element)
     39RenderMathMLRow::RenderMathMLRow(ContainerNode* node)
     40    : RenderMathMLBlock(node)
    4141{
    4242}
    … …  
    4646{
    4747    RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), FLEX);
    48     RenderMathMLRow* newMRow = new (parent->renderArena()) RenderMathMLRow(0);
    49     newMRow->setDocumentForAnonymous(parent->document());
     48    RenderMathMLRow* newMRow = new (parent->renderArena()) RenderMathMLRow(parent->document() /* is anonymous */);
    5049    newMRow->setStyle(newStyle.release());
    5150    return newMRow;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRow.h

    r140023 r140039  
    3535class RenderMathMLRow : public RenderMathMLBlock {
    3636public:
    37     RenderMathMLRow(Element*);
    38 
     37    RenderMathMLRow(ContainerNode*);
    3938    static RenderMathMLRow* createAnonymousWithParentRenderer(const RenderObject*);
    4039   

  • trunk/Source/WebCore/rendering/style/ContentData.cpp

    r140023 r140039  
    7070RenderObject* ImageContentData::createRenderer(Document* doc, RenderStyle* pseudoStyle) const
    7171{
    72     RenderImage* image = RenderImage::createAnonymous(doc);
     72    RenderImage* image = new (doc->renderArena()) RenderImage(doc);
    7373    image->setPseudoStyle(pseudoStyle);
    7474    if (m_image)

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

    r140023 r140039  
    3232namespace WebCore {
    3333
    34 RenderSVGBlock::RenderSVGBlock(SVGElement* element)
    35     : RenderBlock(element)
     34RenderSVGBlock::RenderSVGBlock(SVGElement* node)
     35    : RenderBlock(node)
    3636{
    3737}

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

    r140023 r140039  
    3333namespace WebCore {
    3434   
    35 RenderSVGInline::RenderSVGInline(Element* element)
    36     : RenderInline(element)
     35RenderSVGInline::RenderSVGInline(ContainerNode* node)
     36    : RenderInline(node)
    3737{
    3838    setAlwaysCreateLineBoxes();

  • trunk/Source/WebCore/rendering/svg/RenderSVGInline.h

    r140023 r140039  
    3131class RenderSVGInline : public RenderInline {
    3232public:
    33     explicit RenderSVGInline(Element*);
     33    explicit RenderSVGInline(ContainerNode*);
    3434
    3535    virtual const char* renderName() const { return "RenderSVGInline"; }

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

    r140023 r140039  
    2828namespace WebCore {
    2929
    30 RenderSVGTSpan::RenderSVGTSpan(Element* element)
    31     : RenderSVGInline(element)
     30RenderSVGTSpan::RenderSVGTSpan(ContainerNode* node)
     31    : RenderSVGInline(node)
    3232{
    3333}

  • trunk/Source/WebCore/rendering/svg/RenderSVGTSpan.h

    r140023 r140039  
    2929class RenderSVGTSpan : public RenderSVGInline {
    3030public:
    31     explicit RenderSVGTSpan(Element*);
     31    explicit RenderSVGTSpan(ContainerNode*);
    3232    virtual const char* renderName() const { return "RenderSVGTSpan"; }
    3333};

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

    r140023 r140039  
    3535namespace WebCore {
    3636
    37 RenderSVGTextPath::RenderSVGTextPath(Element* element)
    38     : RenderSVGInline(element)
     37RenderSVGTextPath::RenderSVGTextPath(ContainerNode* node)
     38    : RenderSVGInline(node)
    3939{
    4040}

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

    r140023 r140039  
    2929class RenderSVGTextPath : public RenderSVGInline {
    3030public:
    31     RenderSVGTextPath(Element*);
     31    RenderSVGTextPath(ContainerNode*);
    3232
    3333    Path layoutPath() const;

  • trunk/Source/WebKit/chromium/ChangeLog

    r140035 r140039  
     12013-01-17  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r140023.
     4        http://trac.webkit.org/changeset/140023
     5        https://bugs.webkit.org/show_bug.cgi?id=107176
     6
     7        Broke some tests (Requested by anttik on #webkit).
     8
     9        * tests/RenderTableCellTest.cpp:
     10        * tests/RenderTableRowTest.cpp:
     11
    1122013-01-17  John Mellor  <johnme@chromium.org>
    213

  • trunk/Source/WebKit/chromium/tests/RenderTableCellTest.cpp

    r140023 r140039  
    7373    virtual void SetUp()
    7474    {
    75         m_cell = RenderTableCell::createAnonymous(document());
     75        m_cell = new (arena()) RenderTableCell(document());
    7676    }
    7777

  • trunk/Source/WebKit/chromium/tests/RenderTableRowTest.cpp

    r140023 r140039  
    7373    virtual void SetUp()
    7474    {
    75         m_row = RenderTableRow::createAnonymous(document());
     75        m_row = new (arena()) RenderTableRow(document());
    7676    }
    7777
Note: See TracChangeset for help on using the changeset viewer.