Delete RenderLayerModelObject.

sky/engine/core/rendering/RenderLayer.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 52 matching lines @@
 class HitTestingTransformState;
 class RenderStyle;
 class TransformationMatrix;
 
 enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
 enum IncludeSelfOrNot { IncludeSelf, ExcludeSelf };
 
 class RenderLayer {
     WTF_MAKE_NONCOPYABLE(RenderLayer);
 public:
-    RenderLayer(RenderLayerModelObject*, LayerType);
+    RenderLayer(RenderBox*, LayerType);
     ~RenderLayer();
 
     String debugName() const;
 
-    RenderLayerModelObject* renderer() const { return m_renderer; }
-    RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
+    RenderBox* renderer() const { return m_renderer; }
+    // FIXME(sky): Remove
+    RenderBox* renderBox() const { return m_renderer; }
     RenderLayer* parent() const { return m_parent; }
     RenderLayer* previousSibling() const { return m_previous; }
     RenderLayer* nextSibling() const { return m_next; }
     RenderLayer* firstChild() const { return m_first; }
     RenderLayer* lastChild() const { return m_last; }
 
     void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
     RenderLayer* removeChild(RenderLayer*);
 
     void removeOnlyThisLayer();
@@ skipping 92 matching lines @@
     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
     // Both updates the status, and returns true if descendants of this have 3d.
     bool update3DTransformedDescendantStatus();
 
     // 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()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
 
     bool hasFilter() const { return renderer()->hasFilter(); }
 
     void* operator new(size_t);
-    // Only safe to call from RenderLayerModelObject::destroyLayer()
+    // Only safe to call from RenderBox::destroyLayer()
     void operator delete(void*);
 
     bool paintsWithTransform() const;
 
     FilterOperations computeFilterOperations(const RenderStyle*);
     bool paintsWithFilters() const;
     bool requiresFullLayerImageForFilters() const;
     FilterEffectRenderer* filterRenderer() const
     {
         RenderLayerFilterInfo* filterInfo = this->filterInfo();
@@ skipping 12 matching lines @@
     void setHasFilterInfo(bool hasFilterInfo) { m_hasFilterInfo = hasFilterInfo; }
 
     void updateFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle);
 
     RenderLayerClipper& clipper() { return m_clipper; }
     const RenderLayerClipper& clipper() const { return m_clipper; }
 
     inline bool isPositionedContainer() const
     {
         // FIXME: This is not in sync with containingBlock.
-        RenderLayerModelObject* layerRenderer = renderer();
+        RenderBox* layerRenderer = renderer();
         return isRootLayer() || layerRenderer->isPositioned() || hasTransform();
     }
 
     void updateOrRemoveFilterEffectRenderer();
     void updateSelfPaintingLayer();
 
     void clipToRect(const LayerPaintingInfo&, GraphicsContext*, const ClipRect&, BorderRadiusClippingRule = IncludeSelfForBorderRadius);
     void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
 
 private:
@@ skipping 16 matching lines @@
     void updateHasSelfPaintingLayerDescendant() const;
 
     bool hasSelfPaintingLayerDescendant() const
     {
         if (m_hasSelfPaintingLayerDescendantDirty)
             updateHasSelfPaintingLayerDescendant();
         ASSERT(!m_hasSelfPaintingLayerDescendantDirty);
         return m_hasSelfPaintingLayerDescendant;
     }
 
-    LayoutPoint renderBoxLocation() const { return renderer()->isBox() ? toRenderBox(renderer())->location() : LayoutPoint(); }
+    LayoutPoint renderBoxLocation() const { return renderer()->location(); }
 
     bool shouldBeSelfPaintingLayer() const;
 
     // FIXME: We should only create the stacking node if needed.
     bool requiresStackingNode() const { return true; }
     void updateStackingNode();
 
     void updateTransform(const RenderStyle* oldStyle, RenderStyle* newStyle);
 
     void dirty3DTransformedDescendantStatus();
@@ skipping 20 matching lines @@
                                  // we ended up painting this layer or any descendants (and therefore need to
                                  // blend).
 
     unsigned m_3DTransformedDescendantStatusDirty : 1;
     // Set on a stacking context layer that has 3D descendants anywhere
     // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
     unsigned m_has3DTransformedDescendant : 1;
 
     unsigned m_hasFilterInfo : 1;
 
-    RenderLayerModelObject* m_renderer;
+    RenderBox* m_renderer;
 
     RenderLayer* m_parent;
     RenderLayer* m_previous;
     RenderLayer* m_next;
     RenderLayer* m_first;
     RenderLayer* m_last;
 
     OwnPtr<TransformationMatrix> m_transform;
 
     RenderLayerClipper m_clipper; // FIXME: Lazily allocate?
     OwnPtr<RenderLayerStackingNode> m_stackingNode;
 
     LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::RenderLayer*);
 void showLayerTree(const blink::RenderObject*);
 #endif
 
 #endif  // SKY_ENGINE_CORE_RENDERING_RENDERLAYER_H_