Rename renderer() to 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 75 matching lines @@
 };
 
 class Layer {
     WTF_MAKE_NONCOPYABLE(Layer);
 public:
     Layer(LayoutBoxModelObject*, LayerType);
     ~Layer();
 
     String debugName() const;
 
-    LayoutBoxModelObject* renderer() const { return m_renderer; }
+    LayoutBoxModelObject* layoutObject() const { return m_renderer; }
     LayoutBox* layoutBox() const { return m_renderer && m_renderer->isBox() ? toLayoutBox(m_renderer) : 0; }
     Layer* parent() const { return m_parent; }
     Layer* previousSibling() const { return m_previous; }
     Layer* nextSibling() const { return m_next; }
     Layer* firstChild() const { return m_first; }
     Layer* lastChild() const { return m_last; }
 
     const Layer* compositingContainer() const;
 
     void addChild(Layer* newChild, Layer* beforeChild = 0);
     Layer* removeChild(Layer*);
 
     void removeOnlyThisLayer();
     void insertOnlyThisLayer();
 
     void styleChanged(StyleDifference, const LayoutStyle* oldStyle);
 
     // FIXME: Many people call this function while it has out-of-date information.
     bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
 
     void setLayerType(LayerType layerType) { m_layerType = layerType; }
 
-    bool isTransparent() const { return renderer()->isTransparent() || renderer()->style()->hasBlendMode() || renderer()->hasMask(); }
+    bool isTransparent() const { return layoutObject()->isTransparent() || layoutObject()->style()->hasBlendMode() || layoutObject()->hasMask(); }
 
-    bool isReflection() const { return renderer()->isReplica(); }
+    bool isReflection() const { return layoutObject()->isReplica(); }
     LayerReflectionInfo* reflectionInfo() { return m_reflectionInfo.get(); }
     const LayerReflectionInfo* reflectionInfo() const { return m_reflectionInfo.get(); }
 
     const Layer* root() const
     {
         const Layer* curr = this;
         while (curr->parent())
             curr = curr->parent();
         return curr;
     }
@@ skipping 70 matching lines @@
     // 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 LayoutObjects have an impact on their layers without the renderers knowing about it.
-        return !renderer()->hasColumns() && !renderer()->hasTransformRelatedProperty() && !renderer()->isSVGRoot();
+        return !layoutObject()->hasColumns() && !layoutObject()->hasTransformRelatedProperty() && !layoutObject()->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
     // http://www.chromium.org/developers/design-documents/multi-column-layout for more info.
     LayoutPoint visualOffsetFromAncestor(const Layer* ancestorLayer) const;
 
     // The hitTest() method looks for mouse events by walking layers that intersect the point from front to back.
     bool hitTest(const HitTestRequest&, HitTestResult&);
     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
 
     // Pass offsetFromRoot if known.
     bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const Layer* rootLayer, const LayoutPoint* offsetFromRoot = 0) const;
 
     // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
     LayoutRect physicalBoundingBox(const Layer* ancestorLayer, const LayoutPoint* offsetFromRoot = 0) const;
     LayoutRect physicalBoundingBoxIncludingReflectionAndStackingChildren(const Layer* ancestorLayer, const LayoutPoint& offsetFromRoot) const;
     LayoutRect fragmentsBoundingBox(const Layer* ancestorLayer) const;
 
     LayoutRect boundingBoxForCompositingOverlapTest() const;
 
     // If true, this layer's children are included in its bounds for overlap testing.
     // We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
-    bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer()->style()->filter().hasFilterThatMovesPixels(); }
+    bool overlapBoundsIncludeChildren() const { return hasFilter() && layoutObject()->style()->filter().hasFilterThatMovesPixels(); }
 
     enum CalculateBoundsOptions {
         ApplyBoundsChickenEggHacks,
         DoNotApplyBoundsChickenEggHacks,
     };
     LayoutRect boundingBoxForCompositing(const Layer* ancestorLayer = 0, CalculateBoundsOptions = DoNotApplyBoundsChickenEggHacks) const;
 
     LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
     LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
 
     void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
     void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
 
     LayoutSize subpixelAccumulation() const;
     void setSubpixelAccumulation(const LayoutSize&);
 
-    bool hasTransformRelatedProperty() const { return renderer()->hasTransformRelatedProperty(); }
+    bool hasTransformRelatedProperty() const { return layoutObject()->hasTransformRelatedProperty(); }
     // Note that this transform has the transform-origin baked in.
     TransformationMatrix* transform() const { return m_transform.get(); }
     void setTransform(PassOwnPtr<TransformationMatrix> transform) { m_transform = transform; }
     void clearTransform() { m_transform.clear(); }
 
     // currentTransform computes a transform which takes accelerated animations into account. The
     // resulting transform has transform-origin baked in. If the layer does not have a transform,
     // returns the identity matrix.
     TransformationMatrix currentTransform(LayoutStyle::ApplyTransformOrigin = LayoutStyle::IncludeTransformOrigin) const;
     TransformationMatrix renderableTransform(PaintBehavior) const;
 
     // Get the perspective transform, which is applied to transformed sublayers.
     // Returns true if the layer has a -webkit-perspective.
     // Note that this transform has the perspective-origin baked in.
     TransformationMatrix perspectiveTransform() const;
     FloatPoint perspectiveOrigin() const;
-    bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
+    bool preserves3D() const { return layoutObject()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
 
     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
-    bool shouldPreserve3D() const { return !renderer()->hasReflection() && renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
+    bool shouldPreserve3D() const { return !layoutObject()->hasReflection() && layoutObject()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
 
     void filterNeedsPaintInvalidation();
-    bool hasFilter() const { return renderer()->hasFilter(); }
+    bool hasFilter() const { return layoutObject()->hasFilter(); }
 
     void* operator new(size_t);
     // Only safe to call from LayoutBoxModelObject::destroyLayer()
     void operator delete(void*);
 
     CompositingState compositingState() const;
 
     // This returns true if our document is in a phase of its lifestyle during which
     // compositing state may legally be read.
     bool isAllowedToQueryCompositingState() const;
@@ skipping 42 matching lines @@
     bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
 
     bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
     void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
 
     FilterOperations computeFilterOperations(const LayoutStyle&);
     bool paintsWithFilters() const;
     FilterEffectRenderer* filterRenderer() const
     {
         LayerFilterInfo* filterInfo = this->filterInfo();
-        return filterInfo ? filterInfo->renderer() : 0;
+        return filterInfo ? filterInfo->layoutObject() : 0;
     }
 
     LayerFilterInfo* filterInfo() const { return hasFilterInfo() ? LayerFilterInfo::filterInfoForLayer(this) : 0; }
     LayerFilterInfo* ensureFilterInfo() { return LayerFilterInfo::createFilterInfoForLayerIfNeeded(this); }
     void removeFilterInfoIfNeeded()
     {
         if (hasFilterInfo())
             LayerFilterInfo::removeFilterInfoForLayer(this);
     }
 
@@ skipping 17 matching lines @@
     // 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.
         // LayoutObject::canContainFixedPositionedObject() should probably be used
         // instead.
-        LayoutBoxModelObject* layerRenderer = renderer();
+        LayoutBoxModelObject* layerRenderer = layoutObject();
         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; }
 
@@ skipping 108 matching lines @@
         ASSERT(!m_hasSelfPaintingLayerDescendantDirty);
         return m_hasSelfPaintingLayerDescendant;
     }
     LayoutRect paintingExtent(const Layer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior);
     void appendSingleFragmentIgnoringPagination(LayerFragments&, const Layer* rootLayer, const LayoutRect& dirtyRect, ClipRectsCacheSlot, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, ShouldRespectOverflowClip = RespectOverflowClip, const LayoutPoint* offsetFromRoot = 0, const LayoutSize& subPixelAccumulation = LayoutSize());
     void collectFragments(LayerFragments&, const Layer* rootLayer, const LayoutRect& dirtyRect,
         ClipRectsCacheSlot, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize,
         ShouldRespectOverflowClip = RespectOverflowClip, const LayoutPoint* offsetFromRoot = 0,
         const LayoutSize& subPixelAccumulation = LayoutSize(), const LayoutRect* layerBoundingBox = 0);
 
-    LayoutPoint layoutBoxLocation() const { return renderer()->isBox() ? toLayoutBox(renderer())->location() : LayoutPoint(); }
+    LayoutPoint layoutBoxLocation() const { return layoutObject()->isBox() ? toLayoutBox(layoutObject())->location() : LayoutPoint(); }
 
     enum TransparencyClipBoxBehavior {
         PaintingTransparencyClipBox,
         HitTestingTransparencyClipBox
     };
 
     enum TransparencyClipBoxMode {
         DescendantsOfTransparencyClipBox,
         RootOfTransparencyClipBox
     };
@@ skipping 194 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::Layer*);
 void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif // Layer_h