+2013-05-12 Andreas Kling <akling@apple.com>
+
+ Apply FINAL to the RenderObject hierarchy.
+ <http://webkit.org/b/115977>
+
+ Mostly from Blink r148795 by <cevans@chromium.org>
+ <http://src.chromium.org/viewvc/blink?view=revision&revision=148795>
+
+ * rendering/: Beat things with the FINAL stick.
+ * WebCore.exp.in: Export a now-needed symbol.
+
2013-05-12 Carlos Garcia Campos <cgarcia@igalia.com>
[GTK] Remove unnecessary GTK_CHECK_VERSION #ifdefs
__ZN7WebCore10MouseEventC1ERKN3WTF12AtomicStringEbbNS1_10PassRefPtrINS_9DOMWindowEEEiiiiibbbbtNS5_INS_11EventTargetEEENS5_INS_9ClipboardEEEb
__ZN7WebCore10Pasteboard14writePlainTextERKN3WTF6StringENS0_18SmartReplaceOptionE
__ZN7WebCore10Pasteboard17generalPasteboardEv
+__ZN7WebCore10RenderPart9setWidgetEN3WTF10PassRefPtrINS_6WidgetEEE
__ZN7WebCore10RenderView10compositorEv
__ZN7WebCore10RenderView7hitTestERKNS_14HitTestRequestERNS_13HitTestResultE
__ZN7WebCore10ScrollView17setUseFixedLayoutEb
InlineBox* firstChild() const { checkConsistency(); return m_firstChild; }
InlineBox* lastChild() const { checkConsistency(); return m_lastChild; }
- virtual bool isLeaf() const FINAL { return false; }
+ virtual bool isLeaf() const OVERRIDE FINAL { return false; }
InlineBox* firstLeafChild() const;
InlineBox* lastLeafChild() const;
typedef void (*CustomInlineBoxRangeReverse)(void* userData, Vector<InlineBox*>::iterator first, Vector<InlineBox*>::iterator last);
void collectLeafBoxesInLogicalOrder(Vector<InlineBox*>&, CustomInlineBoxRangeReverse customReverseImplementation = 0, void* userData = 0) const;
- virtual void setConstructed() FINAL
+ virtual void setConstructed() OVERRIDE FINAL
{
InlineBox::setConstructed();
for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
}
void addToLine(InlineBox* child);
- virtual void deleteLine(RenderArena*) FINAL;
- virtual void extractLine() FINAL;
- virtual void attachLine() FINAL;
+ virtual void deleteLine(RenderArena*) OVERRIDE FINAL;
+ virtual void extractLine() OVERRIDE FINAL;
+ virtual void attachLine() OVERRIDE FINAL;
virtual void adjustPosition(float dx, float dy);
virtual void extractLineBoxFromRenderObject();
IntRect roundedFrameRect() const;
- virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&) FINAL;
- virtual void paintMask(PaintInfo&, const LayoutPoint&) FINAL;
+ void paintBoxDecorations(PaintInfo&, const LayoutPoint&);
+ void paintMask(PaintInfo&, const LayoutPoint&);
void paintFillLayers(const PaintInfo&, const Color&, const FillLayer*, const LayoutRect&, CompositeOperator = CompositeSourceOver);
void paintFillLayer(const PaintInfo&, const Color&, const FillLayer*, const LayoutRect&, CompositeOperator = CompositeSourceOver);
void paintBoxShadow(const PaintInfo&, RenderStyle*, ShadowStyle, const LayoutRect&);
protected:
OwnPtr<RenderOverflow> m_overflow;
- virtual bool isInlineFlowBox() const FINAL { return true; }
+ virtual bool isInlineFlowBox() const OVERRIDE FINAL { return true; }
InlineBox* m_firstChild;
InlineBox* m_lastChild;
{
}
- virtual void destroy(RenderArena*) FINAL;
+ virtual void destroy(RenderArena*) OVERRIDE FINAL;
InlineTextBox* prevTextBox() const { return m_prevTextBox; }
InlineTextBox* nextTextBox() const { return m_nextTextBox; }
static inline bool compareByStart(const InlineTextBox* first, const InlineTextBox* second) { return first->start() < second->start(); }
- virtual int baselinePosition(FontBaseline) const FINAL;
- virtual LayoutUnit lineHeight() const FINAL;
+ virtual int baselinePosition(FontBaseline) const OVERRIDE FINAL;
+ virtual LayoutUnit lineHeight() const OVERRIDE FINAL;
bool getEmphasisMarkPosition(RenderStyle*, TextEmphasisPosition&) const;
RenderText* textRenderer() const;
private:
- virtual void deleteLine(RenderArena*) FINAL;
- virtual void extractLine() FINAL;
- virtual void attachLine() FINAL;
+ virtual void deleteLine(RenderArena*) OVERRIDE FINAL;
+ virtual void extractLine() OVERRIDE FINAL;
+ virtual void attachLine() OVERRIDE FINAL;
public:
- virtual RenderObject::SelectionState selectionState() FINAL;
+ virtual RenderObject::SelectionState selectionState() OVERRIDE FINAL;
private:
- virtual void clearTruncation() FINAL { m_truncation = cNoTruncation; }
+ virtual void clearTruncation() OVERRIDE FINAL { m_truncation = cNoTruncation; }
virtual float placeEllipsisBox(bool flowIsLTR, float visibleLeftEdge, float visibleRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox) OVERRIDE FINAL;
public:
- virtual bool isLineBreak() const FINAL;
+ virtual bool isLineBreak() const OVERRIDE FINAL;
void setExpansion(int newExpansion)
{
}
private:
- virtual bool isInlineTextBox() const FINAL { return true; }
+ virtual bool isInlineTextBox() const OVERRIDE FINAL { return true; }
public:
- virtual int caretMinOffset() const FINAL;
- virtual int caretMaxOffset() const FINAL;
+ virtual int caretMinOffset() const OVERRIDE FINAL;
+ virtual int caretMaxOffset() const OVERRIDE FINAL;
private:
float textPos() const; // returns the x position relative to the left start of the text line.
class HTMLAppletElement;
-class RenderApplet : public RenderEmbeddedObject {
+class RenderApplet FINAL : public RenderEmbeddedObject {
public:
explicit RenderApplet(HTMLAppletElement*);
virtual ~RenderApplet();
class Position;
-class RenderBR : public RenderText {
+class RenderBR FINAL : public RenderText {
public:
explicit RenderBR(Node*);
virtual ~RenderBR();
bool beingDestroyed() const { return m_beingDestroyed; }
// These two functions are overridden for inline-block.
- virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;
+ virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;
RenderLineBoxList* lineBoxes() { return &m_lineBoxes; }
void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
void markSiblingsWithFloatsForLayout(RenderBox* floatToRemove = 0);
void markPositionedObjectsForLayout();
- virtual void markForPaginationRelayoutIfNeeded();
+ virtual void markForPaginationRelayoutIfNeeded() OVERRIDE FINAL;
bool containsFloats() const { return m_floatingObjects && !m_floatingObjects->set().isEmpty(); }
bool containsFloat(RenderBox*) const;
virtual VisiblePosition positionForPoint(const LayoutPoint&);
// Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
- virtual LayoutUnit availableLogicalWidth() const;
+ virtual LayoutUnit availableLogicalWidth() const OVERRIDE FINAL;
LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
void clearTruncation();
void adjustRectForColumns(LayoutRect&) const;
- virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const;
+ virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const OVERRIDE FINAL;
void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
void addContinuationWithOutline(RenderInline*);
bool paintsContinuationOutline(RenderInline*);
- virtual RenderBoxModelObject* virtualContinuation() const { return continuation(); }
+ virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
bool isAnonymousBlockContinuation() const { return continuation() && isAnonymousBlock(); }
RenderInline* inlineElementContinuation() const;
RenderBlock* blockElementContinuation() const;
void computeExclusionShapeSize();
void updateExclusionShapeInsideInfoAfterStyleChange(const ExclusionShapeValue*, const ExclusionShapeValue* oldExclusionShape);
#endif
- virtual RenderObjectChildList* virtualChildren() { return children(); }
- virtual const RenderObjectChildList* virtualChildren() const { return children(); }
+ virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
+ virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
virtual const char* renderName() const;
- virtual bool isRenderBlock() const { return true; }
- virtual bool isBlockFlow() const { return (!isInline() || isReplaced()) && !isTable(); }
- virtual bool isInlineBlockOrInlineTable() const { return isInline() && isReplaced(); }
+ virtual bool isRenderBlock() const OVERRIDE FINAL { return true; }
+ virtual bool isBlockFlow() const OVERRIDE FINAL { return (!isInline() || isReplaced()) && !isTable(); }
+ virtual bool isInlineBlockOrInlineTable() const OVERRIDE FINAL { return isInline() && isReplaced(); }
void makeChildrenNonInline(RenderObject* insertionPoint = 0);
virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
static void collapseAnonymousBoxChild(RenderBlock* parent, RenderObject* child);
- virtual void dirtyLinesFromChangedChild(RenderObject* child) { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
+ virtual void dirtyLinesFromChangedChild(RenderObject* child) OVERRIDE FINAL { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild);
void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
- virtual void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
+ void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
- virtual bool isSelfCollapsingBlock() const;
+ virtual bool isSelfCollapsingBlock() const OVERRIDE FINAL;
- virtual LayoutUnit collapsedMarginBefore() const { return maxPositiveMarginBefore() - maxNegativeMarginBefore(); }
- virtual LayoutUnit collapsedMarginAfter() const { return maxPositiveMarginAfter() - maxNegativeMarginAfter(); }
+ virtual LayoutUnit collapsedMarginBefore() const OVERRIDE FINAL { return maxPositiveMarginBefore() - maxNegativeMarginBefore(); }
+ virtual LayoutUnit collapsedMarginAfter() const OVERRIDE FINAL { return maxPositiveMarginAfter() - maxNegativeMarginAfter(); }
- virtual void repaintOverhangingFloats(bool paintAllDescendants) OVERRIDE;
+ virtual void repaintOverhangingFloats(bool paintAllDescendants) OVERRIDE FINAL;
void layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom);
void layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);
LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type = FloatingObject::FloatLeftRight) const;
LayoutUnit nextFloatLogicalBottomBelow(LayoutUnit) const;
- virtual bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
+ bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset);
// Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
// children.
- virtual RenderBlock* firstLineBlock() const;
+ virtual RenderBlock* firstLineBlock() const OVERRIDE;
- virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE;
- virtual RenderStyle* outlineStyleForRepaint() const;
+ virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
+ virtual RenderStyle* outlineStyleForRepaint() const OVERRIDE FINAL;
- virtual RenderObject* hoverAncestor() const;
- virtual void updateDragState(bool dragOn);
- virtual void childBecameNonInline(RenderObject* child);
+ virtual RenderObject* hoverAncestor() const OVERRIDE FINAL;
+ virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
+ virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
- virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE
+ virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE FINAL
{
return selectionGapRectsForRepaint(repaintContainer);
}
- virtual bool shouldPaintSelectionGaps() const;
+ virtual bool shouldPaintSelectionGaps() const OVERRIDE FINAL;
bool isSelectionRoot() const;
GapRects selectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
- virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0);
+ virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) OVERRIDE FINAL;
void adjustPointToColumnContents(LayoutPoint&) const;
// position:static elements that are not flex-items get their z-index coerced to auto.
virtual bool requiresLayer() const OVERRIDE { return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasOverflowClip() || hasTransform() || hasHiddenBackface() || hasReflection() || style()->specifiesColumns() || !style()->hasAutoZIndex() || isFloatingWithShapeOutside(); }
- virtual bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const OVERRIDE;
+ virtual bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const OVERRIDE FINAL;
// Use this with caution! No type checking is done!
RenderBox* firstChildBox() const;
LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), size()); }
LayoutRect paddingBoxRect() const { return LayoutRect(borderLeft(), borderTop(), contentWidth() + paddingLeft() + paddingRight(), contentHeight() + paddingTop() + paddingBottom()); }
IntRect pixelSnappedBorderBoxRect() const { return IntRect(IntPoint(), m_frameRect.pixelSnappedSize()); }
- virtual IntRect borderBoundingBox() const { return pixelSnappedBorderBoxRect(); }
+ virtual IntRect borderBoundingBox() const OVERRIDE FINAL { return pixelSnappedBorderBoxRect(); }
// The content area of the box (excludes padding - and intrinsic padding for table cells, etc... - and border).
LayoutRect contentBoxRect() const { return LayoutRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(), contentWidth(), contentHeight()); }
LayoutRect computedCSSContentBoxRect() const { return LayoutRect(borderLeft() + computedCSSPaddingLeft(), borderTop() + computedCSSPaddingTop(), clientWidth() - computedCSSPaddingLeft() - computedCSSPaddingRight(), clientHeight() - computedCSSPaddingTop() - computedCSSPaddingBottom()); }
// Bounds of the outline box in absolute coords. Respects transforms
- virtual LayoutRect outlineBoundsForRepaint(const RenderLayerModelObject* /*repaintContainer*/, const RenderGeometryMap*) const OVERRIDE;
+ virtual LayoutRect outlineBoundsForRepaint(const RenderLayerModelObject* /*repaintContainer*/, const RenderGeometryMap*) const OVERRIDE FINAL;
virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
// Use this with caution! No type checking is done!
virtual LayoutUnit offsetWidth() const { return width(); }
virtual LayoutUnit offsetHeight() const { return height(); }
- virtual int pixelSnappedOffsetWidth() const OVERRIDE;
- virtual int pixelSnappedOffsetHeight() const OVERRIDE;
+ virtual int pixelSnappedOffsetWidth() const OVERRIDE FINAL;
+ virtual int pixelSnappedOffsetHeight() const OVERRIDE FINAL;
// More IE extensions. clientWidth and clientHeight represent the interior of an object
// excluding border and scrollbar. clientLeft/Top are just the borderLeftWidth and borderTopWidth.
void setMarginLeft(LayoutUnit margin) { m_marginBox.setLeft(margin); }
void setMarginRight(LayoutUnit margin) { m_marginBox.setRight(margin); }
- virtual LayoutUnit marginLogicalLeft() const { return m_marginBox.logicalLeft(style()->writingMode()); }
- virtual LayoutUnit marginLogicalRight() const { return m_marginBox.logicalRight(style()->writingMode()); }
+ LayoutUnit marginLogicalLeft() const { return m_marginBox.logicalLeft(style()->writingMode()); }
+ LayoutUnit marginLogicalRight() const { return m_marginBox.logicalRight(style()->writingMode()); }
- virtual LayoutUnit marginBefore(const RenderStyle* overrideStyle = 0) const OVERRIDE { return m_marginBox.before((overrideStyle ? overrideStyle : style())->writingMode()); }
- virtual LayoutUnit marginAfter(const RenderStyle* overrideStyle = 0) const OVERRIDE { return m_marginBox.after((overrideStyle ? overrideStyle : style())->writingMode()); }
- virtual LayoutUnit marginStart(const RenderStyle* overrideStyle = 0) const OVERRIDE
+ virtual LayoutUnit marginBefore(const RenderStyle* overrideStyle = 0) const OVERRIDE FINAL { return m_marginBox.before((overrideStyle ? overrideStyle : style())->writingMode()); }
+ virtual LayoutUnit marginAfter(const RenderStyle* overrideStyle = 0) const OVERRIDE FINAL { return m_marginBox.after((overrideStyle ? overrideStyle : style())->writingMode()); }
+ virtual LayoutUnit marginStart(const RenderStyle* overrideStyle = 0) const OVERRIDE FINAL
{
const RenderStyle* styleToUse = overrideStyle ? overrideStyle : style();
return m_marginBox.start(styleToUse->writingMode(), styleToUse->direction());
}
- virtual LayoutUnit marginEnd(const RenderStyle* overrideStyle = 0) const OVERRIDE
+ virtual LayoutUnit marginEnd(const RenderStyle* overrideStyle = 0) const OVERRIDE FINAL
{
const RenderStyle* styleToUse = overrideStyle ? overrideStyle : style();
return m_marginBox.end(styleToUse->writingMode(), styleToUse->direction());
virtual bool hasRelativeDimensions() const;
virtual bool hasRelativeLogicalHeight() const;
- virtual bool hasViewportPercentageLogicalHeight() const;
+ bool hasViewportPercentageLogicalHeight() const;
bool hasHorizontalLayoutOverflow() const
{
// These include tables, positioned objects, floats and flexible boxes.
virtual void computePreferredLogicalWidths() { setPreferredLogicalWidthsDirty(false); }
- virtual LayoutRect frameRectForStickyPositioning() const OVERRIDE { return frameRect(); }
+ virtual LayoutRect frameRectForStickyPositioning() const OVERRIDE FINAL { return frameRect(); }
private:
// The width/height of the contents + borders + padding. The x/y location is relative to our container (which is not always our parent).
private:
LayoutUnit computedCSSPadding(Length) const;
- virtual bool isBoxModelObject() const { return true; }
+ virtual bool isBoxModelObject() const OVERRIDE FINAL { return true; }
virtual LayoutRect frameRectForStickyPositioning() const = 0;
// RenderButtons are just like normal flexboxes except that they will generate an anonymous block child.
// For inputs, they will also generate an anonymous RenderText and keep its style and content up
// to date as the button changes.
-class RenderButton : public RenderFlexibleBox {
+class RenderButton FINAL : public RenderFlexibleBox {
public:
explicit RenderButton(Element*);
virtual ~RenderButton();
namespace WebCore {
-class RenderCombineText : public RenderText {
+class RenderCombineText FINAL : public RenderText {
public:
RenderCombineText(Node*, PassRefPtr<StringImpl>);
class CounterNode;
-class RenderCounter : public RenderText {
+class RenderCounter FINAL : public RenderText {
public:
RenderCounter(Document*, const CounterContent&);
virtual ~RenderCounter();
class FlexBoxIterator;
-class RenderDeprecatedFlexibleBox : public RenderBlock {
+class RenderDeprecatedFlexibleBox FINAL : public RenderBlock {
public:
RenderDeprecatedFlexibleBox(Element*);
virtual ~RenderDeprecatedFlexibleBox();
namespace WebCore {
-class RenderDetailsMarker : public RenderBlock {
+class RenderDetailsMarker FINAL : public RenderBlock {
public:
RenderDetailsMarker(Element*);
void handleUnavailablePluginIndicatorEvent(Event*);
#if USE(ACCELERATED_COMPOSITING)
- virtual bool allowsAcceleratedCompositing() const;
+ bool allowsAcceleratedCompositing() const;
#endif
protected:
- virtual void paintReplaced(PaintInfo&, const LayoutPoint&);
- virtual void paint(PaintInfo&, const LayoutPoint&);
+ virtual void paintReplaced(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
- virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const;
+ virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const OVERRIDE;
const RenderObjectChildList* children() const { return &m_children; }
RenderObjectChildList* children() { return &m_children; }
private:
virtual const char* renderName() const { return "RenderEmbeddedObject"; }
- virtual bool isEmbeddedObject() const { return true; }
+ virtual bool isEmbeddedObject() const OVERRIDE FINAL { return true; }
void paintSnapshotImage(PaintInfo&, const LayoutPoint&, Image*);
- virtual void paintContents(PaintInfo&, const LayoutPoint&) OVERRIDE;
+ virtual void paintContents(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
#if USE(ACCELERATED_COMPOSITING)
- virtual bool requiresLayer() const;
+ virtual bool requiresLayer() const OVERRIDE FINAL;
#endif
- virtual void viewCleared();
+ virtual void viewCleared() OVERRIDE FINAL;
- virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
+ virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE FINAL;
- virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier, Node** stopNode);
- virtual bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier, Node** stopNode);
+ virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier, Node** stopNode) OVERRIDE FINAL;
+ virtual bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier, Node** stopNode) OVERRIDE FINAL;
void setUnavailablePluginIndicatorIsPressed(bool);
bool isInUnavailablePluginIndicator(MouseEvent*) const;
bool isInUnavailablePluginIndicator(const LayoutPoint&) const;
bool getReplacementTextGeometry(const LayoutPoint& accumulatedOffset, FloatRect& contentRect, Path&, FloatRect& replacementTextRect, Font&, TextRun&, float& textWidth) const;
- virtual bool canHaveChildren() const;
- virtual RenderObjectChildList* virtualChildren() { return children(); }
- virtual const RenderObjectChildList* virtualChildren() const { return children(); }
+ virtual bool canHaveChildren() const OVERRIDE FINAL;
+ virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
+ virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
virtual bool canHaveWidget() const { return true; }
namespace WebCore {
-class RenderFieldset : public RenderBlock {
+class RenderFieldset FINAL : public RenderBlock {
public:
explicit RenderFieldset(Element*);
// sufficient space to draw a file icon and filename. The RenderButton has a shadow node
// associated with it to receive click/hover events.
-class RenderFileUploadControl : public RenderBlock {
+class RenderFileUploadControl FINAL : public RenderBlock {
public:
RenderFileUploadControl(HTMLInputElement*);
virtual ~RenderFileUploadControl();
virtual const char* renderName() const OVERRIDE;
- virtual bool isFlexibleBox() const OVERRIDE { return true; }
- virtual bool avoidsFloats() const OVERRIDE { return true; }
- virtual bool canCollapseAnonymousBlockChild() const OVERRIDE { return false; }
- virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0) OVERRIDE;
+ virtual bool isFlexibleBox() const OVERRIDE FINAL { return true; }
+ virtual bool avoidsFloats() const OVERRIDE FINAL { return true; }
+ virtual bool canCollapseAnonymousBlockChild() const OVERRIDE FINAL { return false; }
+ virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0) OVERRIDE FINAL;
virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
virtual int firstLineBoxBaseline() const OVERRIDE;
virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
- virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect) OVERRIDE;
+ virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect) OVERRIDE FINAL;
bool isHorizontalFlow() const;
RenderFlowThread();
virtual ~RenderFlowThread() { };
- virtual bool isRenderFlowThread() const { return true; }
+ virtual bool isRenderFlowThread() const OVERRIDE FINAL { return true; }
- virtual void layout();
+ virtual void layout() OVERRIDE FINAL;
// Always create a RenderLayer for the RenderFlowThread so that we
// can easily avoid drawing the children directly.
- virtual bool requiresLayer() const { return true; }
+ virtual bool requiresLayer() const OVERRIDE FINAL { return true; }
void removeFlowChildInfo(RenderObject*);
#ifndef NDEBUG
virtual void removeRegionFromThread(RenderRegion*);
const RenderRegionList& renderRegionList() const { return m_regionList; }
- virtual void updateLogicalWidth() OVERRIDE;
+ virtual void updateLogicalWidth() OVERRIDE FINAL;
virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const OVERRIDE;
void paintFlowThreadPortionInRegion(PaintInfo&, RenderRegion*, LayoutRect flowThreadPortionRect, LayoutRect flowThreadPortionOverflowRect, const LayoutPoint&) const;
class HTMLFrameElement;
-class RenderFrame : public RenderFrameBase {
+class RenderFrame FINAL : public RenderFrameBase {
public:
explicit RenderFrame(HTMLFrameElement*);
Vector<bool> m_allowBorder;
};
-class RenderFrameSet : public RenderBox {
+class RenderFrameSet FINAL : public RenderBox {
public:
RenderFrameSet(HTMLFrameSetElement*);
virtual ~RenderFrameSet();
using namespace WebCore;
-class RenderFullScreenPlaceholder : public RenderBlock {
+class RenderFullScreenPlaceholder FINAL : public RenderBlock {
public:
RenderFullScreenPlaceholder(RenderFullScreen* owner)
: RenderBlock(0)
namespace WebCore {
-class RenderFullScreen : public RenderFlexibleBox {
+class RenderFullScreen FINAL : public RenderFlexibleBox {
public:
static RenderFullScreen* createAnonymous(Document*);
class GridTrack;
-class RenderGrid : public RenderBlock {
+class RenderGrid FINAL : public RenderBlock {
public:
RenderGrid(Element*);
virtual ~RenderGrid();
class HTMLCanvasElement;
-class RenderHTMLCanvas : public RenderReplaced {
+class RenderHTMLCanvas FINAL : public RenderReplaced {
public:
explicit RenderHTMLCanvas(HTMLCanvasElement*);
class RenderView;
-class RenderIFrame : public RenderFrameBase {
+class RenderIFrame FINAL : public RenderFrameBase {
public:
explicit RenderIFrame(Element*);
String altText() const { return m_altText; }
protected:
- virtual bool needsPreferredWidthsRecalculation() const;
- virtual RenderBox* embeddedContentBox() const;
- virtual void computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const;
+ virtual bool needsPreferredWidthsRecalculation() const OVERRIDE FINAL;
+ virtual RenderBox* embeddedContentBox() const OVERRIDE FINAL;
+ virtual void computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const OVERRIDE FINAL;
virtual bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const OVERRIDE;
- virtual void styleDidChange(StyleDifference, const RenderStyle*);
+ virtual void styleDidChange(StyleDifference, const RenderStyle*) OVERRIDE FINAL;
virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
- virtual void paintIntoRect(GraphicsContext*, const LayoutRect&);
- virtual void paint(PaintInfo&, const LayoutPoint&);
+ void paintIntoRect(GraphicsContext*, const LayoutRect&);
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
virtual void layout();
virtual void intrinsicSizeChanged()
virtual const char* renderName() const { return "RenderImage"; }
virtual bool isImage() const { return true; }
- virtual bool isRenderImage() const { return true; }
+ virtual bool isRenderImage() const OVERRIDE FINAL { return true; }
virtual void paintReplaced(PaintInfo&, const LayoutPoint&);
- virtual bool computeBackgroundIsKnownToBeObscured() OVERRIDE;
+ virtual bool computeBackgroundIsKnownToBeObscured() OVERRIDE FINAL;
virtual LayoutUnit minimumReplacedHeight() const OVERRIDE;
- virtual void notifyFinished(CachedResource*);
- virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
+ virtual void notifyFinished(CachedResource*) OVERRIDE FINAL;
+ virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE FINAL;
- virtual bool boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, InlineFlowBox*) const OVERRIDE;
+ virtual bool boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, InlineFlowBox*) const OVERRIDE FINAL;
IntSize imageSizeForError(CachedImage*) const;
void imageDimensionsChanged(bool imageSizeChanged, const IntRect* = 0);
Element* node() const { return toElement(RenderBoxModelObject::node()); }
- virtual LayoutUnit marginLeft() const;
- virtual LayoutUnit marginRight() const;
- virtual LayoutUnit marginTop() const;
- virtual LayoutUnit marginBottom() const;
- virtual LayoutUnit marginBefore(const RenderStyle* otherStyle = 0) const;
- virtual LayoutUnit marginAfter(const RenderStyle* otherStyle = 0) const;
- virtual LayoutUnit marginStart(const RenderStyle* otherStyle = 0) const;
- virtual LayoutUnit marginEnd(const RenderStyle* otherStyle = 0) const;
-
- virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
+ virtual LayoutUnit marginLeft() const OVERRIDE FINAL;
+ virtual LayoutUnit marginRight() const OVERRIDE FINAL;
+ virtual LayoutUnit marginTop() const OVERRIDE FINAL;
+ virtual LayoutUnit marginBottom() const OVERRIDE FINAL;
+ virtual LayoutUnit marginBefore(const RenderStyle* otherStyle = 0) const OVERRIDE FINAL;
+ virtual LayoutUnit marginAfter(const RenderStyle* otherStyle = 0) const OVERRIDE FINAL;
+ virtual LayoutUnit marginStart(const RenderStyle* otherStyle = 0) const OVERRIDE FINAL;
+ virtual LayoutUnit marginEnd(const RenderStyle* otherStyle = 0) const OVERRIDE FINAL;
+
+ virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE FINAL;
virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
- virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
+ virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const OVERRIDE FINAL;
IntRect linesBoundingBox() const;
LayoutRect linesVisualOverflowBoundingBox() const;
InlineBox* firstLineBoxIncludingCulling() const { return alwaysCreateLineBoxes() ? firstLineBox() : culledInlineFirstLineBox(); }
InlineBox* lastLineBoxIncludingCulling() const { return alwaysCreateLineBoxes() ? lastLineBox() : culledInlineLastLineBox(); }
- virtual RenderBoxModelObject* virtualContinuation() const { return continuation(); }
+ virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
RenderInline* inlineElementContinuation() const;
- virtual void updateDragState(bool dragOn);
+ virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
LayoutSize offsetForInFlowPositionedInline(const RenderBox* child) const;
- virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
+ virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE FINAL;
void paintOutline(PaintInfo&, const LayoutPoint&);
using RenderBoxModelObject::continuation;
void setAlwaysCreateLineBoxes() { m_alwaysCreateLineBoxes = true; }
void updateAlwaysCreateLineBoxes(bool fullLayout);
- virtual LayoutRect localCaretRect(InlineBox*, int, LayoutUnit* extraWidthToEndOfLine) OVERRIDE;
+ virtual LayoutRect localCaretRect(InlineBox*, int, LayoutUnit* extraWidthToEndOfLine) OVERRIDE FINAL;
bool hitTestCulledInline(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset);
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
private:
- virtual RenderObjectChildList* virtualChildren() { return children(); }
- virtual const RenderObjectChildList* virtualChildren() const { return children(); }
+ virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
+ virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
const RenderObjectChildList* children() const { return &m_children; }
RenderObjectChildList* children() { return &m_children; }
virtual const char* renderName() const;
- virtual bool isRenderInline() const { return true; }
+ virtual bool isRenderInline() const OVERRIDE FINAL { return true; }
LayoutRect culledInlineVisualOverflowBoundingBox() const;
InlineBox* culledInlineFirstLineBox() const;
void generateCulledLineBoxRects(GeneratorContext& yield, const RenderInline* container) const;
void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
- virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0);
+ virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) OVERRIDE FINAL;
void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
RenderObject* beforeChild, RenderBoxModelObject* oldCont);
void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
RenderObject* newChild, RenderBoxModelObject* oldCont);
- virtual void layout() { ASSERT_NOT_REACHED(); } // Do nothing for layout()
+ virtual void layout() OVERRIDE FINAL { ASSERT_NOT_REACHED(); } // Do nothing for layout()
- virtual void paint(PaintInfo&, const LayoutPoint&);
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
- virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
+ virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE FINAL;
- virtual bool requiresLayer() const { return isInFlowPositioned() || createsGroup() || hasClipPath(); }
+ virtual bool requiresLayer() const OVERRIDE { return isInFlowPositioned() || createsGroup() || hasClipPath(); }
- virtual LayoutUnit offsetLeft() const;
- virtual LayoutUnit offsetTop() const;
- virtual LayoutUnit offsetWidth() const { return linesBoundingBox().width(); }
- virtual LayoutUnit offsetHeight() const { return linesBoundingBox().height(); }
+ virtual LayoutUnit offsetLeft() const OVERRIDE FINAL;
+ virtual LayoutUnit offsetTop() const OVERRIDE FINAL;
+ virtual LayoutUnit offsetWidth() const OVERRIDE FINAL { return linesBoundingBox().width(); }
+ virtual LayoutUnit offsetHeight() const OVERRIDE FINAL { return linesBoundingBox().height(); }
virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;
- virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE;
- virtual void computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect&, bool fixed) const OVERRIDE;
+ virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
+ virtual void computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect&, bool fixed) const OVERRIDE FINAL;
virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const OVERRIDE;
- virtual VisiblePosition positionForPoint(const LayoutPoint&);
+ virtual VisiblePosition positionForPoint(const LayoutPoint&) OVERRIDE FINAL;
- virtual LayoutRect frameRectForStickyPositioning() const OVERRIDE { return linesBoundingBox(); }
+ virtual LayoutRect frameRectForStickyPositioning() const OVERRIDE FINAL { return linesBoundingBox(); }
- virtual IntRect borderBoundingBox() const
+ virtual IntRect borderBoundingBox() const OVERRIDE FINAL
{
IntRect boundingBox = linesBoundingBox();
return IntRect(0, 0, boundingBox.width(), boundingBox.height());
virtual InlineFlowBox* createInlineFlowBox(); // Subclassed by SVG and Ruby
- virtual void dirtyLinesFromChangedChild(RenderObject* child) { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
+ virtual void dirtyLinesFromChangedChild(RenderObject* child) OVERRIDE FINAL { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
- virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;
- virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;
+ virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
+ virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
- virtual void childBecameNonInline(RenderObject* child);
+ virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
- virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&);
+ virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) OVERRIDE FINAL;
- virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
+ virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) OVERRIDE FINAL;
#if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
- virtual void addAnnotatedRegions(Vector<AnnotatedRegionValue>&);
+ virtual void addAnnotatedRegions(Vector<AnnotatedRegionValue>&) OVERRIDE FINAL;
#endif
- virtual void updateFromStyle() OVERRIDE;
+ virtual void updateFromStyle() OVERRIDE FINAL;
RenderInline* clone() const;
virtual void willBeDestroyed() OVERRIDE;
private:
- virtual bool isLayerModelObject() const OVERRIDE { return true; }
+ virtual bool isLayerModelObject() const OVERRIDE FINAL { return true; }
RenderLayer* m_layer;
class HTMLSelectElement;
-class RenderListBox : public RenderBlock, private ScrollableArea {
+class RenderListBox FINAL : public RenderBlock, private ScrollableArea {
public:
explicit RenderListBox(Element*);
virtual ~RenderListBox();
class HTMLOListElement;
class RenderListMarker;
-class RenderListItem : public RenderBlock {
+class RenderListItem FINAL : public RenderBlock {
public:
explicit RenderListItem(Element*);
// Used to render the list item's marker.
// The RenderListMarker always has to be a child of a RenderListItem.
-class RenderListMarker : public RenderBox {
+class RenderListMarker FINAL : public RenderBox {
public:
static RenderListMarker* createAnonymous(RenderListItem*);
virtual void layout();
private:
- virtual RenderObjectChildList* virtualChildren() { return children(); }
- virtual const RenderObjectChildList* virtualChildren() const { return children(); }
- virtual bool canHaveChildren() const { return true; }
+ virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
+ virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
+ virtual bool canHaveChildren() const OVERRIDE FINAL { return true; }
virtual const char* renderName() const { return "RenderMedia"; }
- virtual bool isMedia() const { return true; }
- virtual bool isImage() const { return false; }
+ virtual bool isMedia() const OVERRIDE FINAL { return true; }
+ virtual bool isImage() const OVERRIDE FINAL { return false; }
virtual void paintReplaced(PaintInfo&, const LayoutPoint&);
- virtual bool requiresForcedStyleRecalcPropagation() const { return true; }
+ virtual bool requiresForcedStyleRecalcPropagation() const OVERRIDE FINAL { return true; }
RenderObjectChildList m_children;
};
namespace WebCore {
-class RenderMediaVolumeSliderContainer : public RenderBlock {
+class RenderMediaVolumeSliderContainer FINAL : public RenderBlock {
public:
RenderMediaVolumeSliderContainer(Element*);
// ----------------------------
-class RenderMediaControlTimelineContainer : public RenderFlexibleBox {
+class RenderMediaControlTimelineContainer FINAL : public RenderFlexibleBox {
public:
RenderMediaControlTimelineContainer(Element*);
#if ENABLE(VIDEO_TRACK)
-class RenderTextTrackContainerElement : public RenderBlock {
+class RenderTextTrackContainerElement FINAL : public RenderBlock {
public:
RenderTextTrackContainerElement(Element*);
class HTMLSelectElement;
class RenderText;
-class RenderMenuList : public RenderFlexibleBox, private PopupMenuClient {
+class RenderMenuList FINAL : public RenderFlexibleBox, private PopupMenuClient {
public:
RenderMenuList(Element*);
class HTMLMeterElement;
-class RenderMeter : public RenderBlock {
+class RenderMeter FINAL : public RenderBlock {
public:
explicit RenderMeter(HTMLElement*);
virtual ~RenderMeter();
class RenderMultiColumnFlowThread;
-class RenderMultiColumnBlock : public RenderBlock {
+class RenderMultiColumnBlock FINAL : public RenderBlock {
public:
RenderMultiColumnBlock(Element*);
namespace WebCore {
-class RenderMultiColumnFlowThread : public RenderFlowThread {
+class RenderMultiColumnFlowThread FINAL : public RenderFlowThread {
public:
~RenderMultiColumnFlowThread();
//
// Column spans result in the creation of new column sets as well, since a spanning region has to be placed in between the column sets that
// come before and after the span.
-class RenderMultiColumnSet : public RenderRegionSet {
+class RenderMultiColumnSet FINAL : public RenderRegionSet {
public:
static RenderMultiColumnSet* createAnonymous(RenderFlowThread*);
typedef HashCountedSet<RenderNamedFlowThread*> RenderNamedFlowThreadCountedSet;
typedef ListHashSet<Node*> NamedFlowContentNodes;
-class RenderNamedFlowThread : public RenderFlowThread {
+class RenderNamedFlowThread FINAL : public RenderFlowThread {
public:
virtual ~RenderNamedFlowThread();
explicit RenderPart(Element*);
virtual ~RenderPart();
- virtual void setWidget(PassRefPtr<Widget>);
+ virtual void setWidget(PassRefPtr<Widget>) OVERRIDE FINAL;
virtual void viewCleared();
#if USE(ACCELERATED_COMPOSITING)
bool requiresAcceleratedCompositing() const;
#endif
- virtual bool needsPreferredWidthsRecalculation() const;
- virtual RenderBox* embeddedContentBox() const;
+ virtual bool needsPreferredWidthsRecalculation() const OVERRIDE FINAL;
+ virtual RenderBox* embeddedContentBox() const OVERRIDE FINAL;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
protected:
#if USE(ACCELERATED_COMPOSITING)
- virtual bool requiresLayer() const;
+ virtual bool requiresLayer() const OVERRIDE;
#endif
private:
- virtual bool isRenderPart() const { return true; }
- virtual const char* renderName() const { return "RenderPart"; }
+ virtual bool isRenderPart() const OVERRIDE FINAL { return true; }
+ virtual const char* renderName() const OVERRIDE { return "RenderPart"; }
};
inline RenderPart* toRenderPart(RenderObject* object)
class HTMLProgressElement;
-class RenderProgress : public RenderBlock {
+class RenderProgress FINAL : public RenderBlock {
public:
explicit RenderProgress(HTMLElement*);
virtual ~RenderProgress();
public:
explicit RenderRegion(Element*, RenderFlowThread*);
- virtual bool isRenderRegion() const { return true; }
+ virtual bool isRenderRegion() const OVERRIDE FINAL { return true; }
virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
virtual bool shouldHaveAutoLogicalHeight() const OVERRIDE { return false; }
private:
- virtual void installFlowThread() OVERRIDE;
+ virtual void installFlowThread() OVERRIDE FINAL;
- virtual void expandToEncompassFlowThreadContentsIfNeeded() OVERRIDE;
+ virtual void expandToEncompassFlowThreadContentsIfNeeded() OVERRIDE FINAL;
virtual const char* renderName() const = 0;
- virtual bool isRenderRegionSet() const OVERRIDE { return true; }
+ virtual bool isRenderRegionSet() const OVERRIDE FINAL { return true; }
};
} // namespace WebCore
virtual void layout();
- virtual LayoutSize intrinsicSize() const OVERRIDE { return m_intrinsicSize; }
+ virtual LayoutSize intrinsicSize() const OVERRIDE FINAL { return m_intrinsicSize; }
virtual void computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const;
- virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
+ virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE FINAL;
virtual LayoutUnit minimumReplacedHeight() const { return LayoutUnit(); }
virtual void intrinsicSizeChanged();
virtual bool hasRelativeIntrinsicLogicalWidth() const { return false; }
- virtual void paint(PaintInfo&, const LayoutPoint&);
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
bool shouldPaint(PaintInfo&, const LayoutPoint&);
LayoutRect localSelectionRect(bool checkWhetherSelected = true) const; // This is in local coordinates, but it's a physical rect (so the top left corner is physical top left).
private:
virtual RenderBox* embeddedContentBox() const { return 0; }
- virtual const char* renderName() const { return "RenderReplaced"; }
+ virtual const char* renderName() const OVERRIDE { return "RenderReplaced"; }
virtual bool canHaveChildren() const { return false; }
- virtual void computePreferredLogicalWidths();
+ virtual void computePreferredLogicalWidths() OVERRIDE FINAL;
virtual void paintReplaced(PaintInfo&, const LayoutPoint&) { }
virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;
- virtual VisiblePosition positionForPoint(const LayoutPoint&);
+ virtual VisiblePosition positionForPoint(const LayoutPoint&) OVERRIDE FINAL;
virtual bool canBeSelectionLeaf() const { return true; }
- virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent = true) OVERRIDE;
+ virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent = true) OVERRIDE FINAL;
void computeAspectRatioInformationForRenderBox(RenderBox*, FloatSize& constrainedSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const;
mutable LayoutSize m_intrinsicSize;
namespace WebCore {
-class RenderReplica : public RenderBox {
+class RenderReplica FINAL : public RenderBox {
public:
static RenderReplica* createAnonymous(Document*);
// Generated :before/:after content is shunted into anonymous inline blocks
// <ruby> when used as 'display:inline'
-class RenderRubyAsInline : public RenderInline {
+class RenderRubyAsInline FINAL : public RenderInline {
public:
RenderRubyAsInline(Element*);
virtual ~RenderRubyAsInline();
};
// <ruby> when used as 'display:block' or 'display:inline-block'
-class RenderRubyAsBlock : public RenderBlock {
+class RenderRubyAsBlock FINAL : public RenderBlock {
public:
RenderRubyAsBlock(Element*);
virtual ~RenderRubyAsBlock();
class RenderRubyRun;
-class RenderRubyBase : public RenderBlock {
+class RenderRubyBase FINAL : public RenderBlock {
public:
virtual ~RenderRubyBase();
// RenderRubyRun are 'inline-block/table' like objects,and wrap a single pairing of a ruby base with its ruby text(s).
// See RenderRuby.h for further comments on the structure
-class RenderRubyRun : public RenderBlock {
+class RenderRubyRun FINAL : public RenderBlock {
public:
virtual ~RenderRubyRun();
namespace WebCore {
-class RenderRubyText : public RenderBlock {
+class RenderRubyText FINAL : public RenderBlock {
public:
RenderRubyText(Element*);
virtual ~RenderRubyText();
class RenderScrollbar;
-class RenderScrollbarPart : public RenderBlock {
+class RenderScrollbarPart FINAL : public RenderBlock {
public:
static RenderScrollbarPart* createAnonymous(Document*, RenderScrollbar* = 0, ScrollbarPart = NoPart);
class HTMLInputElement;
class SearchPopupMenu;
-class RenderSearchField : public RenderTextControlSingleLine, private PopupMenuClient {
+class RenderSearchField FINAL : public RenderTextControlSingleLine, private PopupMenuClient {
public:
RenderSearchField(Element*);
virtual ~RenderSearchField();
class MouseEvent;
class SliderThumbElement;
-class RenderSlider : public RenderFlexibleBox {
+class RenderSlider FINAL : public RenderFlexibleBox {
public:
static const int defaultTrackLength;
class HTMLPlugInImageElement;
-class RenderSnapshottedPlugIn : public RenderEmbeddedObject {
+class RenderSnapshottedPlugIn FINAL : public RenderEmbeddedObject {
public:
explicit RenderSnapshottedPlugIn(HTMLPlugInImageElement*);
virtual ~RenderSnapshottedPlugIn();
HTMLPlugInImageElement* plugInImageElement() const;
virtual const char* renderName() const { return "RenderSnapshottedPlugIn"; }
- virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const OVERRIDE;
- virtual bool isSnapshottedPlugIn() const OVERRIDE { return true; }
+ virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const OVERRIDE FINAL;
+ virtual bool isSnapshottedPlugIn() const OVERRIDE FINAL { return true; }
virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
- virtual bool canHaveWidget() const OVERRIDE { return false; }
+ virtual bool canHaveWidget() const OVERRIDE FINAL { return false; }
void paintSnapshot(PaintInfo&, const LayoutPoint&);
int calcBorderEnd() const;
void recalcBordersInRowDirection();
- virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0);
+ virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE FINAL;
struct ColumnStruct {
explicit ColumnStruct(unsigned initialSpan = 1)
}
// Override paddingStart/End to return pixel values to match behavor of RenderTableCell.
- virtual LayoutUnit paddingEnd() const OVERRIDE { return static_cast<int>(RenderBlock::paddingEnd()); }
- virtual LayoutUnit paddingStart() const OVERRIDE { return static_cast<int>(RenderBlock::paddingStart()); }
+ virtual LayoutUnit paddingEnd() const OVERRIDE FINAL { return static_cast<int>(RenderBlock::paddingEnd()); }
+ virtual LayoutUnit paddingStart() const OVERRIDE FINAL { return static_cast<int>(RenderBlock::paddingStart()); }
LayoutUnit bordersPaddingAndSpacingInRowDirection() const
{
void removeColumn(const RenderTableCol*);
protected:
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
- virtual void simplifiedNormalFlowLayout();
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE FINAL;
+ virtual void simplifiedNormalFlowLayout() OVERRIDE FINAL;
private:
- virtual const char* renderName() const { return "RenderTable"; }
+ virtual const char* renderName() const OVERRIDE { return "RenderTable"; }
- virtual bool isTable() const { return true; }
+ virtual bool isTable() const OVERRIDE FINAL { return true; }
- virtual bool avoidsFloats() const { return true; }
+ virtual bool avoidsFloats() const OVERRIDE FINAL { return true; }
- virtual void paint(PaintInfo&, const LayoutPoint&);
- virtual void paintObject(PaintInfo&, const LayoutPoint&);
- virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&);
- virtual void paintMask(PaintInfo&, const LayoutPoint&);
- virtual void layout();
- virtual void computeIntrinsicLogicalWidths(LayoutUnit& minWidth, LayoutUnit& maxWidth) const OVERRIDE;
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void paintObject(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void paintMask(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void layout() OVERRIDE FINAL;
+ virtual void computeIntrinsicLogicalWidths(LayoutUnit& minWidth, LayoutUnit& maxWidth) const OVERRIDE FINAL;
virtual void computePreferredLogicalWidths() OVERRIDE;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
- virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
+ virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
virtual int firstLineBoxBaseline() const OVERRIDE;
- virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
+ virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE FINAL;
RenderTableCol* slowColElement(unsigned col, bool* startEdge, bool* endEdge) const;
void updateColumnCache() const;
void invalidateCachedColumns();
- virtual RenderBlock* firstLineBlock() const;
- virtual void updateFirstLetter();
+ virtual RenderBlock* firstLineBlock() const OVERRIDE FINAL;
+ virtual void updateFirstLetter() OVERRIDE FINAL;
- virtual void updateLogicalWidth() OVERRIDE;
+ virtual void updateLogicalWidth() OVERRIDE FINAL;
LayoutUnit convertStyleLogicalWidthToComputedWidth(const Length& styleLogicalWidth, LayoutUnit availableWidth);
LayoutUnit convertStyleLogicalHeightToComputedHeight(const Length& styleLogicalHeight);
- virtual LayoutRect overflowClipRect(const LayoutPoint& location, RenderRegion*, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize);
+ virtual LayoutRect overflowClipRect(const LayoutPoint& location, RenderRegion*, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) OVERRIDE FINAL;
- virtual void addOverflowFromChildren();
+ virtual void addOverflowFromChildren() OVERRIDE FINAL;
void subtractCaptionRect(LayoutRect&) const;
class RenderTable;
-class RenderTableCaption : public RenderBlock {
+class RenderTableCaption FINAL : public RenderBlock {
public:
explicit RenderTableCaption(Element*);
virtual ~RenderTableCaption();
enum IncludeBorderColorOrNot { DoNotIncludeBorderColor, IncludeBorderColor };
-class RenderTableCell : public RenderBlock {
+class RenderTableCell FINAL : public RenderBlock {
public:
explicit RenderTableCell(Element*);
class RenderTable;
class RenderTableCell;
-class RenderTableCol : public RenderBox {
+class RenderTableCol FINAL : public RenderBox {
public:
explicit RenderTableCol(Element*);
static const unsigned unsetRowIndex = 0x7FFFFFFF;
static const unsigned maxRowIndex = 0x7FFFFFFE; // 2,147,483,646
-class RenderTableRow : public RenderBox {
+class RenderTableRow FINAL : public RenderBox {
public:
explicit RenderTableRow(Element*);
class RenderTableCell;
class RenderTableRow;
-class RenderTableSection : public RenderBox {
+class RenderTableSection FINAL : public RenderBox {
public:
RenderTableSection(Element*);
virtual ~RenderTableSection();
virtual ~RenderText();
#endif
- virtual const char* renderName() const;
+ virtual const char* renderName() const OVERRIDE;
virtual bool isTextFragment() const;
virtual bool isWordBreak() const;
InlineTextBox* createInlineTextBox();
void dirtyLineBoxes(bool fullLayout);
- virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
+ virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE FINAL;
void absoluteRectsForRange(Vector<IntRect>&, unsigned startOffset = 0, unsigned endOffset = UINT_MAX, bool useSelectionHeight = false, bool* wasFixed = 0);
- virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
+ virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE FINAL;
void absoluteQuadsForRange(Vector<FloatQuad>&, unsigned startOffset = 0, unsigned endOffset = UINT_MAX, bool useSelectionHeight = false, bool* wasFixed = 0);
enum ClippingOption { NoClipping, ClipToEllipsis };
virtual void transformText();
virtual bool canBeSelectionLeaf() const { return true; }
- virtual void setSelectionState(SelectionState s);
+ virtual void setSelectionState(SelectionState s) OVERRIDE FINAL;
virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent = true) OVERRIDE;
virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0);
- virtual LayoutUnit marginLeft() const { return minimumValueForLength(style()->marginLeft(), 0, view()); }
- virtual LayoutUnit marginRight() const { return minimumValueForLength(style()->marginRight(), 0, view()); }
+ LayoutUnit marginLeft() const { return minimumValueForLength(style()->marginLeft(), 0, view()); }
+ LayoutUnit marginRight() const { return minimumValueForLength(style()->marginRight(), 0, view()); }
- virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;
+ virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE FINAL;
InlineTextBox* firstTextBox() const { return m_firstTextBox; }
InlineTextBox* lastTextBox() const { return m_lastTextBox; }
virtual int caretMinOffset() const;
virtual int caretMaxOffset() const;
- virtual unsigned renderedTextLength() const;
+ unsigned renderedTextLength() const;
- virtual int previousOffset(int current) const;
- virtual int previousOffsetForBackwardDeletion(int current) const;
- virtual int nextOffset(int current) const;
+ virtual int previousOffset(int current) const OVERRIDE FINAL;
+ virtual int previousOffsetForBackwardDeletion(int current) const OVERRIDE FINAL;
+ virtual int nextOffset(int current) const OVERRIDE FINAL;
bool containsReversedText() const { return m_containsReversedText; }
virtual void computePreferredLogicalWidths(float leadWidth);
virtual void willBeDestroyed();
- virtual void styleWillChange(StyleDifference, const RenderStyle*) { }
+ virtual void styleWillChange(StyleDifference, const RenderStyle*) OVERRIDE FINAL { }
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
virtual void setTextInternal(PassRefPtr<StringImpl>);
// Make length() private so that callers that have a RenderText*
// will use the more efficient textLength() instead, while
// callers with a RenderObject* can continue to use length().
- virtual unsigned length() const { return textLength(); }
+ virtual unsigned length() const OVERRIDE FINAL { return textLength(); }
- virtual void paint(PaintInfo&, const LayoutPoint&) { ASSERT_NOT_REACHED(); }
- virtual void layout() { ASSERT_NOT_REACHED(); }
- virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) OVERRIDE { ASSERT_NOT_REACHED(); return false; }
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL { ASSERT_NOT_REACHED(); }
+ virtual void layout() OVERRIDE FINAL { ASSERT_NOT_REACHED(); }
+ virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) OVERRIDE FINAL { ASSERT_NOT_REACHED(); return false; }
void deleteTextBoxes();
bool containsOnlyWhitespace(unsigned from, unsigned len) const;
int scrollbarThickness() const;
void adjustInnerTextStyle(const RenderStyle* startStyle, RenderStyle* textBlockStyle) const;
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
void hitInnerTextElement(HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset);
virtual RenderObject* layoutSpecialExcludedChild(bool relayoutChildren);
private:
- virtual const char* renderName() const { return "RenderTextControl"; }
- virtual bool isTextControl() const { return true; }
+ virtual const char* renderName() const OVERRIDE { return "RenderTextControl"; }
+ virtual bool isTextControl() const OVERRIDE FINAL { return true; }
virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
virtual void computePreferredLogicalWidths() OVERRIDE;
virtual void removeLeftoverAnonymousBlock(RenderBlock*) { }
- virtual bool avoidsFloats() const { return true; }
+ virtual bool avoidsFloats() const OVERRIDE { return true; }
virtual bool canHaveGeneratedChildren() const OVERRIDE { return false; }
virtual bool canBeReplacedWithInlineRunIn() const OVERRIDE;
// We can't use RenderFlexibleBox directly, because flexboxes have a different
// baseline definition, and then inputs of different types wouldn't line up
// anymore.
-class RenderTextControlInnerContainer : public RenderFlexibleBox {
+class RenderTextControlInnerContainer FINAL : public RenderFlexibleBox {
public:
explicit RenderTextControlInnerContainer(Element* element)
: RenderFlexibleBox(element)
namespace WebCore {
-class RenderTextControlMultiLine : public RenderTextControl {
+class RenderTextControlMultiLine FINAL : public RenderTextControl {
public:
RenderTextControlMultiLine(Element*);
virtual ~RenderTextControlMultiLine();
virtual void updateFromElement() OVERRIDE;
private:
- virtual bool hasControlClip() const;
- virtual LayoutRect controlClipRect(const LayoutPoint&) const;
- virtual bool isTextField() const { return true; }
+ virtual bool hasControlClip() const OVERRIDE;
+ virtual LayoutRect controlClipRect(const LayoutPoint&) const OVERRIDE;
+ virtual bool isTextField() const OVERRIDE FINAL { return true; }
- virtual void paint(PaintInfo&, const LayoutPoint&);
- virtual void layout();
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
+ virtual void layout() OVERRIDE;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
- virtual void autoscroll(const IntPoint&);
+ virtual void autoscroll(const IntPoint&) OVERRIDE;
// Subclassed to forward to our inner div.
- virtual int scrollLeft() const;
- virtual int scrollTop() const;
- virtual int scrollWidth() const;
- virtual int scrollHeight() const;
- virtual void setScrollLeft(int);
- virtual void setScrollTop(int);
- virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Node** stopNode = 0);
- virtual bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Node** stopNode = 0);
+ virtual int scrollLeft() const OVERRIDE;
+ virtual int scrollTop() const OVERRIDE;
+ virtual int scrollWidth() const OVERRIDE;
+ virtual int scrollHeight() const OVERRIDE;
+ virtual void setScrollLeft(int) OVERRIDE;
+ virtual void setScrollTop(int) OVERRIDE;
+ virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Node** stopNode = 0) OVERRIDE;
+ virtual bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Node** stopNode = 0) OVERRIDE;
int textBlockWidth() const;
- virtual float getAvgCharWidth(AtomicString family);
- virtual LayoutUnit preferredContentLogicalWidth(float charWidth) const;
+ virtual float getAvgCharWidth(AtomicString family) OVERRIDE;
+ virtual LayoutUnit preferredContentLogicalWidth(float charWidth) const OVERRIDE;
virtual LayoutUnit computeControlLogicalHeight(LayoutUnit lineHeight, LayoutUnit nonContentHeight) const OVERRIDE;
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
- virtual RenderStyle* textBaseStyle() const;
+ virtual RenderStyle* textBaseStyle() const OVERRIDE;
bool textShouldBeTruncated() const;
// first letter and that must therefore have different styles (and positions in the render tree).
// We cache offsets so that text transformations can be applied in such a way that we can recover
// the original unaltered string from our corresponding DOM node.
-class RenderTextFragment : public RenderText {
+class RenderTextFragment FINAL : public RenderText {
public:
RenderTextFragment(Node*, StringImpl*, int startOffset, int length);
RenderTextFragment(Node*, StringImpl*);
class TextTrackCueBox;
-class RenderTextTrackCue : public RenderBlock {
+class RenderTextTrackCue FINAL : public RenderBlock {
public:
explicit RenderTextTrackCue(TextTrackCueBox*);
class HTMLMediaElement;
class HTMLVideoElement;
-class RenderVideo : public RenderMedia {
+class RenderVideo FINAL : public RenderMedia {
public:
RenderVideo(HTMLVideoElement*);
virtual ~RenderVideo();
class CustomFilterGlobalContext;
#endif
-class RenderView : public RenderBlock {
+class RenderView FINAL : public RenderBlock {
public:
explicit RenderView(Document*);
virtual ~RenderView();
void clearWidget();
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
- virtual void layout();
- virtual void paint(PaintInfo&, const LayoutPoint&);
- virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const;
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE FINAL;
+ virtual void layout() OVERRIDE;
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
+ virtual CursorDirective getCursor(const LayoutPoint&, Cursor&) const OVERRIDE;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
virtual void paintContents(PaintInfo&, const LayoutPoint&);
private:
- virtual bool isWidget() const { return true; }
+ virtual bool isWidget() const OVERRIDE FINAL { return true; }
- virtual void willBeDestroyed();
- virtual void destroy();
- virtual void setSelectionState(SelectionState);
- virtual void setOverlapTestResult(bool);
+ virtual void willBeDestroyed() OVERRIDE FINAL;
+ virtual void destroy() OVERRIDE FINAL;
+ virtual void setSelectionState(SelectionState) OVERRIDE FINAL;
+ virtual void setOverlapTestResult(bool) OVERRIDE FINAL;
bool setWidgetGeometry(const LayoutRect&);
bool updateWidgetGeometry();
class HTMLElement;
-class RenderWordBreak : public RenderText {
+class RenderWordBreak FINAL : public RenderText {
public:
explicit RenderWordBreak(HTMLElement*);
public:
explicit RootInlineBox(RenderBlock*);
- virtual void destroy(RenderArena*) FINAL;
+ virtual void destroy(RenderArena*) OVERRIDE FINAL;
- virtual bool isRootInlineBox() const FINAL { return true; }
+ virtual bool isRootInlineBox() const OVERRIDE FINAL { return true; }
void detachEllipsisBox(RenderArena*);
RootInlineBox* nextRootBox() const { return static_cast<RootInlineBox*>(m_nextLineBox); }
RootInlineBox* prevRootBox() const { return static_cast<RootInlineBox*>(m_prevLineBox); }
- virtual void adjustPosition(float dx, float dy) FINAL;
+ virtual void adjustPosition(float dx, float dy) OVERRIDE FINAL;
LayoutUnit lineTop() const { return m_lineTop; }
LayoutUnit lineBottom() const { return m_lineBottom; }
m_lineBottomWithLeading = bottomWithLeading;
}
- virtual RenderLineBoxList* rendererLineBoxes() const FINAL;
+ virtual RenderLineBoxList* rendererLineBoxes() const OVERRIDE FINAL;
RenderObject* lineBreakObj() const { return m_lineBreakObj; }
BidiStatus lineBreakBidiStatus() const;
bool isHyphenated() const;
- virtual int baselinePosition(FontBaseline baselineType) const FINAL;
- virtual LayoutUnit lineHeight() const FINAL;
+ virtual int baselinePosition(FontBaseline baselineType) const OVERRIDE FINAL;
+ virtual LayoutUnit lineHeight() const OVERRIDE FINAL;
#if PLATFORM(MAC)
void addHighlightOverflow();
using InlineBox::hasSelectedChildren;
using InlineBox::setHasSelectedChildren;
- virtual RenderObject::SelectionState selectionState() FINAL;
+ virtual RenderObject::SelectionState selectionState() OVERRIDE FINAL;
InlineBox* firstSelectedBox();
InlineBox* lastSelectedBox();
Vector<RenderBox*>* floatsPtr() { ASSERT(!isDirty()); return m_floats.get(); }
- virtual void extractLineBoxFromRenderObject() FINAL;
- virtual void attachLineBoxToRenderObject() FINAL;
- virtual void removeLineBoxFromRenderObject() FINAL;
+ virtual void extractLineBoxFromRenderObject() OVERRIDE FINAL;
+ virtual void attachLineBoxToRenderObject() OVERRIDE FINAL;
+ virtual void removeLineBoxFromRenderObject() OVERRIDE FINAL;
FontBaseline baselineType() const { return static_cast<FontBaseline>(m_baselineType); }
// This will catch anyone doing an unnecessary cast.
void toRenderMathMLBlock(const RenderMathMLBlock*);
-class RenderMathMLTable : public RenderTable {
+class RenderMathMLTable FINAL : public RenderTable {
public:
explicit RenderMathMLTable(Element* element) : RenderTable(element) { }
public:
explicit RenderSVGBlock(SVGElement*);
- virtual LayoutRect visualOverflowRect() const;
+ virtual LayoutRect visualOverflowRect() const OVERRIDE FINAL;
protected:
virtual void willBeDestroyed() OVERRIDE;
private:
- virtual void setStyle(PassRefPtr<RenderStyle>);
- virtual void updateFromStyle() OVERRIDE;
+ virtual void setStyle(PassRefPtr<RenderStyle>) OVERRIDE FINAL;
+ virtual void updateFromStyle() OVERRIDE FINAL;
- virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
+ virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE FINAL;
- virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+ virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle) OVERRIDE FINAL;
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE FINAL;
};
}
RenderObjectChildList* children() { return &m_children; }
virtual void paint(PaintInfo&, const LayoutPoint&);
- virtual void setNeedsBoundariesUpdate() { m_needsBoundariesUpdate = true; }
- virtual bool needsBoundariesUpdate() OVERRIDE { return m_needsBoundariesUpdate; }
+ virtual void setNeedsBoundariesUpdate() OVERRIDE FINAL { m_needsBoundariesUpdate = true; }
+ virtual bool needsBoundariesUpdate() OVERRIDE FINAL { return m_needsBoundariesUpdate; }
virtual bool didTransformToRootUpdate() { return false; }
bool isObjectBoundingBoxValid() const { return m_objectBoundingBoxValid; }
protected:
- virtual RenderObjectChildList* virtualChildren() { return children(); }
- virtual const RenderObjectChildList* virtualChildren() const { return children(); }
+ virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
+ virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
- virtual bool isSVGContainer() const { return true; }
- virtual const char* renderName() const { return "RenderSVGContainer"; }
+ virtual bool isSVGContainer() const OVERRIDE FINAL { return true; }
+ virtual const char* renderName() const OVERRIDE { return "RenderSVGContainer"; }
- virtual void layout();
+ virtual void layout() OVERRIDE;
- virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE;
- virtual void removeChild(RenderObject*) OVERRIDE;
- virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
+ virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE FINAL;
+ virtual void removeChild(RenderObject*) OVERRIDE FINAL;
+ virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE FINAL;
- virtual FloatRect objectBoundingBox() const { return m_objectBoundingBox; }
- virtual FloatRect strokeBoundingBox() const { return m_strokeBoundingBox; }
- virtual FloatRect repaintRectInLocalCoordinates() const { return m_repaintBoundingBox; }
+ virtual FloatRect objectBoundingBox() const OVERRIDE FINAL { return m_objectBoundingBox; }
+ virtual FloatRect strokeBoundingBox() const OVERRIDE FINAL { return m_strokeBoundingBox; }
+ virtual FloatRect repaintRectInLocalCoordinates() const OVERRIDE FINAL { return m_repaintBoundingBox; }
- virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);
+ virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction) OVERRIDE;
// Allow RenderSVGTransformableContainer to hook in at the right time in layout()
virtual bool calculateLocalTransform() { return false; }
namespace WebCore {
-class RenderSVGEllipse : public RenderSVGShape {
+class RenderSVGEllipse FINAL : public RenderSVGShape {
public:
explicit RenderSVGEllipse(SVGStyledTransformableElement*);
virtual ~RenderSVGEllipse();
class SVGForeignObjectElement;
-class RenderSVGForeignObject : public RenderSVGBlock {
+class RenderSVGForeignObject FINAL : public RenderSVGBlock {
public:
explicit RenderSVGForeignObject(SVGForeignObjectElement*);
virtual ~RenderSVGForeignObject();
class SVGStopElement;
// This class exists mostly so we can hear about gradient stop style changes
-class RenderSVGGradientStop : public RenderObject {
+class RenderSVGGradientStop FINAL : public RenderObject {
public:
RenderSVGGradientStop(SVGStopElement*);
virtual ~RenderSVGGradientStop();
public:
explicit RenderSVGHiddenContainer(SVGStyledElement*);
- virtual const char* renderName() const { return "RenderSVGHiddenContainer"; }
+ virtual const char* renderName() const OVERRIDE { return "RenderSVGHiddenContainer"; }
protected:
- virtual void layout();
+ virtual void layout() OVERRIDE;
private:
- virtual bool isSVGHiddenContainer() const { return true; }
+ virtual bool isSVGHiddenContainer() const OVERRIDE FINAL { return true; }
- virtual void paint(PaintInfo&, const LayoutPoint&);
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
- virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject*) const OVERRIDE { return LayoutRect(); }
- virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
+ virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject*) const OVERRIDE FINAL { return LayoutRect(); }
+ virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE FINAL;
- virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);
+ virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction) OVERRIDE FINAL;
};
}
class RenderImageResource;
class SVGImageElement;
-class RenderSVGImage : public RenderSVGModelObject {
+class RenderSVGImage FINAL : public RenderSVGModelObject {
public:
RenderSVGImage(SVGImageElement*);
virtual ~RenderSVGImage();
public:
explicit RenderSVGInline(Element*);
- virtual const char* renderName() const { return "RenderSVGInline"; }
- virtual bool requiresLayer() const { return false; }
- virtual bool isSVGInline() const { return true; }
+ virtual const char* renderName() const OVERRIDE { return "RenderSVGInline"; }
+ virtual bool requiresLayer() const OVERRIDE FINAL { return false; }
+ virtual bool isSVGInline() const OVERRIDE FINAL { return true; }
// Chapter 10.4 of the SVG Specification say that we should use the
// object bounding box of the parent text element.
// We search for the root text element and take its bounding box.
// It is also necessary to take the stroke and repaint rect of
// this element, since we need it for filters.
- virtual FloatRect objectBoundingBox() const;
- virtual FloatRect strokeBoundingBox() const;
- virtual FloatRect repaintRectInLocalCoordinates() const;
+ virtual FloatRect objectBoundingBox() const OVERRIDE FINAL;
+ virtual FloatRect strokeBoundingBox() const OVERRIDE FINAL;
+ virtual FloatRect repaintRectInLocalCoordinates() const OVERRIDE FINAL;
- virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;
- virtual void computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect&, bool fixed = false) const OVERRIDE;
- virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
- virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const OVERRIDE;
- virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
+ virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE FINAL;
+ virtual void computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect&, bool fixed = false) const OVERRIDE FINAL;
+ virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE FINAL;
+ virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const OVERRIDE FINAL;
+ virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE FINAL;
private:
- virtual InlineFlowBox* createInlineFlowBox();
+ virtual InlineFlowBox* createInlineFlowBox() OVERRIDE FINAL;
- virtual void willBeDestroyed();
- virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+ virtual void willBeDestroyed() OVERRIDE FINAL;
+ virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle) OVERRIDE FINAL;
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE FINAL;
- virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE;
- virtual void removeChild(RenderObject*) OVERRIDE;
+ virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0) OVERRIDE FINAL;
+ virtual void removeChild(RenderObject*) OVERRIDE FINAL;
};
}
class SVGInlineTextBox;
-class RenderSVGInlineText : public RenderText {
+class RenderSVGInlineText FINAL : public RenderText {
public:
RenderSVGInlineText(Node*, PassRefPtr<StringImpl>);
public:
explicit RenderSVGModelObject(SVGStyledElement*);
- virtual bool requiresLayer() const { return false; }
-
virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;
- virtual void computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect&, bool fixed = false) const OVERRIDE;
- virtual LayoutRect outlineBoundsForRepaint(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap*) const OVERRIDE;
+ virtual void computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect&, bool fixed = false) const OVERRIDE FINAL;
+ virtual LayoutRect outlineBoundsForRepaint(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap*) const OVERRIDE FINAL;
- virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
+ virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE FINAL;
virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
- virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
- virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const OVERRIDE;
- virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
+ virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE FINAL;
+ virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const OVERRIDE FINAL;
+ virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle) OVERRIDE FINAL;
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
static bool checkIntersection(RenderObject*, const FloatRect&);
void setHasSVGShadow(bool hasShadow) { m_hasSVGShadow = hasShadow; }
protected:
- virtual void willBeDestroyed();
+ virtual void willBeDestroyed() OVERRIDE;
private:
// This method should never be called, SVG uses a different nodeAtPoint method
bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
- virtual void absoluteFocusRingQuads(Vector<FloatQuad>&);
+ virtual void absoluteFocusRingQuads(Vector<FloatQuad>&) OVERRIDE FINAL;
bool m_hasSVGShadow;
};
namespace WebCore {
-class RenderSVGPath : public RenderSVGShape {
+class RenderSVGPath FINAL : public RenderSVGShape {
public:
explicit RenderSVGPath(SVGStyledTransformableElement*);
virtual ~RenderSVGPath();
namespace WebCore {
-class RenderSVGRect : public RenderSVGShape {
+class RenderSVGRect FINAL : public RenderSVGShape {
public:
explicit RenderSVGRect(SVGRectElement*);
virtual ~RenderSVGRect();
OwnPtr<ImageBuffer> clipMaskImage;
};
-class RenderSVGResourceClipper : public RenderSVGResourceContainer {
+class RenderSVGResourceClipper FINAL : public RenderSVGResourceContainer {
public:
RenderSVGResourceClipper(SVGClipPathElement*);
virtual ~RenderSVGResourceClipper();
RenderSVGResourceContainer(SVGStyledElement*);
virtual ~RenderSVGResourceContainer();
- virtual void layout();
- virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
+ virtual void layout() OVERRIDE;
+ virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE FINAL;
- virtual bool isSVGResourceContainer() const { return true; }
- virtual RenderSVGResourceContainer* toRenderSVGResourceContainer() { return this; }
+ virtual bool isSVGResourceContainer() const OVERRIDE FINAL { return true; }
+ virtual RenderSVGResourceContainer* toRenderSVGResourceContainer() OVERRIDE FINAL { return this; }
static bool shouldTransformOnTextPainting(RenderObject*, AffineTransform&);
static AffineTransform transformOnNonScalingStroke(RenderObject*, const AffineTransform& resourceTransform);
void removeClient(RenderObject*);
private:
- virtual void willBeDestroyed();
+ virtual void willBeDestroyed() OVERRIDE FINAL;
void registerResource();
AtomicString m_id;
class GraphicsContext;
-class RenderSVGResourceFilter : public RenderSVGResourceContainer {
+class RenderSVGResourceFilter FINAL : public RenderSVGResourceContainer {
public:
RenderSVGResourceFilter(SVGFilterElement*);
virtual ~RenderSVGResourceFilter();
class FilterEffect;
-class RenderSVGResourceFilterPrimitive : public RenderSVGHiddenContainer {
+class RenderSVGResourceFilterPrimitive FINAL : public RenderSVGHiddenContainer {
public:
explicit RenderSVGResourceFilterPrimitive(SVGStyledElement* filterPrimitiveElement)
: RenderSVGHiddenContainer(filterPrimitiveElement)
public:
RenderSVGResourceGradient(SVGGradientElement*);
- virtual void removeAllClientsFromCache(bool markForInvalidation = true);
- virtual void removeClientFromCache(RenderObject*, bool markForInvalidation = true);
+ virtual void removeAllClientsFromCache(bool markForInvalidation = true) OVERRIDE FINAL;
+ virtual void removeClientFromCache(RenderObject*, bool markForInvalidation = true) OVERRIDE FINAL;
- virtual bool applyResource(RenderObject*, RenderStyle*, GraphicsContext*&, unsigned short resourceMode);
- virtual void postApplyResource(RenderObject*, GraphicsContext*&, unsigned short resourceMode, const Path*, const RenderSVGShape*);
- virtual FloatRect resourceBoundingBox(RenderObject*) { return FloatRect(); }
+ virtual bool applyResource(RenderObject*, RenderStyle*, GraphicsContext*&, unsigned short resourceMode) OVERRIDE FINAL;
+ virtual void postApplyResource(RenderObject*, GraphicsContext*&, unsigned short resourceMode, const Path*, const RenderSVGShape*) OVERRIDE FINAL;
+ virtual FloatRect resourceBoundingBox(RenderObject*) OVERRIDE FINAL { return FloatRect(); }
protected:
void addStops(GradientData*, const Vector<Gradient::ColorStop>&) const;
class SVGLinearGradientElement;
-class RenderSVGResourceLinearGradient : public RenderSVGResourceGradient {
+class RenderSVGResourceLinearGradient FINAL : public RenderSVGResourceGradient {
public:
RenderSVGResourceLinearGradient(SVGLinearGradientElement*);
virtual ~RenderSVGResourceLinearGradient();
class AffineTransform;
class RenderObject;
-class RenderSVGResourceMarker : public RenderSVGResourceContainer {
+class RenderSVGResourceMarker FINAL : public RenderSVGResourceContainer {
public:
RenderSVGResourceMarker(SVGMarkerElement*);
virtual ~RenderSVGResourceMarker();
OwnPtr<ImageBuffer> maskImage;
};
-class RenderSVGResourceMasker : public RenderSVGResourceContainer {
+class RenderSVGResourceMasker FINAL : public RenderSVGResourceContainer {
public:
RenderSVGResourceMasker(SVGMaskElement*);
virtual ~RenderSVGResourceMasker();
AffineTransform transform;
};
-class RenderSVGResourcePattern : public RenderSVGResourceContainer {
+class RenderSVGResourcePattern FINAL : public RenderSVGResourceContainer {
public:
RenderSVGResourcePattern(SVGPatternElement*);
class SVGRadialGradientElement;
-class RenderSVGResourceRadialGradient : public RenderSVGResourceGradient {
+class RenderSVGResourceRadialGradient FINAL : public RenderSVGResourceGradient {
public:
RenderSVGResourceRadialGradient(SVGRadialGradientElement*);
virtual ~RenderSVGResourceRadialGradient();
class AffineTransform;
class SVGStyledElement;
-class RenderSVGRoot : public RenderReplaced {
+class RenderSVGRoot FINAL : public RenderReplaced {
public:
explicit RenderSVGRoot(SVGStyledElement*);
virtual ~RenderSVGRoot();
virtual ~RenderSVGShape();
void setNeedsShapeUpdate() { m_needsShapeUpdate = true; }
- virtual void setNeedsBoundariesUpdate() { m_needsBoundariesUpdate = true; }
- virtual bool needsBoundariesUpdate() OVERRIDE { return m_needsBoundariesUpdate; }
- virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }
+ virtual void setNeedsBoundariesUpdate() OVERRIDE FINAL { m_needsBoundariesUpdate = true; }
+ virtual bool needsBoundariesUpdate() OVERRIDE FINAL { return m_needsBoundariesUpdate; }
+ virtual void setNeedsTransformUpdate() OVERRIDE FINAL { m_needsTransformUpdate = true; }
virtual void fillShape(GraphicsContext*) const;
virtual void strokeShape(GraphicsContext*) const;
bool fillContains(const FloatPoint&, bool requiresFill = true, const WindRule fillRule = RULE_NONZERO);
bool strokeContains(const FloatPoint&, bool requiresStroke = true);
- virtual FloatRect repaintRectInLocalCoordinates() const { return m_repaintBoundingBox; }
- virtual FloatRect repaintRectInLocalCoordinatesExcludingSVGShadow() const OVERRIDE { return m_repaintBoundingBoxExcludingShadow; }
- virtual const AffineTransform& localToParentTransform() const { return m_localTransform; }
- virtual AffineTransform localTransform() const { return m_localTransform; }
+ virtual FloatRect repaintRectInLocalCoordinates() const OVERRIDE FINAL { return m_repaintBoundingBox; }
+ virtual FloatRect repaintRectInLocalCoordinatesExcludingSVGShadow() const OVERRIDE FINAL { return m_repaintBoundingBoxExcludingShadow; }
+ virtual const AffineTransform& localToParentTransform() const OVERRIDE FINAL { return m_localTransform; }
+ virtual AffineTransform localTransform() const OVERRIDE FINAL { return m_localTransform; }
- virtual bool isSVGShape() const { return true; }
+ virtual bool isSVGShape() const OVERRIDE FINAL { return true; }
virtual const char* renderName() const { return "RenderSVGShape"; }
- virtual void layout();
- virtual void paint(PaintInfo&, const LayoutPoint&);
- virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
+ virtual void layout() OVERRIDE FINAL;
+ virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE FINAL;
+ virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE FINAL;
- virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);
+ virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction) OVERRIDE FINAL;
- virtual FloatRect objectBoundingBox() const { return m_fillBoundingBox; }
- virtual FloatRect strokeBoundingBox() const { return m_strokeBoundingBox; }
+ virtual FloatRect objectBoundingBox() const OVERRIDE FINAL { return m_fillBoundingBox; }
+ virtual FloatRect strokeBoundingBox() const OVERRIDE FINAL { return m_strokeBoundingBox; }
FloatRect calculateObjectBoundingBox() const;
FloatRect calculateStrokeBoundingBox() const;
void updateRepaintBoundingBox();
#include "RenderSVGInline.h"
namespace WebCore {
-class RenderSVGTSpan : public RenderSVGInline {
+class RenderSVGTSpan FINAL : public RenderSVGInline {
public:
explicit RenderSVGTSpan(Element*);
virtual const char* renderName() const { return "RenderSVGTSpan"; }
class SVGTextElement;
class RenderSVGInlineText;
-class RenderSVGText : public RenderSVGBlock {
+class RenderSVGText FINAL : public RenderSVGBlock {
public:
RenderSVGText(SVGTextElement*);
virtual ~RenderSVGText();
namespace WebCore {
-class RenderSVGTextPath : public RenderSVGInline {
+class RenderSVGTextPath FINAL : public RenderSVGInline {
public:
RenderSVGTextPath(Element*);
namespace WebCore {
class SVGStyledTransformableElement;
-class RenderSVGTransformableContainer : public RenderSVGContainer {
+class RenderSVGTransformableContainer FINAL : public RenderSVGContainer {
public:
explicit RenderSVGTransformableContainer(SVGStyledTransformableElement*);
// This is used for non-root <svg> elements and <marker> elements, neither of which are SVGTransformable
// thus we inherit from RenderSVGContainer instead of RenderSVGTransformableContainer
-class RenderSVGViewportContainer : public RenderSVGContainer {
+class RenderSVGViewportContainer FINAL : public RenderSVGContainer {
public:
explicit RenderSVGViewportContainer(SVGStyledElement*);
FloatRect viewport() const { return m_viewport; }
return min(supportable_instances, default_count)
def _build_java_test_support(self):
+ return True
java_tests_path = self._filesystem.join(self.layout_tests_dir(), "java")
build_java = [self.make_command(), "-C", java_tests_path]
if self._executive.run_command(build_java, return_exit_code=True): # Paths are absolute, so we don't need to set a cwd.
git://git.webkit.org / WebKit-https.git / commitdiff