Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/Layer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 190 matching lines @@
     // Returns the enclosing layer root into which this layer paints, inclusive of this one. Note that the enclosing layer may or may not have its own
     // GraphicsLayer backing, but is nevertheless the root for a call to the Layer::paint*() methods.
     Layer* enclosingLayerForPaintInvalidation() const;
 
     Layer* enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const;
 
     bool hasAncestorWithFilterOutsets() const;
 
     bool canUseConvertToLayerCoords() const
     {
-        // These RenderObjects have an impact on their layers without the renderers knowing about it.
+        // These LayoutObjects have an impact on their layers without the renderers knowing about it.
         return !renderer()->hasColumns() && !renderer()->hasTransformRelatedProperty() && !renderer()->isSVGRoot();
     }
 
     void convertToLayerCoords(const Layer* ancestorLayer, LayoutPoint&) const;
     void convertToLayerCoords(const Layer* ancestorLayer, LayoutRect&) const;
 
     // Does the same as convertToLayerCoords() when not in multicol. For multicol, however,
     // convertToLayerCoords() calculates the offset in flow-thread coordinates (what the layout
     // engine uses internally), while this method calculates the visual coordinates; i.e. it figures
     // out which column the layer starts in and adds in the offset. See
@@ skipping 83 matching lines @@
     CompositedLayerMapping* groupedMapping() const { return m_groupedMapping; }
     void setGroupedMapping(CompositedLayerMapping* groupedMapping, bool layerBeingDestroyed = false);
 
     bool hasCompositedMask() const;
     bool hasCompositedClippingMask() const;
     bool needsCompositedScrolling() const { return m_scrollableArea && m_scrollableArea->needsCompositedScrolling(); }
 
     // Computes the position of the given render object in the space of |paintInvalidationContainer|.
     // FIXME: invert the logic to have paint invalidation containers take care of painting objects into them, rather than the reverse.
     // This will allow us to clean up this static method messiness.
-    static LayoutPoint positionFromPaintInvalidationBacking(const RenderObject*, const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0);
+    static LayoutPoint positionFromPaintInvalidationBacking(const LayoutObject*, const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0);
 
     static void mapPointToPaintBackingCoordinates(const LayoutLayerModelObject* paintInvalidationContainer, FloatPoint&);
     static void mapRectToPaintBackingCoordinates(const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect&);
 
-    // Adjusts the given rect (in the coordinate space of the RenderObject) to the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
-    static void mapRectToPaintInvalidationBacking(const RenderObject*, const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect&, const PaintInvalidationState* = 0);
+    // Adjusts the given rect (in the coordinate space of the LayoutObject) to the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
+    static void mapRectToPaintInvalidationBacking(const LayoutObject*, const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect&, const PaintInvalidationState* = 0);
 
-    // Computes the bounding paint invalidation rect for |renderObject|, in the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
-    static LayoutRect computePaintInvalidationRect(const RenderObject*, const Layer* paintInvalidationContainer, const PaintInvalidationState* = 0);
+    // Computes the bounding paint invalidation rect for |layoutObject|, in the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
+    static LayoutRect computePaintInvalidationRect(const LayoutObject*, const Layer* paintInvalidationContainer, const PaintInvalidationState* = 0);
 
     bool paintsWithTransparency(PaintBehavior paintBehavior) const
     {
         return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || compositingState() != PaintsIntoOwnBacking);
     }
 
     bool paintsWithTransform(PaintBehavior) const;
 
     // Returns true if background phase is painted opaque in the given rect.
     // The query rect is given in local coordinates.
@@ skipping 36 matching lines @@
     void computeSelfHitTestRects(LayerHitTestRects&) const;
 
     // FIXME: This should probably return a ScrollableArea but a lot of internal methods are mistakenly exposed.
     LayerScrollableArea* scrollableArea() const { return m_scrollableArea.get(); }
     LayerClipper& clipper() { return m_clipper; }
     const LayerClipper& clipper() const { return m_clipper; }
 
     inline bool isPositionedContainer() const
     {
         // FIXME: This is not in sync with containingBlock.
-        // RenderObject::canContainFixedPositionedObject() should probably be used
+        // LayoutObject::canContainFixedPositionedObject() should probably be used
         // instead.
         LayoutLayerModelObject* layerRenderer = renderer();
         return isRootLayer() || layerRenderer->isPositioned() || hasTransformRelatedProperty();
     }
 
     bool scrollsOverflow() const;
 
     CompositingReasons potentialCompositingReasonsFromStyle() const { return m_potentialCompositingReasonsFromStyle; }
     void setPotentialCompositingReasonsFromStyle(CompositingReasons reasons) { ASSERT(reasons == (reasons & CompositingReasonComboAllStyleDeterminedReasons)); m_potentialCompositingReasonsFromStyle = reasons; }
 
     bool hasStyleDeterminedDirectCompositingReasons() const { return m_potentialCompositingReasonsFromStyle & CompositingReasonComboAllDirectStyleDeterminedReasons; }
 
     class AncestorDependentCompositingInputs {
     public:
         AncestorDependentCompositingInputs()
             : opacityAncestor(0)
             , transformAncestor(0)
             , filterAncestor(0)
             , clippingContainer(0)
             , ancestorScrollingLayer(0)
             , scrollParent(0)
             , clipParent(0)
             , hasAncestorWithClipPath(false)
         { }
 
         IntRect clippedAbsoluteBoundingBox;
         const Layer* opacityAncestor;
         const Layer* transformAncestor;
         const Layer* filterAncestor;
-        const RenderObject* clippingContainer;
+        const LayoutObject* clippingContainer;
         const Layer* ancestorScrollingLayer;
 
         // A scroll parent is a compositor concept. It's only needed in blink
         // because we need to use it as a promotion trigger. A layer has a
         // scroll parent if neither its compositor scrolling ancestor, nor any
         // other layer scrolled by this ancestor, is a stacking ancestor of this
         // layer. Layers with scroll parents must be scrolled with the main
         // scrolling layer by the compositor.
         const Layer* scrollParent;
 
@@ skipping 32 matching lines @@
     void updateDescendantDependentCompositingInputs(const DescendantDependentCompositingInputs&);
     void didUpdateCompositingInputs();
 
     const AncestorDependentCompositingInputs& ancestorDependentCompositingInputs() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_ancestorDependentCompositingInputs; }
     const DescendantDependentCompositingInputs& descendantDependentCompositingInputs() const { ASSERT(!m_needsDescendantDependentCompositingInputsUpdate); return m_descendantDependentCompositingInputs; }
 
     IntRect clippedAbsoluteBoundingBox() const { return ancestorDependentCompositingInputs().clippedAbsoluteBoundingBox; }
     const Layer* opacityAncestor() const { return ancestorDependentCompositingInputs().opacityAncestor; }
     const Layer* transformAncestor() const { return ancestorDependentCompositingInputs().transformAncestor; }
     const Layer* filterAncestor() const { return ancestorDependentCompositingInputs().filterAncestor; }
-    const RenderObject* clippingContainer() const { return ancestorDependentCompositingInputs().clippingContainer; }
+    const LayoutObject* clippingContainer() const { return ancestorDependentCompositingInputs().clippingContainer; }
     const Layer* ancestorScrollingLayer() const { return ancestorDependentCompositingInputs().ancestorScrollingLayer; }
     Layer* scrollParent() const { return const_cast<Layer*>(ancestorDependentCompositingInputs().scrollParent); }
     Layer* clipParent() const { return const_cast<Layer*>(ancestorDependentCompositingInputs().clipParent); }
     bool hasAncestorWithClipPath() const { return ancestorDependentCompositingInputs().hasAncestorWithClipPath; }
     bool hasDescendantWithClipPath() const { return descendantDependentCompositingInputs().hasDescendantWithClipPath; }
     bool hasNonIsolatedDescendantWithBlendMode() const;
 
     bool lostGroupedMapping() const { ASSERT(isAllowedToQueryCompositingState()); return m_lostGroupedMapping; }
     void setLostGroupedMapping(bool b) { m_lostGroupedMapping = b; }
 
@@ skipping 237 matching lines @@
     OwnPtr<LayerReflectionInfo> m_reflectionInfo;
 
     LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::Layer*);
-void showLayerTree(const blink::RenderObject*);
+void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif // Layer_h