Delete RenderLayerModelObject.

sky/engine/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 60 matching lines @@
 #include "sky/engine/platform/graphics/filters/SourceGraphic.h"
 #include "sky/engine/platform/transforms/ScaleTransformOperation.h"
 #include "sky/engine/platform/transforms/TransformationMatrix.h"
 #include "sky/engine/platform/transforms/TranslateTransformOperation.h"
 #include "sky/engine/public/platform/Platform.h"
 #include "sky/engine/wtf/StdLibExtras.h"
 #include "sky/engine/wtf/text/CString.h"
 
 namespace blink {
 
-RenderLayer::RenderLayer(RenderLayerModelObject* renderer, LayerType type)
+RenderLayer::RenderLayer(RenderBox* renderer, LayerType type)
     : m_layerType(type)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_3DTransformedDescendantStatusDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_hasFilterInfo(false)
     , m_renderer(renderer)
     , m_parent(0)
@@ skipping 262 matching lines @@
 TransformationMatrix RenderLayer::perspectiveTransform() const
 {
     if (!renderer()->hasTransform())
         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 IntRect borderBox = 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())
         return FloatPoint();
 
-    const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
+    const LayoutRect borderBox = renderer()->borderBoxRect();
     RenderStyle* style = renderer()->style();
 
     return FloatPoint(floatValueForLength(style->perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style->perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
 {
     RenderLayer* curr = parent();
     while (curr && !curr->isPositionedContainer())
         curr = curr->parent();
@@ skipping 17 matching lines @@
         if (curr->requiresFullLayerImageForFilters())
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
 bool RenderLayer::hasAncestorWithFilterOutsets() const
 {
     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
-        RenderLayerModelObject* renderer = curr->renderer();
+        RenderBox* renderer = curr->renderer();
         if (renderer->style()->hasFilterOutsets())
             return true;
     }
     return false;
 }
 
 RenderLayer* RenderLayer::transparentPaintingAncestor()
 {
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
         if (curr->isTransparent())
@@ skipping 205 matching lines @@
 
     // Clear out all the clip rects.
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutPoint& location)
 {
     ASSERT(ancestorLayer != layer);
 
-    const RenderLayerModelObject* renderer = layer->renderer();
+    const RenderBox* renderer = layer->renderer();
     EPosition position = renderer->style()->position();
 
     RenderLayer* parentLayer;
     if (position == AbsolutePosition) {
         // Do what enclosingPositionedAncestor() does, but check for ancestorLayer along the way.
         parentLayer = layer->parent();
         bool foundAncestorFirst = false;
         while (parentLayer) {
             // RenderFlowThread is a positioned container, child of RenderView, positioned at (0,0).
             // This implies that, for out-of-flow positioned elements inside a RenderFlowThread,
@@ skipping 385 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif