Rename hasTransform() to hasTransformRelatedProperty, since the meaning is the latter.

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. 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>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 302 matching lines @@
     }
 }
 
 void RenderLayer::updateTransform(const RenderStyle* oldStyle, RenderStyle* newStyle)
 {
     if (oldStyle && newStyle->transformDataEquivalent(*oldStyle))
         return;
 
     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
     // so check style too.
-    bool hasTransform = renderer()->hasTransform() && newStyle->hasTransform();
+    bool hasTransform = renderer()->hasTransformRelatedProperty() && newStyle->hasTransform();
     bool had3DTransform = has3DTransform();
 
     bool hadTransform = m_transform;
     if (hasTransform != hadTransform) {
         if (hasTransform)
             m_transform = adoptPtr(new TransformationMatrix);
         else
             m_transform.clear();
 
         // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
@@ skipping 155 matching lines @@
         m_enclosingPaginationLayer = this;
         return;
     }
 
     if (m_stackingNode->isNormalFlowOnly()) {
         if (regionBasedColumnsUsed) {
             // Content inside a transform is not considered to be paginated, since we simply
             // paint the transform multiple times in each column, so we don't have to use
             // fragments for the transformed content.
             m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
-            if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
+            if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransformRelatedProperty())
                 m_enclosingPaginationLayer = 0;
         } else {
             m_isPaginated = parent()->renderer()->hasColumns();
         }
         return;
     }
 
     // For the new columns code, we want to walk up our containing block chain looking for an enclosing layer. Once
     // we find one, then we just check its pagination status.
     if (regionBasedColumnsUsed) {
         RenderView* view = renderer()->view();
         RenderBlock* containingBlock;
         for (containingBlock = renderer()->containingBlock();
              containingBlock && containingBlock != view;
              containingBlock = containingBlock->containingBlock()) {
             if (containingBlock->hasLayer()) {
                 // Content inside a transform is not considered to be paginated, since we simply
                 // paint the transform multiple times in each column, so we don't have to use
                 // fragments for the transformed content.
                 m_enclosingPaginationLayer = containingBlock->layer()->enclosingPaginationLayer();
-                if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
+                if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransformRelatedProperty())
                     m_enclosingPaginationLayer = 0;
                 return;
             }
         }
         return;
     }
 
     // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
     RenderLayerStackingNode* ancestorStackingContextNode = m_stackingNode->ancestorStackingContextNode();
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
@@ skipping 331 matching lines @@
     return localPoint;
 }
 
 const LayoutSize RenderLayer::offsetForInFlowPosition() const
 {
     return renderer()->isRelPositioned() ? toRenderBoxModelObject(renderer())->offsetForInFlowPosition() : LayoutSize();
 }
 
 TransformationMatrix RenderLayer::perspectiveTransform() const
 {
-    if (!renderer()->hasTransform())
+    if (!renderer()->hasTransformRelatedProperty())
         return TransformationMatrix();
 
     RenderStyle* style = renderer()->style();
     if (!style->hasPerspective())
         return TransformationMatrix();
 
     // Maybe fetch the perspective from the backing?
     const IntRect borderBox = toRenderBox(renderer())->pixelSnappedBorderBoxRect();
     const float boxWidth = borderBox.width();
     const float boxHeight = borderBox.height();
 
     float perspectiveOriginX = floatValueForLength(style->perspectiveOriginX(), boxWidth);
     float perspectiveOriginY = floatValueForLength(style->perspectiveOriginY(), boxHeight);
 
     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
     // We want it to be in the top-left, so subtract half the height and width.
     perspectiveOriginX -= boxWidth / 2.0f;
     perspectiveOriginY -= boxHeight / 2.0f;
 
     TransformationMatrix t;
     t.translate(perspectiveOriginX, perspectiveOriginY);
     t.applyPerspective(style->perspective());
     t.translate(-perspectiveOriginX, -perspectiveOriginY);
 
     return t;
 }
 
 FloatPoint RenderLayer::perspectiveOrigin() const
 {
-    if (!renderer()->hasTransform())
+    if (!renderer()->hasTransformRelatedProperty())
         return FloatPoint();
 
     const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
     RenderStyle* style = renderer()->style();
 
     return FloatPoint(floatValueForLength(style->perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style->perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 static inline bool isFixedPositionedContainer(RenderLayer* layer)
 {
-    return layer->isRootLayer() || layer->hasTransform();
+    return layer->isRootLayer() || layer->hasTransformRelatedProperty();
 }
 
 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
 {
     RenderLayer* curr = parent();
     while (curr && !curr->isPositionedContainer())
         curr = curr->parent();
 
     return curr;
 }
 
 RenderLayer* RenderLayer::enclosingTransformedAncestor() const
 {
     RenderLayer* curr = parent();
-    while (curr && !curr->isRootLayer() && !curr->renderer()->hasTransform())
+    while (curr && !curr->isRootLayer() && !curr->renderer()->hasTransformRelatedProperty())
         curr = curr->parent();
 
     return curr;
 }
 
 LayoutPoint RenderLayer::computeOffsetFromTransformedAncestor() const
 {
     const AncestorDependentCompositingInputs& properties = ancestorDependentCompositingInputs();
 
     TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
@@ skipping 179 matching lines @@
 }
 
 LayoutRect RenderLayer::transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
     TransparencyClipBoxMode transparencyMode, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
     // would be better to respect clips.
 
     if (rootLayer != layer && ((transparencyBehavior == PaintingTransparencyClipBox && layer->paintsWithTransform(paintBehavior))
-        || (transparencyBehavior == HitTestingTransparencyClipBox && layer->hasTransform()))) {
+        || (transparencyBehavior == HitTestingTransparencyClipBox && layer->hasTransformRelatedProperty()))) {
         // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
         // the transformed layer and all of its children.
         const RenderLayer* paginationLayer = transparencyMode == DescendantsOfTransparencyClipBox ? layer->enclosingPaginationLayer() : 0;
         const RenderLayer* rootLayerForTransform = paginationLayer ? paginationLayer : rootLayer;
         LayoutPoint delta;
         layer->convertToLayerCoords(rootLayerForTransform, delta);
 
         delta.move(subPixelAccumulation);
         IntPoint pixelSnappedDelta = roundedIntPoint(delta);
         TransformationMatrix transform;
@@ skipping 327 matching lines @@
 
 bool RenderLayer::hasOverflowControls() const
 {
     return m_scrollableArea && (m_scrollableArea->hasScrollbar() || m_scrollableArea->hasScrollCorner() || renderer()->style()->resize() != RESIZE_NONE);
 }
 
 void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip respectOverflowClip, const LayoutPoint* offsetFromRoot,
     const LayoutSize& subPixelAccumulation, const LayoutRect* layerBoundingBox)
 {
-    if (!enclosingPaginationLayer() || hasTransform()) {
+    if (!enclosingPaginationLayer() || hasTransformRelatedProperty()) {
         // For unpaginated layers, there is only one fragment.
         LayerFragment fragment;
         ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot, inOverlayScrollbarSizeRelevancy, subPixelAccumulation);
         if (respectOverflowClip == IgnoreOverflowClip)
             clipRectsContext.setIgnoreOverflowClip();
         clipper().calculateRects(clipRectsContext, dirtyRect, fragment.layerBounds, fragment.backgroundRect, fragment.foregroundRect, fragment.outlineRect, offsetFromRoot);
         fragments.append(fragment);
         return;
     }
 
@@ skipping 1376 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif