Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderGeometryMap.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 100 matching lines @@
     if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer)))
         result = p + m_accumulatedOffset;
     else {
         TransformState transformState(TransformState::ApplyTransformDirection, p);
         mapToContainer(transformState, container);
         result = transformState.lastPlanarPoint();
     }
 
 #if ENABLE(ASSERT)
     if (m_mapping.size() > 0) {
-        const RenderObject* lastRenderer = m_mapping.last().m_renderer;
+        const LayoutObject* lastRenderer = m_mapping.last().m_renderer;
         const Layer* layer = lastRenderer->enclosingLayer();
 
         // Bounds for invisible layers are intentionally not calculated, and are
         // therefore not necessarily expected to be correct here. This is ok,
         // because they will be recomputed if the layer becomes visible.
         if (!layer || !layer->subtreeIsInvisible()) {
             FloatPoint rendererMappedResult = lastRenderer->localToContainerPoint(p, container, m_mapCoordinatesFlags);
 
             ASSERT(roundedIntPoint(rendererMappedResult) == roundedIntPoint(result));
         }
@@ skipping 25 matching lines @@
         result = rect;
         result.move(m_accumulatedOffset);
     } else {
         TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
         mapToContainer(transformState, container);
         result = transformState.lastPlanarQuad();
     }
 
 #if ENABLE(ASSERT)
     if (m_mapping.size() > 0) {
-        const RenderObject* lastRenderer = m_mapping.last().m_renderer;
+        const LayoutObject* lastRenderer = m_mapping.last().m_renderer;
         const Layer* layer = lastRenderer->enclosingLayer();
 
         // Bounds for invisible layers are intentionally not calculated, and are
         // therefore not necessarily expected to be correct here. This is ok,
         // because they will be recomputed if the layer becomes visible.
         if (!layer->subtreeIsInvisible() && lastRenderer->style()->visibility() == VISIBLE) {
             FloatRect rendererMappedResult = lastRenderer->localToContainerQuad(rect, container, m_mapCoordinatesFlags).boundingBox();
 
             // Inspector creates renderers with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
             // Taking FloatQuad bounds avoids spurious assertions because of that.
             ASSERT(enclosingIntRect(rendererMappedResult) == enclosingIntRect(result.boundingBox()));
         }
     }
 #endif
 
     return result;
 }
 
-void RenderGeometryMap::pushMappingsToAncestor(const RenderObject* renderer, const LayoutLayerModelObject* ancestorRenderer)
+void RenderGeometryMap::pushMappingsToAncestor(const LayoutObject* renderer, const LayoutLayerModelObject* ancestorRenderer)
 {
     // We need to push mappings in reverse order here, so do insertions rather than appends.
     TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
     do {
         renderer = renderer->pushMappingToContainer(ancestorRenderer, *this);
     } while (renderer && renderer != ancestorRenderer);
 
     ASSERT(m_mapping.isEmpty() || isTopmostRenderView(m_mapping[0].m_renderer));
 }
 
-static bool canMapBetweenRenderers(const RenderObject* renderer, const RenderObject* ancestor)
+static bool canMapBetweenRenderers(const LayoutObject* renderer, const LayoutObject* ancestor)
 {
-    for (const RenderObject* current = renderer; ; current = current->parent()) {
+    for (const LayoutObject* current = renderer; ; current = current->parent()) {
         const RenderStyle* style = current->style();
         if (style->position() == FixedPosition || style->isFlippedBlocksWritingMode())
             return false;
 
         if (current->hasColumns() || current->hasTransformRelatedProperty() || current->isRenderFlowThread() || current->isSVGRoot())
             return false;
 
         if (current == ancestor)
             break;
     }
 
     return true;
 }
 
 void RenderGeometryMap::pushMappingsToAncestor(const Layer* layer, const Layer* ancestorLayer)
 {
-    const RenderObject* renderer = layer->renderer();
+    const LayoutObject* renderer = layer->renderer();
 
     bool crossDocument = ancestorLayer && layer->renderer()->frame() != ancestorLayer->renderer()->frame();
     ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
 
     // We have to visit all the renderers to detect flipped blocks. This might defeat the gains
     // from mapping via layers.
     bool canConvertInLayerTree = (ancestorLayer && !crossDocument) ? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer()) : false;
 
 //    fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer, canConvertInLayerTree);
 
     if (canConvertInLayerTree) {
         LayoutPoint layerOffset;
         layer->convertToLayerCoords(ancestorLayer, layerOffset);
 
         // The RenderView must be pushed first.
         if (!m_mapping.size()) {
             ASSERT(ancestorLayer->renderer()->isRenderView());
             pushMappingsToAncestor(ancestorLayer->renderer(), 0);
         }
 
         TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
         bool accumulatingTransform = layer->renderer()->style()->preserves3D() || ancestorLayer->renderer()->style()->preserves3D();
         push(renderer, toLayoutSize(layerOffset), accumulatingTransform, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
         return;
     }
     const LayoutLayerModelObject* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
     pushMappingsToAncestor(renderer, ancestorRenderer);
 }
 
-void RenderGeometryMap::push(const RenderObject* renderer, const LayoutSize& offsetFromContainer, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
+void RenderGeometryMap::push(const LayoutObject* renderer, const LayoutSize& offsetFromContainer, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
 {
 //    fprintf(stderr, "RenderGeometryMap::push %p %d,%d isNonUniform=%d\n", renderer, offsetFromContainer.width().toInt(), offsetFromContainer.height().toInt(), isNonUniform);
 
     ASSERT(m_insertionPosition != kNotFound);
     ASSERT(!renderer->isRenderView() || !m_insertionPosition || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
     ASSERT(offsetForFixedPosition.isZero() || renderer->isRenderView());
 
     m_mapping.insert(m_insertionPosition, RenderGeometryMapStep(renderer, accumulatingTransform, isNonUniform, isFixedPosition, hasTransform));
 
     RenderGeometryMapStep& step = m_mapping[m_insertionPosition];
     step.m_offset = offsetFromContainer;
     step.m_offsetForFixedPosition = offsetForFixedPosition;
 
     stepInserted(step);
 }
 
-void RenderGeometryMap::push(const RenderObject* renderer, const TransformationMatrix& t, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
+void RenderGeometryMap::push(const LayoutObject* renderer, const TransformationMatrix& t, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
 {
     ASSERT(m_insertionPosition != kNotFound);
     ASSERT(!renderer->isRenderView() || !m_insertionPosition || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
     ASSERT(offsetForFixedPosition.isZero() || renderer->isRenderView());
 
     m_mapping.insert(m_insertionPosition, RenderGeometryMapStep(renderer, accumulatingTransform, isNonUniform, isFixedPosition, hasTransform));
 
     RenderGeometryMapStep& step = m_mapping[m_insertionPosition];
     step.m_offsetForFixedPosition = offsetForFixedPosition;
 
@@ skipping 49 matching lines @@
         --m_transformedStepsCount;
     }
 
     if (step.m_isFixedPosition) {
         ASSERT(m_fixedStepsCount);
         --m_fixedStepsCount;
     }
 }
 
 #if ENABLE(ASSERT)
-bool RenderGeometryMap::isTopmostRenderView(const RenderObject* renderer) const
+bool RenderGeometryMap::isTopmostRenderView(const LayoutObject* renderer) const
 {
     if (!renderer->isRenderView())
         return false;
 
     // If we're not working with multiple RenderViews, then any view is considered
     // "topmost" (to preserve original behavior).
     if (!(m_mapCoordinatesFlags & TraverseDocumentBoundaries))
         return true;
 
     return renderer->frame()->isMainFrame();
 }
 #endif
 
 } // namespace blink