Delete RenderLayerModelObject.

sky/engine/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 28 matching lines @@
     , m_nonUniformStepsCount(0)
     , m_transformedStepsCount(0)
     , m_mapCoordinatesFlags(flags)
 {
 }
 
 RenderGeometryMap::~RenderGeometryMap()
 {
 }
 
-void RenderGeometryMap::mapToContainer(TransformState& transformState, const RenderLayerModelObject* container) const
+void RenderGeometryMap::mapToContainer(TransformState& transformState, const RenderBox* container) const
 {
     // If the mapping includes something like columns, we have to go via renderers.
     if (hasNonUniformStep()) {
         m_mapping.last().m_renderer->mapLocalToContainer(container, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
         transformState.flatten();
         return;
     }
 
 #if ENABLE(ASSERT)
     bool foundContainer = !container || (m_mapping.size() && m_mapping[0].m_renderer == container);
@@ skipping 22 matching lines @@
                 transformState.applyTransform(*currentStep.m_transform.get(), accumulate);
             else
                 transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height(), accumulate);
         }
     }
 
     ASSERT(foundContainer);
     transformState.flatten();
 }
 
-FloatPoint RenderGeometryMap::mapToContainer(const FloatPoint& p, const RenderLayerModelObject* container) const
+FloatPoint RenderGeometryMap::mapToContainer(const FloatPoint& p, const RenderBox* container) const
 {
     FloatPoint result;
 
     if (!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();
     }
@@ skipping 24 matching lines @@
     fprintf(stderr, "RenderGeometryMap::dumpSteps accumulatedOffset=%d,%d\n", m_accumulatedOffset.width().toInt(), m_accumulatedOffset.height().toInt());
     for (int i = m_mapping.size() - 1; i >= 0; --i) {
         fprintf(stderr, " [%d] %s: offset=%d,%d", i, m_mapping[i].m_renderer->debugName().ascii().data(), m_mapping[i].m_offset.width().toInt(), m_mapping[i].m_offset.height().toInt());
         if (m_mapping[i].m_hasTransform)
             fprintf(stderr, " hasTransform");
         fprintf(stderr, "\n");
     }
 }
 #endif
 
-FloatQuad RenderGeometryMap::mapToContainer(const FloatRect& rect, const RenderLayerModelObject* container) const
+FloatQuad RenderGeometryMap::mapToContainer(const FloatRect& rect, const RenderBox* container) const
 {
     FloatRect result;
 
     if (!hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_renderer))) {
         result = rect;
         result.move(m_accumulatedOffset);
     } else {
         TransformState transformState(TransformState::ApplyTransformDirection, rect.center(), rect);
         mapToContainer(transformState, container);
         result = transformState.lastPlanarQuad().boundingBox();
@@ skipping 10 matching lines @@
 
         // 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(FloatQuad(result).boundingBox()));
     }
 #endif
 
     return result;
 }
 
-void RenderGeometryMap::pushMappingsToAncestor(const RenderObject* renderer, const RenderLayerModelObject* ancestorRenderer)
+void RenderGeometryMap::pushMappingsToAncestor(const RenderObject* renderer, const RenderBox* 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));
 }
 
@@ skipping 31 matching lines @@
         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, /*hasTransform*/ false);
         return;
     }
-    const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
+    const RenderBox* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
     pushMappingsToAncestor(renderer, ancestorRenderer);
 }
 
 void RenderGeometryMap::push(const RenderObject* renderer, const LayoutSize& offsetFromContainer, bool accumulatingTransform, bool isNonUniform, bool hasTransform)
 {
 //    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);
 
@@ skipping 15 matching lines @@
     RenderGeometryMapStep& step = m_mapping[m_insertionPosition];
 
     if (!t.isIntegerTranslation())
         step.m_transform = adoptPtr(new TransformationMatrix(t));
     else
         step.m_offset = LayoutSize(t.e(), t.f());
 
     stepInserted(step);
 }
 
-void RenderGeometryMap::popMappingsToAncestor(const RenderLayerModelObject* ancestorRenderer)
+void RenderGeometryMap::popMappingsToAncestor(const RenderBox* ancestorRenderer)
 {
     ASSERT(m_mapping.size());
 
     while (m_mapping.size() && m_mapping.last().m_renderer != ancestorRenderer) {
         stepRemoved(m_mapping.last());
         m_mapping.removeLast();
     }
 }
 
 void RenderGeometryMap::popMappingsToAncestor(const RenderLayer* ancestorLayer)
 {
-    const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
+    const RenderBox* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
     popMappingsToAncestor(ancestorRenderer);
 }
 
 void RenderGeometryMap::stepInserted(const RenderGeometryMapStep& step)
 {
     m_accumulatedOffset += step.m_offset;
 
     if (step.m_isNonUniform)
         ++m_nonUniformStepsCount;
 
@@ skipping 22 matching lines @@
     if (!renderer->isRenderView())
         return false;
 
     // If we're not working with multiple RenderViews, then any view is considered
     // "topmost" (to preserve original behavior).
     return !(m_mapCoordinatesFlags & TraverseDocumentBoundaries);
 }
 #endif
 
 } // namespace blink