Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
-#ifndef RenderObject_h
-#define RenderObject_h
+#ifndef LayoutObject_h
+#define LayoutObject_h
 
 #include "core/dom/Document.h"
 #include "core/dom/DocumentLifecycle.h"
 #include "core/dom/Element.h"
 #include "core/editing/TextAffinity.h"
 #include "core/fetch/ImageResourceClient.h"
 #include "core/html/HTMLElement.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/layout/HitTestRequest.h"
+#include "core/layout/LayoutObjectChildList.h"
 #include "core/layout/compositing/CompositingState.h"
 #include "core/layout/compositing/CompositingTriggers.h"
 #include "core/rendering/PaintInvalidationState.h"
 #include "core/rendering/PaintPhase.h"
-#include "core/rendering/RenderObjectChildList.h"
 #include "core/rendering/ScrollAlignment.h"
 #include "core/rendering/SubtreeLayoutScope.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "core/rendering/style/StyleInheritedData.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/CompositingReasons.h"
 #include "platform/graphics/PaintInvalidationReason.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
 #include "platform/transforms/TransformationMatrix.h"
@@ skipping 67 matching lines @@
     bool draggable;
 };
 
 typedef WTF::HashMap<const Layer*, Vector<LayoutRect>> LayerHitTestRects;
 
 #ifndef NDEBUG
 const int showTreeCharacterOffset = 39;
 #endif
 
 // Base class for all rendering tree objects.
-class RenderObject : public ImageResourceClient {
+class LayoutObject : public ImageResourceClient {
     friend class RenderBlock;
     friend class RenderBlockFlow;
     friend class LayerReflectionInfo; // For setParent
     friend class LayerScrollableArea; // For setParent.
-    friend class RenderObjectChildList;
-    WTF_MAKE_NONCOPYABLE(RenderObject);
+    friend class LayoutObjectChildList;
+    WTF_MAKE_NONCOPYABLE(LayoutObject);
 public:
     // Anonymous objects should pass the document as their node, and they will then automatically be
     // marked as anonymous in the constructor.
-    explicit RenderObject(Node*);
-    virtual ~RenderObject();
+    explicit LayoutObject(Node*);
+    virtual ~LayoutObject();
 
     virtual const char* renderName() const = 0;
 
     String debugName() const;
 
-    RenderObject* parent() const { return m_parent; }
-    bool isDescendantOf(const RenderObject*) const;
+    LayoutObject* parent() const { return m_parent; }
+    bool isDescendantOf(const LayoutObject*) const;
 
-    RenderObject* previousSibling() const { return m_previous; }
-    RenderObject* nextSibling() const { return m_next; }
+    LayoutObject* previousSibling() const { return m_previous; }
+    LayoutObject* nextSibling() const { return m_next; }
 
-    RenderObject* slowFirstChild() const
+    LayoutObject* slowFirstChild() const
     {
-        if (const RenderObjectChildList* children = virtualChildren())
+        if (const LayoutObjectChildList* children = virtualChildren())
             return children->firstChild();
         return 0;
     }
-    RenderObject* slowLastChild() const
+    LayoutObject* slowLastChild() const
     {
-        if (const RenderObjectChildList* children = virtualChildren())
+        if (const LayoutObjectChildList* children = virtualChildren())
             return children->lastChild();
         return 0;
     }
 
-    virtual RenderObjectChildList* virtualChildren() { return 0; }
-    virtual const RenderObjectChildList* virtualChildren() const { return 0; }
+    virtual LayoutObjectChildList* virtualChildren() { return 0; }
+    virtual const LayoutObjectChildList* virtualChildren() const { return 0; }
 
-    RenderObject* nextInPreOrder() const;
-    RenderObject* nextInPreOrder(const RenderObject* stayWithin) const;
-    RenderObject* nextInPreOrderAfterChildren() const;
-    RenderObject* nextInPreOrderAfterChildren(const RenderObject* stayWithin) const;
-    RenderObject* previousInPreOrder() const;
-    RenderObject* previousInPreOrder(const RenderObject* stayWithin) const;
-    RenderObject* childAt(unsigned) const;
+    LayoutObject* nextInPreOrder() const;
+    LayoutObject* nextInPreOrder(const LayoutObject* stayWithin) const;
+    LayoutObject* nextInPreOrderAfterChildren() const;
+    LayoutObject* nextInPreOrderAfterChildren(const LayoutObject* stayWithin) const;
+    LayoutObject* previousInPreOrder() const;
+    LayoutObject* previousInPreOrder(const LayoutObject* stayWithin) const;
+    LayoutObject* childAt(unsigned) const;
 
-    RenderObject* lastLeafChild() const;
+    LayoutObject* lastLeafChild() const;
 
     // The following six functions are used when the render tree hierarchy changes to make sure layers get
     // properly added and removed.  Since containership can be implemented by any subclass, and since a hierarchy
     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
     Layer* enclosingLayer() const;
     void addLayers(Layer* parentLayer);
     void removeLayers(Layer* parentLayer);
     void moveLayers(Layer* oldParent, Layer* newParent);
-    Layer* findNextLayer(Layer* parentLayer, RenderObject* startPoint, bool checkParent = true);
+    Layer* findNextLayer(Layer* parentLayer, LayoutObject* startPoint, bool checkParent = true);
 
     // Scrolling is a RenderBox concept, however some code just cares about recursively scrolling our enclosing ScrollableArea(s).
     bool scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
 
-    // Convenience function for getting to the nearest enclosing box of a RenderObject.
+    // Convenience function for getting to the nearest enclosing box of a LayoutObject.
     RenderBox* enclosingBox() const;
     RenderBoxModelObject* enclosingBoxModelObject() const;
 
     RenderBox* enclosingScrollableBox() const;
 
     // Function to return our enclosing flow thread if we are contained inside one. This
     // function follows the containing block chain.
     RenderFlowThread* flowThreadContainingBlock() const
     {
         if (flowThreadState() == NotInsideFlowThread)
             return 0;
         return locateFlowThreadContainingBlock();
     }
 
 #if ENABLE(ASSERT)
     void setHasAXObject(bool flag) { m_hasAXObject = flag; }
     bool hasAXObject() const { return m_hasAXObject; }
 
     // Helper class forbidding calls to setNeedsLayout() during its lifetime.
     class SetLayoutNeededForbiddenScope {
     public:
-        explicit SetLayoutNeededForbiddenScope(RenderObject&);
+        explicit SetLayoutNeededForbiddenScope(LayoutObject&);
         ~SetLayoutNeededForbiddenScope();
     private:
-        RenderObject& m_renderObject;
+        LayoutObject& m_layoutObject;
         bool m_preexistingForbidden;
     };
 
     void assertRendererLaidOut() const
     {
 #ifndef NDEBUG
         if (needsLayout())
             showRenderTreeForThis();
 #endif
         ASSERT_WITH_SECURITY_IMPLICATION(!needsLayout());
     }
 
     void assertSubtreeIsLaidOut() const
     {
-        for (const RenderObject* renderer = this; renderer; renderer = renderer->nextInPreOrder())
+        for (const LayoutObject* renderer = this; renderer; renderer = renderer->nextInPreOrder())
             renderer->assertRendererLaidOut();
     }
 
     void assertRendererClearedPaintInvalidationState() const
     {
 #ifndef NDEBUG
         if (paintInvalidationStateIsDirty()) {
             showRenderTreeForThis();
             ASSERT_NOT_REACHED();
         }
 #endif
     }
 
     void assertSubtreeClearedPaintInvalidationState() const
     {
-        for (const RenderObject* renderer = this; renderer; renderer = renderer->nextInPreOrder())
+        for (const LayoutObject* renderer = this; renderer; renderer = renderer->nextInPreOrder())
             renderer->assertRendererClearedPaintInvalidationState();
     }
 
 #endif
 
     // FIXME: This could be used when changing the size of a renderer without children to skip some invalidations.
     bool rendererHasNoBoxEffect() const
     {
         return !style()->hasVisualOverflowingEffect() && !style()->hasBorder() && !style()->hasBackground();
     }
 
     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
     // children.
     virtual RenderBlock* firstLineBlock() const;
 
     // Called when an object that was floating or positioned becomes a normal flow object
     // again.  We have to make sure the render tree updates as needed to accommodate the new
     // normal flow object.
     void handleDynamicFloatPositionChange();
 
-    // RenderObject tree manipulation
+    // LayoutObject tree manipulation
     //////////////////////////////////////////
     virtual bool canHaveChildren() const { return virtualChildren(); }
     virtual bool canHaveGeneratedChildren() const;
-    virtual bool isChildAllowed(RenderObject*, const RenderStyle&) const { return true; }
-    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
-    virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) { return addChild(newChild, beforeChild); }
-    virtual void removeChild(RenderObject*);
+    virtual bool isChildAllowed(LayoutObject*, const RenderStyle&) const { return true; }
+    virtual void addChild(LayoutObject* newChild, LayoutObject* beforeChild = 0);
+    virtual void addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild = 0) { return addChild(newChild, beforeChild); }
+    virtual void removeChild(LayoutObject*);
     virtual bool createsAnonymousWrapper() const { return false; }
     //////////////////////////////////////////
 
 protected:
     //////////////////////////////////////////
     // Helper functions. Dangerous to use!
-    void setPreviousSibling(RenderObject* previous) { m_previous = previous; }
-    void setNextSibling(RenderObject* next) { m_next = next; }
-    void setParent(RenderObject* parent)
+    void setPreviousSibling(LayoutObject* previous) { m_previous = previous; }
+    void setNextSibling(LayoutObject* next) { m_next = next; }
+    void setParent(LayoutObject* parent)
     {
         m_parent = parent;
 
         // Only update if our flow thread state is different from our new parent and if we're not a RenderFlowThread.
         // A RenderFlowThread is always considered to be inside itself, so it never has to change its state
         // in response to parent changes.
         FlowThreadState newState = parent ? parent->flowThreadState() : NotInsideFlowThread;
         if (newState != flowThreadState() && !isRenderFlowThread())
             setFlowThreadStateIncludingDescendants(newState);
     }
 
     //////////////////////////////////////////
 private:
 #if ENABLE(ASSERT)
     bool isSetNeedsLayoutForbidden() const { return m_setNeedsLayoutForbidden; }
     void setNeedsLayoutIsForbidden(bool flag) { m_setNeedsLayoutForbidden = flag; }
 #endif
 
     void addAbsoluteRectForLayer(LayoutRect& result);
-    bool requiresAnonymousTableWrappers(const RenderObject*) const;
+    bool requiresAnonymousTableWrappers(const LayoutObject*) const;
 
     // Gets pseudoStyle from Shadow host(in case of input elements)
     // or from Parent element.
     PassRefPtr<RenderStyle> getUncachedPseudoStyleFromParentOrShadowHost() const;
 
     bool skipInvalidationWhenLaidOutChildren() const;
 
 public:
 #ifndef NDEBUG
     void showTreeForThis() const;
     void showRenderTreeForThis() const;
     void showLineTreeForThis() const;
 
-    void showRenderObject() const;
+    void showLayoutObject() const;
     // We don't make printedCharacters an optional parameter so that
-    // showRenderObject can be called from gdb easily.
-    void showRenderObject(int printedCharacters) const;
-    void showRenderTreeAndMark(const RenderObject* markedObject1 = 0, const char* markedLabel1 = 0, const RenderObject* markedObject2 = 0, const char* markedLabel2 = 0, int depth = 0) const;
+    // showLayoutObject can be called from gdb easily.
+    void showLayoutObject(int printedCharacters) const;
+    void showRenderTreeAndMark(const LayoutObject* markedObject1 = 0, const char* markedLabel1 = 0, const LayoutObject* markedObject2 = 0, const char* markedLabel2 = 0, int depth = 0) const;
 #endif
 
-    static RenderObject* createObject(Element*, const RenderStyle&);
+    static LayoutObject* createObject(Element*, const RenderStyle&);
     static unsigned instanceCount() { return s_instanceCount; }
 
-    // RenderObjects are allocated out of the rendering partition.
+    // LayoutObjects are allocated out of the rendering partition.
     void* operator new(size_t);
     void operator delete(void*);
 
 public:
     bool isPseudoElement() const { return node() && node()->isPseudoElement(); }
 
     virtual bool isBoxModelObject() const { return false; }
-    bool isBR() const { return isOfType(RenderObjectBr); }
-    bool isCanvas() const { return isOfType(RenderObjectCanvas); }
-    bool isCounter() const { return isOfType(RenderObjectCounter); }
-    bool isDetailsMarker() const { return isOfType(RenderObjectDetailsMarker); }
-    bool isEmbeddedObject() const { return isOfType(RenderObjectEmbeddedObject); }
-    bool isFieldset() const { return isOfType(RenderObjectFieldset); }
-    bool isFileUploadControl() const { return isOfType(RenderObjectFileUploadControl); }
-    bool isFrame() const { return isOfType(RenderObjectFrame); }
-    bool isFrameSet() const { return isOfType(RenderObjectFrameSet); }
-    bool isLayoutTableCol() const { return isOfType(RenderObjectLayoutTableCol); }
-    bool isListBox() const { return isOfType(RenderObjectListBox); }
-    bool isListItem() const { return isOfType(RenderObjectListItem); }
-    bool isListMarker() const { return isOfType(RenderObjectListMarker); }
-    bool isMedia() const { return isOfType(RenderObjectMedia); }
-    bool isMenuList() const { return isOfType(RenderObjectMenuList); }
-    bool isMeter() const { return isOfType(RenderObjectMeter); }
-    bool isProgress() const { return isOfType(RenderObjectProgress); }
-    bool isQuote() const { return isOfType(RenderObjectQuote); }
-    bool isRenderButton() const { return isOfType(RenderObjectRenderButton); }
-    bool isRenderFullScreen() const { return isOfType(RenderObjectRenderFullScreen); }
-    bool isRenderFullScreenPlaceholder() const { return isOfType(RenderObjectRenderFullScreenPlaceholder); }
-    bool isRenderGrid() const { return isOfType(RenderObjectRenderGrid); }
-    bool isRenderIFrame() const { return isOfType(RenderObjectRenderIFrame); }
-    bool isRenderImage() const { return isOfType(RenderObjectRenderImage); }
-    bool isRenderMultiColumnSet() const { return isOfType(RenderObjectRenderMultiColumnSet); }
-    bool isRenderMultiColumnSpannerPlaceholder() const { return isOfType(RenderObjectRenderMultiColumnSpannerPlaceholder); }
-    bool isRenderRegion() const { return isOfType(RenderObjectRenderRegion); }
-    bool isRenderScrollbarPart() const { return isOfType(RenderObjectRenderScrollbarPart); }
-    bool isRenderView() const { return isOfType(RenderObjectRenderView); }
-    bool isReplica() const { return isOfType(RenderObjectReplica); }
-    bool isRuby() const { return isOfType(RenderObjectRuby); }
-    bool isRubyBase() const { return isOfType(RenderObjectRubyBase); }
-    bool isRubyRun() const { return isOfType(RenderObjectRubyRun); }
-    bool isRubyText() const { return isOfType(RenderObjectRubyText); }
-    bool isSlider() const { return isOfType(RenderObjectSlider); }
-    bool isSliderThumb() const { return isOfType(RenderObjectSliderThumb); }
-    bool isTable() const { return isOfType(RenderObjectTable); }
-    bool isTableCaption() const { return isOfType(RenderObjectTableCaption); }
-    bool isTableCell() const { return isOfType(RenderObjectTableCell); }
-    bool isTableRow() const { return isOfType(RenderObjectTableRow); }
-    bool isTableSection() const { return isOfType(RenderObjectTableSection); }
-    bool isTextArea() const { return isOfType(RenderObjectTextArea); }
-    bool isTextControl() const { return isOfType(RenderObjectTextControl); }
-    bool isTextField() const { return isOfType(RenderObjectTextField); }
-    bool isVideo() const { return isOfType(RenderObjectVideo); }
-    bool isWidget() const { return isOfType(RenderObjectWidget); }
+    bool isBR() const { return isOfType(LayoutObjectBr); }
+    bool isCanvas() const { return isOfType(LayoutObjectCanvas); }
+    bool isCounter() const { return isOfType(LayoutObjectCounter); }
+    bool isDetailsMarker() const { return isOfType(LayoutObjectDetailsMarker); }
+    bool isEmbeddedObject() const { return isOfType(LayoutObjectEmbeddedObject); }
+    bool isFieldset() const { return isOfType(LayoutObjectFieldset); }
+    bool isFileUploadControl() const { return isOfType(LayoutObjectFileUploadControl); }
+    bool isFrame() const { return isOfType(LayoutObjectFrame); }
+    bool isFrameSet() const { return isOfType(LayoutObjectFrameSet); }
+    bool isLayoutTableCol() const { return isOfType(LayoutObjectLayoutTableCol); }
+    bool isListBox() const { return isOfType(LayoutObjectListBox); }
+    bool isListItem() const { return isOfType(LayoutObjectListItem); }
+    bool isListMarker() const { return isOfType(LayoutObjectListMarker); }
+    bool isMedia() const { return isOfType(LayoutObjectMedia); }
+    bool isMenuList() const { return isOfType(LayoutObjectMenuList); }
+    bool isMeter() const { return isOfType(LayoutObjectMeter); }
+    bool isProgress() const { return isOfType(LayoutObjectProgress); }
+    bool isQuote() const { return isOfType(LayoutObjectQuote); }
+    bool isRenderButton() const { return isOfType(LayoutObjectRenderButton); }
+    bool isRenderFullScreen() const { return isOfType(LayoutObjectRenderFullScreen); }
+    bool isRenderFullScreenPlaceholder() const { return isOfType(LayoutObjectRenderFullScreenPlaceholder); }
+    bool isRenderGrid() const { return isOfType(LayoutObjectRenderGrid); }
+    bool isRenderIFrame() const { return isOfType(LayoutObjectRenderIFrame); }
+    bool isRenderImage() const { return isOfType(LayoutObjectRenderImage); }
+    bool isRenderMultiColumnSet() const { return isOfType(LayoutObjectRenderMultiColumnSet); }
+    bool isRenderMultiColumnSpannerPlaceholder() const { return isOfType(LayoutObjectRenderMultiColumnSpannerPlaceholder); }
+    bool isRenderRegion() const { return isOfType(LayoutObjectRenderRegion); }
+    bool isRenderScrollbarPart() const { return isOfType(LayoutObjectRenderScrollbarPart); }
+    bool isRenderView() const { return isOfType(LayoutObjectRenderView); }
+    bool isReplica() const { return isOfType(LayoutObjectReplica); }
+    bool isRuby() const { return isOfType(LayoutObjectRuby); }
+    bool isRubyBase() const { return isOfType(LayoutObjectRubyBase); }
+    bool isRubyRun() const { return isOfType(LayoutObjectRubyRun); }
+    bool isRubyText() const { return isOfType(LayoutObjectRubyText); }
+    bool isSlider() const { return isOfType(LayoutObjectSlider); }
+    bool isSliderThumb() const { return isOfType(LayoutObjectSliderThumb); }
+    bool isTable() const { return isOfType(LayoutObjectTable); }
+    bool isTableCaption() const { return isOfType(LayoutObjectTableCaption); }
+    bool isTableCell() const { return isOfType(LayoutObjectTableCell); }
+    bool isTableRow() const { return isOfType(LayoutObjectTableRow); }
+    bool isTableSection() const { return isOfType(LayoutObjectTableSection); }
+    bool isTextArea() const { return isOfType(LayoutObjectTextArea); }
+    bool isTextControl() const { return isOfType(LayoutObjectTextControl); }
+    bool isTextField() const { return isOfType(LayoutObjectTextField); }
+    bool isVideo() const { return isOfType(LayoutObjectVideo); }
+    bool isWidget() const { return isOfType(LayoutObjectWidget); }
 
     virtual bool isImage() const { return false; }
 
     virtual bool isInlineBlockOrInlineTable() const { return false; }
     virtual bool isLayoutLayerModelObject() const { return false; }
     virtual bool isRenderBlock() const { return false; }
     virtual bool isRenderBlockFlow() const { return false; }
     virtual bool isRenderFlowThread() const { return false; }
     virtual bool isRenderInline() const { return false; }
     virtual bool isRenderPart() const { return false; }
 
     bool isDocumentElement() const { return document().documentElement() == m_node; }
     // isBody is called from RenderBox::styleWillChange and is thus quite hot.
     bool isBody() const { return node() && node()->hasTagName(HTMLNames::bodyTag); }
     bool isHR() const;
     bool isLegend() const;
 
     bool isTablePart() const { return isTableCell() || isLayoutTableCol() || isTableCaption() || isTableRow() || isTableSection(); }
 
     inline bool isBeforeContent() const;
     inline bool isAfterContent() const;
     inline bool isBeforeOrAfterContent() const;
-    static inline bool isAfterContent(const RenderObject* obj) { return obj && obj->isAfterContent(); }
+    static inline bool isAfterContent(const LayoutObject* obj) { return obj && obj->isAfterContent(); }
 
     bool hasCounterNodeMap() const { return m_bitfields.hasCounterNodeMap(); }
     void setHasCounterNodeMap(bool hasCounterNodeMap) { m_bitfields.setHasCounterNodeMap(hasCounterNodeMap); }
     bool everHadLayout() const { return m_bitfields.everHadLayout(); }
 
     bool childrenInline() const { return m_bitfields.childrenInline(); }
     void setChildrenInline(bool b) { m_bitfields.setChildrenInline(b); }
     bool hasColumns() const { return m_bitfields.hasColumns(); }
     void setHasColumns(bool b = true) { m_bitfields.setHasColumns(b); }
 
@@ skipping 21 matching lines @@
         InsideOutOfFlowThread = 1,
         InsideInFlowThread = 2,
     };
 
     void setFlowThreadStateIncludingDescendants(FlowThreadState);
 
     FlowThreadState flowThreadState() const { return m_bitfields.flowThreadState(); }
     void setFlowThreadState(FlowThreadState state) { m_bitfields.setFlowThreadState(state); }
 
     // FIXME: Until all SVG renders can be subclasses of RenderSVGModelObject we have
-    // to add SVG renderer methods to RenderObject with an ASSERT_NOT_REACHED() default implementation.
-    bool isSVG() const { return isOfType(RenderObjectSVG); }
-    bool isSVGRoot() const { return isOfType(RenderObjectSVGRoot); }
-    bool isSVGContainer() const { return isOfType(RenderObjectSVGContainer); }
-    bool isSVGTransformableContainer() const { return isOfType(RenderObjectSVGTransformableContainer); }
-    bool isSVGViewportContainer() const { return isOfType(RenderObjectSVGViewportContainer); }
-    bool isSVGGradientStop() const { return isOfType(RenderObjectSVGGradientStop); }
-    bool isSVGHiddenContainer() const { return isOfType(RenderObjectSVGHiddenContainer); }
-    bool isSVGShape() const { return isOfType(RenderObjectSVGShape); }
-    bool isSVGText() const { return isOfType(RenderObjectSVGText); }
-    bool isSVGTextPath() const { return isOfType(RenderObjectSVGTextPath); }
-    bool isSVGInline() const { return isOfType(RenderObjectSVGInline); }
-    bool isSVGInlineText() const { return isOfType(RenderObjectSVGInlineText); }
-    bool isSVGImage() const { return isOfType(RenderObjectSVGImage); }
-    bool isSVGForeignObject() const { return isOfType(RenderObjectSVGForeignObject); }
-    bool isSVGResourceContainer() const { return isOfType(RenderObjectSVGResourceContainer); }
-    bool isSVGResourceFilter() const { return isOfType(RenderObjectSVGResourceFilter); }
-    bool isSVGResourceFilterPrimitive() const { return isOfType(RenderObjectSVGResourceFilterPrimitive); }
+    // to add SVG renderer methods to LayoutObject with an ASSERT_NOT_REACHED() default implementation.
+    bool isSVG() const { return isOfType(LayoutObjectSVG); }
+    bool isSVGRoot() const { return isOfType(LayoutObjectSVGRoot); }
+    bool isSVGContainer() const { return isOfType(LayoutObjectSVGContainer); }
+    bool isSVGTransformableContainer() const { return isOfType(LayoutObjectSVGTransformableContainer); }
+    bool isSVGViewportContainer() const { return isOfType(LayoutObjectSVGViewportContainer); }
+    bool isSVGGradientStop() const { return isOfType(LayoutObjectSVGGradientStop); }
+    bool isSVGHiddenContainer() const { return isOfType(LayoutObjectSVGHiddenContainer); }
+    bool isSVGShape() const { return isOfType(LayoutObjectSVGShape); }
+    bool isSVGText() const { return isOfType(LayoutObjectSVGText); }
+    bool isSVGTextPath() const { return isOfType(LayoutObjectSVGTextPath); }
+    bool isSVGInline() const { return isOfType(LayoutObjectSVGInline); }
+    bool isSVGInlineText() const { return isOfType(LayoutObjectSVGInlineText); }
+    bool isSVGImage() const { return isOfType(LayoutObjectSVGImage); }
+    bool isSVGForeignObject() const { return isOfType(LayoutObjectSVGForeignObject); }
+    bool isSVGResourceContainer() const { return isOfType(LayoutObjectSVGResourceContainer); }
+    bool isSVGResourceFilter() const { return isOfType(LayoutObjectSVGResourceFilter); }
+    bool isSVGResourceFilterPrimitive() const { return isOfType(LayoutObjectSVGResourceFilterPrimitive); }
 
     // FIXME: Those belong into a SVG specific base-class for all renderers (see above)
     // Unfortunately we don't have such a class yet, because it's not possible for all renderers
-    // to inherit from RenderSVGObject -> RenderObject (some need RenderBlock inheritance for instance)
+    // to inherit from RenderSVGObject -> LayoutObject (some need RenderBlock inheritance for instance)
     virtual void setNeedsTransformUpdate() { }
     virtual void setNeedsBoundariesUpdate();
 
     bool isBlendingAllowed() const { return !isSVG() || (isSVGContainer() && !isSVGHiddenContainer()) || isSVGShape() || isSVGImage() || isSVGText(); }
     virtual bool hasNonIsolatedBlendingDescendants() const { return false; }
     enum DescendantIsolationState {
         DescendantIsolationRequired,
         DescendantIsolationNeedsUpdate,
     };
     virtual void descendantIsolationRequirementsChanged(DescendantIsolationState) { }
@@ skipping 154 matching lines @@
 
     Document& document() const { return m_node->document(); }
     LocalFrame* frame() const { return document().frame(); }
 
     virtual RenderMultiColumnSpannerPlaceholder* spannerPlaceholder() const { return 0; }
     bool isColumnSpanAll() const { return style()->columnSpan() == ColumnSpanAll && spannerPlaceholder(); }
 
     // Returns the object containing this one. Can be different from parent for positioned elements.
     // If paintInvalidationContainer and paintInvalidationContainerSkipped are not null, on return *paintInvalidationContainerSkipped
     // is true if the renderer returned is an ancestor of paintInvalidationContainer.
-    RenderObject* container(const LayoutLayerModelObject* paintInvalidationContainer = 0, bool* paintInvalidationContainerSkipped = 0) const;
+    LayoutObject* container(const LayoutLayerModelObject* paintInvalidationContainer = 0, bool* paintInvalidationContainerSkipped = 0) const;
     RenderBlock* containerForFixedPosition(const LayoutLayerModelObject* paintInvalidationContainer = 0, bool* paintInvalidationContainerSkipped = 0) const;
 
-    virtual RenderObject* hoverAncestor() const { return parent(); }
+    virtual LayoutObject* hoverAncestor() const { return parent(); }
 
     Element* offsetParent() const;
 
-    void markContainingBlocksForLayout(bool scheduleRelayout = true, RenderObject* newRoot = 0, SubtreeLayoutScope* = 0);
+    void markContainingBlocksForLayout(bool scheduleRelayout = true, LayoutObject* newRoot = 0, SubtreeLayoutScope* = 0);
     void setNeedsLayout(MarkingBehavior = MarkContainingBlockChain, SubtreeLayoutScope* = 0);
     void setNeedsLayoutAndFullPaintInvalidation(MarkingBehavior = MarkContainingBlockChain, SubtreeLayoutScope* = 0);
     void clearNeedsLayout();
     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain, SubtreeLayoutScope* = 0);
     void setNeedsPositionedMovementLayout();
     void setPreferredLogicalWidthsDirty(MarkingBehavior = MarkContainingBlockChain);
     void clearPreferredLogicalWidthsDirty();
     void invalidateContainerPreferredLogicalWidths();
 
     void setNeedsLayoutAndPrefWidthsRecalc()
@@ skipping 40 matching lines @@
     virtual void paint(const PaintInfo&, const LayoutPoint& paintOffset);
 
     // Subclasses must reimplement this method to compute the size and position
     // of this object and all its descendants.
     virtual void layout() = 0;
     virtual bool updateImageLoadingPriorities() { return false; }
     void setHasPendingResourceUpdate(bool hasPendingResourceUpdate) { m_bitfields.setHasPendingResourceUpdate(hasPendingResourceUpdate); }
     bool hasPendingResourceUpdate() const { return m_bitfields.hasPendingResourceUpdate(); }
 
     /* This function performs a layout only if one is needed. */
-    void layoutIfNeeded() { if (needsLayout()) layout(); }
+    void layoutIfNeeded()
+    {
+        if (needsLayout())
+            layout();
+    }
 
     void forceLayout();
     void forceChildLayout();
 
     // Used for element state updates that cannot be fixed with a
     // paint invalidation and do not need a relayout.
     virtual void updateFromElement() { }
 
     virtual void addAnnotatedRegions(Vector<AnnotatedRegionValue>&);
     void collectAnnotatedRegions(Vector<AnnotatedRegionValue>&);
 
     CompositingState compositingState() const;
     virtual CompositingReasons additionalCompositingReasons() const;
 
     bool hitTest(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestFilter = HitTestAll);
     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&);
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 
     virtual PositionWithAffinity positionForPoint(const LayoutPoint&);
     PositionWithAffinity createPositionWithAffinity(int offset, EAffinity);
     PositionWithAffinity createPositionWithAffinity(const Position&);
 
-    virtual void dirtyLinesFromChangedChild(RenderObject*);
+    virtual void dirtyLinesFromChangedChild(LayoutObject*);
 
     // Set the style of the object and update the state of the object accordingly.
     void setStyle(PassRefPtr<RenderStyle>);
 
     // Set the style of the object if it's generated content.
     void setPseudoStyle(PassRefPtr<RenderStyle>);
 
     // Updates only the local style ptr of the object.  Does not update the state of the object,
     // and so only should be called when the style is known not to have changed (or from setStyle).
     void setStyleInternal(PassRefPtr<RenderStyle> style) { m_style = style; }
@@ skipping 21 matching lines @@
 
     // Convert a local quad into the coordinate system of container, taking transforms into account.
     FloatQuad localToContainerQuad(const FloatQuad&, const LayoutLayerModelObject* paintInvalidatinoContainer, MapCoordinatesFlags = 0, bool* wasFixed = 0) const;
     FloatPoint localToContainerPoint(const FloatPoint&, const LayoutLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags = 0, bool* wasFixed = 0, const PaintInvalidationState* = 0) const;
 
     // Convert a local point into the coordinate system of backing coordinates. Also returns the backing layer if needed.
     FloatPoint localToInvalidationBackingPoint(const LayoutPoint&, Layer** backingLayer = nullptr);
 
     // Return the offset from the container() renderer (excluding transforms). In multi-column layout,
     // different offsets apply at different points, so return the offset that applies to the given point.
-    virtual LayoutSize offsetFromContainer(const RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
+    virtual LayoutSize offsetFromContainer(const LayoutObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
     // Return the offset from an object up the container() chain. Asserts that none of the intermediate objects have transforms.
-    LayoutSize offsetFromAncestorContainer(const RenderObject*) const;
+    LayoutSize offsetFromAncestorContainer(const LayoutObject*) const;
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint&) const { }
 
     IntRect absoluteBoundingBoxRect() const;
     // FIXME: This function should go away eventually
     IntRect absoluteBoundingBoxRectIgnoringTransforms() const;
 
     // Build an array of quads in absolute coords for line boxes
     virtual void absoluteQuads(Vector<FloatQuad>&, bool* /*wasFixed*/ = 0) const { }
 
     virtual IntRect absoluteFocusRingBoundingBoxRect() const;
 
     static FloatRect absoluteBoundingBoxRectForRange(const Range*);
 
     // the rect that will be painted if this object is passed as the paintingRoot
     LayoutRect paintingRootRect(LayoutRect& topLevelRect);
 
     virtual LayoutUnit minPreferredLogicalWidth() const { return 0; }
     virtual LayoutUnit maxPreferredLogicalWidth() const { return 0; }
 
     RenderStyle* style() const { return m_style.get(); }
 
     // m_style can only be nullptr before the first style is set, thus most
     // callers will never see a nullptr style and should use styleRef().
     // FIXME: It would be better if style() returned a const reference.
     const RenderStyle& styleRef() const { return mutableStyleRef(); }
     RenderStyle& mutableStyleRef() const { ASSERT(m_style); return *m_style; }
 
-    /* The following methods are inlined in RenderObjectInlines.h */
+    /* The following methods are inlined in LayoutObjectInlines.h */
     RenderStyle* firstLineStyle() const;
     RenderStyle* style(bool firstLine) const;
     const RenderStyle& styleRef(bool firstLine) const;
 
     static inline Color resolveColor(const RenderStyle& styleToUse, int colorProperty)
     {
         return styleToUse.visitedDependentColor(colorProperty);
     }
 
     inline Color resolveColor(int colorProperty) const
@@ skipping 20 matching lines @@
     // methods.
     const LayoutLayerModelObject* containerForPaintInvalidation() const;
     const LayoutLayerModelObject* adjustCompositedContainerForSpecialAncestors(const LayoutLayerModelObject* paintInvalidationContainer) const;
     bool isPaintInvalidationContainer() const;
 
     LayoutRect computePaintInvalidationRect()
     {
         return computePaintInvalidationRect(containerForPaintInvalidation());
     }
 
-    // Returns the paint invalidation rect for this RenderObject in the coordinate space of the paint backing (typically a GraphicsLayer) for |paintInvalidationContainer|.
+    // Returns the paint invalidation rect for this LayoutObject in the coordinate space of the paint backing (typically a GraphicsLayer) for |paintInvalidationContainer|.
     LayoutRect computePaintInvalidationRect(const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0) const;
 
     // Returns the rect bounds needed to invalidate the paint of this object, in the coordinate space of the rendering backing of |paintInvalidationContainer|
     LayoutRect boundsRectForPaintInvalidation(const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0) const;
 
     // Actually do the paint invalidate of rect r for this object which has been computed in the coordinate space
     // of the GraphicsLayer backing of |paintInvalidationContainer|. Note that this coordinaten space is not the same
     // as the local coordinate space of |paintInvalidationContainer| in the presence of layer squashing.
     // If |paintInvalidationContainer| is 0, invalidate paints via the view.
     // FIXME: |paintInvalidationContainer| should never be 0. See crbug.com/363699.
@@ skipping 101 matching lines @@
     virtual int previousOffsetForBackwardDeletion(int current) const;
     virtual int nextOffset(int current) const;
 
     virtual void imageChanged(ImageResource*, const IntRect* = 0) override final;
     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) { }
     virtual bool willRenderImage(ImageResource*) override final;
     virtual bool getImageAnimationPolicy(ImageResource*, ImageAnimationPolicy&) override final;
 
     void selectionStartEnd(int& spos, int& epos) const;
 
-    void remove() { if (parent()) parent()->removeChild(this); }
+    void remove()
+    {
+        if (parent())
+            parent()->removeChild(this);
+    }
 
     bool isInert() const;
 
     bool supportsTouchAction() const;
 
     bool visibleToHitTestRequest(const HitTestRequest& request) const { return style()->visibility() == VISIBLE && (request.ignorePointerEventsNone() || style()->pointerEvents() != PE_NONE) && !isInert(); }
 
     bool visibleToHitTesting() const { return style()->visibility() == VISIBLE && style()->pointerEvents() != PE_NONE && !isInert(); }
 
     // Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use
     // localToAbsolute/absoluteToLocal methods instead.
     virtual void mapLocalToContainer(const LayoutLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0, const PaintInvalidationState* = 0) const;
     virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const;
 
     // Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).
     // Returns the renderer which was mapped to (container or ancestorToStopAt).
-    virtual const RenderObject* pushMappingToContainer(const LayoutLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const;
+    virtual const LayoutObject* pushMappingToContainer(const LayoutLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const;
 
-    bool shouldUseTransformFromContainer(const RenderObject* container) const;
-    void getTransformFromContainer(const RenderObject* container, const LayoutSize& offsetInContainer, TransformationMatrix&) const;
+    bool shouldUseTransformFromContainer(const LayoutObject* container) const;
+    void getTransformFromContainer(const LayoutObject* container, const LayoutSize& offsetInContainer, TransformationMatrix&) const;
 
     bool createsGroup() const { return isTransparent() || hasMask() || hasFilter() || style()->hasBlendMode(); }
 
     virtual void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint& additionalOffset) const { }
 
     // Compute a list of hit-test rectangles per layer rooted at this renderer.
     virtual void computeLayerHitTestRects(LayerHitTestRects&) const;
 
     // Return the renderer whose background style is used to paint the root background. Should only be called on the renderer for which isDocumentElement() is true.
-    RenderObject* rendererForRootBackground();
+    LayoutObject* rendererForRootBackground();
 
     RespectImageOrientationEnum shouldRespectImageOrientation() const;
 
     bool isRelayoutBoundaryForInspector() const;
 
     // The previous paint invalidation rect in the object's previous paint backing.
     const LayoutRect& previousPaintInvalidationRect() const { return m_previousPaintInvalidationRect; }
     void setPreviousPaintInvalidationRect(const LayoutRect& rect) { m_previousPaintInvalidationRect = rect; }
 
     // The previous position of the top-left corner of the object in its previous paint backing.
@@ skipping 43 matching lines @@
     virtual bool supportsPaintInvalidationStateCachedOffsets() const { return !hasColumns() && !hasTransformRelatedProperty() && !hasReflection() && !style()->isFlippedBlocksWritingMode(); }
 
     void setNeedsOverflowRecalcAfterStyleChange();
     void markContainingBlocksForOverflowRecalc();
 
     virtual LayoutRect viewRect() const;
 
     DisplayItemClient displayItemClient() const { return toDisplayItemClient(this); }
 
 protected:
-    enum RenderObjectType {
-        RenderObjectBr,
-        RenderObjectCanvas,
-        RenderObjectFieldset,
-        RenderObjectCounter,
-        RenderObjectDetailsMarker,
-        RenderObjectEmbeddedObject,
-        RenderObjectFileUploadControl,
-        RenderObjectFrame,
-        RenderObjectFrameSet,
-        RenderObjectLayoutTableCol,
-        RenderObjectListBox,
-        RenderObjectListItem,
-        RenderObjectListMarker,
-        RenderObjectMedia,
-        RenderObjectMenuList,
-        RenderObjectMeter,
-        RenderObjectProgress,
-        RenderObjectQuote,
-        RenderObjectRenderButton,
-        RenderObjectRenderFlowThread,
-        RenderObjectRenderFullScreen,
-        RenderObjectRenderFullScreenPlaceholder,
-        RenderObjectRenderGrid,
-        RenderObjectRenderIFrame,
-        RenderObjectRenderImage,
-        RenderObjectRenderInline,
-        RenderObjectRenderMultiColumnSet,
-        RenderObjectRenderMultiColumnSpannerPlaceholder,
-        RenderObjectRenderPart,
-        RenderObjectRenderRegion,
-        RenderObjectRenderScrollbarPart,
-        RenderObjectRenderView,
-        RenderObjectReplica,
-        RenderObjectRuby,
-        RenderObjectRubyBase,
-        RenderObjectRubyRun,
-        RenderObjectRubyText,
-        RenderObjectSlider,
-        RenderObjectSliderThumb,
-        RenderObjectTable,
-        RenderObjectTableCaption,
-        RenderObjectTableCell,
-        RenderObjectTableRow,
-        RenderObjectTableSection,
-        RenderObjectTextArea,
-        RenderObjectTextControl,
-        RenderObjectTextField,
-        RenderObjectVideo,
-        RenderObjectWidget,
+    enum LayoutObjectType {
+        LayoutObjectBr,
+        LayoutObjectCanvas,
+        LayoutObjectFieldset,
+        LayoutObjectCounter,
+        LayoutObjectDetailsMarker,
+        LayoutObjectEmbeddedObject,
+        LayoutObjectFileUploadControl,
+        LayoutObjectFrame,
+        LayoutObjectFrameSet,
+        LayoutObjectLayoutTableCol,
+        LayoutObjectListBox,
+        LayoutObjectListItem,
+        LayoutObjectListMarker,
+        LayoutObjectMedia,
+        LayoutObjectMenuList,
+        LayoutObjectMeter,
+        LayoutObjectProgress,
+        LayoutObjectQuote,
+        LayoutObjectRenderButton,
+        LayoutObjectRenderFlowThread,
+        LayoutObjectRenderFullScreen,
+        LayoutObjectRenderFullScreenPlaceholder,
+        LayoutObjectRenderGrid,
+        LayoutObjectRenderIFrame,
+        LayoutObjectRenderImage,
+        LayoutObjectRenderInline,
+        LayoutObjectRenderMultiColumnSet,
+        LayoutObjectRenderMultiColumnSpannerPlaceholder,
+        LayoutObjectRenderPart,
+        LayoutObjectRenderRegion,
+        LayoutObjectRenderScrollbarPart,
+        LayoutObjectRenderView,
+        LayoutObjectReplica,
+        LayoutObjectRuby,
+        LayoutObjectRubyBase,
+        LayoutObjectRubyRun,
+        LayoutObjectRubyText,
+        LayoutObjectSlider,
+        LayoutObjectSliderThumb,
+        LayoutObjectTable,
+        LayoutObjectTableCaption,
+        LayoutObjectTableCell,
+        LayoutObjectTableRow,
+        LayoutObjectTableSection,
+        LayoutObjectTextArea,
+        LayoutObjectTextControl,
+        LayoutObjectTextField,
+        LayoutObjectVideo,
+        LayoutObjectWidget,
 
-        RenderObjectSVG, /* Keep by itself? */
-        RenderObjectSVGRoot,
-        RenderObjectSVGContainer,
-        RenderObjectSVGTransformableContainer,
-        RenderObjectSVGViewportContainer,
-        RenderObjectSVGHiddenContainer,
-        RenderObjectSVGGradientStop,
-        RenderObjectSVGShape,
-        RenderObjectSVGText,
-        RenderObjectSVGTextPath,
-        RenderObjectSVGInline,
-        RenderObjectSVGInlineText,
-        RenderObjectSVGImage,
-        RenderObjectSVGForeignObject,
-        RenderObjectSVGResourceContainer,
-        RenderObjectSVGResourceFilter,
-        RenderObjectSVGResourceFilterPrimitive,
+        LayoutObjectSVG, /* Keep by itself? */
+        LayoutObjectSVGRoot,
+        LayoutObjectSVGContainer,
+        LayoutObjectSVGTransformableContainer,
+        LayoutObjectSVGViewportContainer,
+        LayoutObjectSVGHiddenContainer,
+        LayoutObjectSVGGradientStop,
+        LayoutObjectSVGShape,
+        LayoutObjectSVGText,
+        LayoutObjectSVGTextPath,
+        LayoutObjectSVGInline,
+        LayoutObjectSVGInlineText,
+        LayoutObjectSVGImage,
+        LayoutObjectSVGForeignObject,
+        LayoutObjectSVGResourceContainer,
+        LayoutObjectSVGResourceFilter,
+        LayoutObjectSVGResourceFilterPrimitive,
     };
-    virtual bool isOfType(RenderObjectType type) const { return false; }
+    virtual bool isOfType(LayoutObjectType type) const { return false; }
 
     inline bool layerCreationAllowedForSubtree() const;
 
     // Overrides should call the superclass at the end. m_style will be 0 the first time
     // this function will be called.
     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle);
     // Overrides should call the superclass at the start. |oldStyle| will be 0 the first
     // time this function is called.
     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
     void propagateStyleToAnonymousChildren(bool blockChildrenOnly = false);
-    virtual void updateAnonymousChildStyle(const RenderObject* child, RenderStyle* style) const { }
+    virtual void updateAnonymousChildStyle(const LayoutObject* child, RenderStyle* style) const { }
 
 protected:
     void setSelfMayNeedPaintInvalidation();
 
     void clearLayoutRootIfNeeded() const;
     virtual void willBeDestroyed();
     void postDestroy();
 
     virtual void insertedIntoTree();
     virtual void willBeRemovedFromTree();
@@ skipping 70 matching lines @@
 
     void markContainingBlockChainForPaintInvalidation();
 
     static bool isAllowedToModifyRenderTreeStructure(Document&);
 
     RefPtr<RenderStyle> m_style;
 
     // Oilpan: raw pointer back to the owning Node is considered safe.
     Node* m_node;
 
-    RenderObject* m_parent;
-    RenderObject* m_previous;
-    RenderObject* m_next;
+    LayoutObject* m_parent;
+    LayoutObject* m_previous;
+    LayoutObject* m_next;
 
 #if ENABLE(ASSERT)
     unsigned m_hasAXObject             : 1;
     unsigned m_setNeedsLayoutForbidden : 1;
 #endif
 
 #define ADD_BOOLEAN_BITFIELD(name, Name) \
     private:\
         unsigned m_##name : 1;\
     public:\
         bool name() const { return m_##name; }\
         void set##Name(bool name) { m_##name = name; }\
 
-    class RenderObjectBitfields {
+    class LayoutObjectBitfields {
         enum PositionedState {
             IsStaticallyPositioned = 0,
             IsRelativelyPositioned = 1,
             IsOutOfFlowPositioned = 2,
         };
 
     public:
-        RenderObjectBitfields(Node* node)
+        LayoutObjectBitfields(Node* node)
             : m_selfNeedsLayout(false)
             , m_shouldInvalidateOverflowForPaint(false)
             // FIXME: We should remove mayNeedPaintInvalidation once we are able to
             // use the other layout flags to detect the same cases. crbug.com/370118
             , m_mayNeedPaintInvalidation(false)
             , m_shouldInvalidateSelection(false)
             , m_neededLayoutBecauseOfChildren(false)
             , m_needsPositionedMovementLayout(false)
             , m_normalChildNeedsLayout(false)
             , m_posChildNeedsLayout(false)
@@ skipping 99 matching lines @@
 
         ALWAYS_INLINE BoxDecorationBackgroundState boxDecorationBackgroundState() const { return static_cast<BoxDecorationBackgroundState>(m_boxDecorationBackgroundState); }
         ALWAYS_INLINE void setBoxDecorationBackgroundState(BoxDecorationBackgroundState s) { m_boxDecorationBackgroundState = s; }
 
         PaintInvalidationReason fullPaintInvalidationReason() const { return static_cast<PaintInvalidationReason>(m_fullPaintInvalidationReason); }
         void setFullPaintInvalidationReason(PaintInvalidationReason reason) { m_fullPaintInvalidationReason = reason; }
     };
 
 #undef ADD_BOOLEAN_BITFIELD
 
-    RenderObjectBitfields m_bitfields;
+    LayoutObjectBitfields m_bitfields;
 
     void setSelfNeedsLayout(bool b) { m_bitfields.setSelfNeedsLayout(b); }
     void setNeedsPositionedMovementLayout(bool b) { m_bitfields.setNeedsPositionedMovementLayout(b); }
     void setNormalChildNeedsLayout(bool b) { m_bitfields.setNormalChildNeedsLayout(b); }
     void setPosChildNeedsLayout(bool b) { m_bitfields.setPosChildNeedsLayout(b); }
     void setNeedsSimplifiedNormalFlowLayout(bool b) { m_bitfields.setNeedsSimplifiedNormalFlowLayout(b); }
     void setIsDragging(bool b) { m_bitfields.setIsDragging(b); }
     void setEverHadLayout(bool b) { m_bitfields.setEverHadLayout(b); }
     void setShouldInvalidateOverflowForPaint(bool b) { m_bitfields.setShouldInvalidateOverflowForPaint(b); }
     void setSelfNeedsOverflowRecalcAfterStyleChange(bool b) { m_bitfields.setSelfNeedsOverflowRecalcAfterStyleChange(b); }
@@ skipping 18 matching lines @@
     WTF_MAKE_NONCOPYABLE(DeprecatedDisableModifyRenderTreeStructureAsserts);
 public:
     DeprecatedDisableModifyRenderTreeStructureAsserts();
 
     static bool canModifyRenderTreeStateInAnyState();
 
 private:
     TemporaryChange<bool> m_disabler;
 };
 
-// Allow equality comparisons of RenderObjects by reference or pointer, interchangeably.
-DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(RenderObject)
+// Allow equality comparisons of LayoutObjects by reference or pointer, interchangeably.
+DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(LayoutObject)
 
-inline bool RenderObject::documentBeingDestroyed() const
+inline bool LayoutObject::documentBeingDestroyed() const
 {
     return document().lifecycle().state() >= DocumentLifecycle::Stopping;
 }
 
-inline bool RenderObject::isBeforeContent() const
+inline bool LayoutObject::isBeforeContent() const
 {
     if (style()->styleType() != BEFORE)
         return false;
     // Text nodes don't have their own styles, so ignore the style on a text node.
     if (isText() && !isBR())
         return false;
     return true;
 }
 
-inline bool RenderObject::isAfterContent() const
+inline bool LayoutObject::isAfterContent() const
 {
     if (style()->styleType() != AFTER)
         return false;
     // Text nodes don't have their own styles, so ignore the style on a text node.
     if (isText() && !isBR())
         return false;
     return true;
 }
 
-inline bool RenderObject::isBeforeOrAfterContent() const
+inline bool LayoutObject::isBeforeOrAfterContent() const
 {
     return isBeforeContent() || isAfterContent();
 }
 
 // setNeedsLayout() won't cause full paint invalidations as
 // setNeedsLayoutAndFullPaintInvalidation() does. Otherwise the two methods are identical.
-inline void RenderObject::setNeedsLayout(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
+inline void LayoutObject::setNeedsLayout(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
 {
     TRACE_EVENT_INSTANT1(
         TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "LayoutInvalidationTracking",
         "data",
         InspectorLayoutInvalidationTrackingEvent::data(this));
     ASSERT(!isSetNeedsLayoutForbidden());
     bool alreadyNeededLayout = m_bitfields.selfNeedsLayout();
     setSelfNeedsLayout(true);
     if (!alreadyNeededLayout) {
         if (markParents == MarkContainingBlockChain && (!layouter || layouter->root() != this))
             markContainingBlocksForLayout(true, 0, layouter);
     }
 }
 
-inline void RenderObject::setNeedsLayoutAndFullPaintInvalidation(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
+inline void LayoutObject::setNeedsLayoutAndFullPaintInvalidation(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
 {
     setNeedsLayout(markParents, layouter);
     setShouldDoFullPaintInvalidation();
 }
 
-inline void RenderObject::clearNeedsLayout()
+inline void LayoutObject::clearNeedsLayout()
 {
     setNeededLayoutBecauseOfChildren(needsLayoutBecauseOfChildren());
     setLayoutDidGetCalledSinceLastFrame();
     setSelfNeedsLayout(false);
     setEverHadLayout(true);
     setPosChildNeedsLayout(false);
     setNeedsSimplifiedNormalFlowLayout(false);
     setNormalChildNeedsLayout(false);
     setNeedsPositionedMovementLayout(false);
     setAncestorLineBoxDirty(false);
 #if ENABLE(ASSERT)
     checkBlockPositionedObjectsNeedLayout();
 #endif
 }
 
-inline void RenderObject::setChildNeedsLayout(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
+inline void LayoutObject::setChildNeedsLayout(MarkingBehavior markParents, SubtreeLayoutScope* layouter)
 {
     ASSERT(!isSetNeedsLayoutForbidden());
     bool alreadyNeededLayout = normalChildNeedsLayout();
     setNormalChildNeedsLayout(true);
     // FIXME: Replace MarkOnlyThis with the SubtreeLayoutScope code path and remove the MarkingBehavior argument entirely.
     if (!alreadyNeededLayout && markParents == MarkContainingBlockChain && (!layouter || layouter->root() != this))
         markContainingBlocksForLayout(true, 0, layouter);
 }
 
-inline void RenderObject::setNeedsPositionedMovementLayout()
+inline void LayoutObject::setNeedsPositionedMovementLayout()
 {
     bool alreadyNeededLayout = needsPositionedMovementLayout();
     setNeedsPositionedMovementLayout(true);
     ASSERT(!isSetNeedsLayoutForbidden());
     if (!alreadyNeededLayout)
         markContainingBlocksForLayout();
 }
 
-inline bool RenderObject::preservesNewline() const
+inline bool LayoutObject::preservesNewline() const
 {
     if (isSVGInlineText())
         return false;
 
     return style()->preserveNewline();
 }
 
-inline bool RenderObject::layerCreationAllowedForSubtree() const
+inline bool LayoutObject::layerCreationAllowedForSubtree() const
 {
-    RenderObject* parentRenderer = parent();
+    LayoutObject* parentRenderer = parent();
     while (parentRenderer) {
         if (parentRenderer->isSVGHiddenContainer())
             return false;
         parentRenderer = parentRenderer->parent();
     }
 
     return true;
 }
 
-inline void RenderObject::setSelectionStateIfNeeded(SelectionState state)
+inline void LayoutObject::setSelectionStateIfNeeded(SelectionState state)
 {
     if (selectionState() == state)
         return;
 
     setSelectionState(state);
 }
 
-inline void RenderObject::setHasBoxDecorationBackground(bool b)
+inline void LayoutObject::setHasBoxDecorationBackground(bool b)
 {
     if (!b) {
         m_bitfields.setBoxDecorationBackgroundState(NoBoxDecorationBackground);
         return;
     }
     if (hasBoxDecorationBackground())
         return;
     m_bitfields.setBoxDecorationBackgroundState(HasBoxDecorationBackgroundObscurationStatusInvalid);
 }
 
-inline void RenderObject::invalidateBackgroundObscurationStatus()
+inline void LayoutObject::invalidateBackgroundObscurationStatus()
 {
     if (!hasBoxDecorationBackground())
         return;
     m_bitfields.setBoxDecorationBackgroundState(HasBoxDecorationBackgroundObscurationStatusInvalid);
 }
 
-inline bool RenderObject::boxDecorationBackgroundIsKnownToBeObscured()
+inline bool LayoutObject::boxDecorationBackgroundIsKnownToBeObscured()
 {
     if (m_bitfields.boxDecorationBackgroundState() == HasBoxDecorationBackgroundObscurationStatusInvalid) {
         BoxDecorationBackgroundState state = computeBackgroundIsKnownToBeObscured() ? HasBoxDecorationBackgroundKnownToBeObscured : HasBoxDecorationBackgroundMayBeVisible;
         m_bitfields.setBoxDecorationBackgroundState(state);
     }
     return m_bitfields.boxDecorationBackgroundState() == HasBoxDecorationBackgroundKnownToBeObscured;
 }
 
 inline void makeMatrixRenderable(TransformationMatrix& matrix, bool has3DRendering)
 {
     if (!has3DRendering)
         matrix.makeAffine();
 }
 
-inline int adjustForAbsoluteZoom(int value, RenderObject* renderer)
+inline int adjustForAbsoluteZoom(int value, LayoutObject* renderer)
 {
     return adjustForAbsoluteZoom(value, renderer->style());
 }
 
-inline double adjustDoubleForAbsoluteZoom(double value, RenderObject& renderer)
+inline double adjustDoubleForAbsoluteZoom(double value, LayoutObject& renderer)
 {
     ASSERT(renderer.style());
     return adjustDoubleForAbsoluteZoom(value, *renderer.style());
 }
 
-inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, RenderObject& renderer)
+inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, LayoutObject& renderer)
 {
     ASSERT(renderer.style());
     return adjustLayoutUnitForAbsoluteZoom(value, *renderer.style());
 }
 
-inline void adjustFloatQuadForAbsoluteZoom(FloatQuad& quad, RenderObject& renderer)
+inline void adjustFloatQuadForAbsoluteZoom(FloatQuad& quad, LayoutObject& renderer)
 {
     float zoom = renderer.style()->effectiveZoom();
     if (zoom != 1)
         quad.scale(1 / zoom, 1 / zoom);
 }
 
-inline void adjustFloatRectForAbsoluteZoom(FloatRect& rect, RenderObject& renderer)
+inline void adjustFloatRectForAbsoluteZoom(FloatRect& rect, LayoutObject& renderer)
 {
     float zoom = renderer.style()->effectiveZoom();
     if (zoom != 1)
         rect.scale(1 / zoom, 1 / zoom);
 }
 
-inline double adjustScrollForAbsoluteZoom(double value, RenderObject& renderer)
+inline double adjustScrollForAbsoluteZoom(double value, LayoutObject& renderer)
 {
     ASSERT(renderer.style());
     return adjustScrollForAbsoluteZoom(value, *renderer.style());
 }
 
-#define DEFINE_RENDER_OBJECT_TYPE_CASTS(thisType, predicate) \
-    DEFINE_TYPE_CASTS(thisType, RenderObject, object, object->predicate, object.predicate)
+#define DEFINE_LAYOUT_OBJECT_TYPE_CASTS(thisType, predicate) \
+    DEFINE_TYPE_CASTS(thisType, LayoutObject, object, object->predicate, object.predicate)
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
-void showTree(const blink::RenderObject*);
-void showLineTree(const blink::RenderObject*);
-void showRenderTree(const blink::RenderObject* object1);
+void showTree(const blink::LayoutObject*);
+void showLineTree(const blink::LayoutObject*);
+void showRenderTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showRenderTree
 // can be called from gdb easily.
-void showRenderTree(const blink::RenderObject* object1, const blink::RenderObject* object2);
+void showRenderTree(const blink::LayoutObject* object1, const blink::LayoutObject* object2);
 
 #endif
 
-#endif // RenderObject_h
+#endif // LayoutObject_h