Move rendering/RenderLayer* to layout/

Source/core/layout/LayoutTreeAsText.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 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 17 matching lines @@
 
 #include "core/HTMLNames.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "core/dom/PseudoElement.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLElement.h"
+#include "core/layout/Layer.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/page/PrintContext.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderBR.h"
 #include "core/rendering/RenderDetailsMarker.h"
 #include "core/rendering/RenderFileUploadControl.h"
 #include "core/rendering/RenderInline.h"
-#include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderListItem.h"
 #include "core/rendering/RenderListMarker.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/svg/RenderSVGContainer.h"
 #include "core/rendering/svg/RenderSVGGradientStop.h"
 #include "core/rendering/svg/RenderSVGImage.h"
 #include "core/rendering/svg/RenderSVGInlineText.h"
 #include "core/rendering/svg/RenderSVGPath.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
@@ skipping 427 matching lines @@
         write(ts, *child, indent + 1, behavior);
     }
 
     if (o.isRenderPart()) {
         Widget* widget = toRenderPart(o).widget();
         if (widget && widget->isFrameView()) {
             FrameView* view = toFrameView(widget);
             RenderView* root = view->renderView();
             if (root) {
                 view->layout();
-                RenderLayer* layer = root->layer();
+                Layer* layer = root->layer();
                 if (layer)
                     LayoutTreeAsText::writeLayers(ts, layer, layer, layer->rect(), indent + 1, behavior);
             }
         }
     }
 }
 
 enum LayerPaintPhase {
     LayerPaintPhaseAll = 0,
     LayerPaintPhaseBackground = -1,
     LayerPaintPhaseForeground = 1
 };
 
-static void write(TextStream& ts, RenderLayer& layer,
+static void write(TextStream& ts, Layer& layer,
     const LayoutRect& layerBounds, const LayoutRect& backgroundClipRect, const LayoutRect& clipRect, const LayoutRect& outlineClipRect,
     LayerPaintPhase paintPhase = LayerPaintPhaseAll, int indent = 0, LayoutAsTextBehavior behavior = LayoutAsTextBehaviorNormal)
 {
     IntRect adjustedLayoutBounds = pixelSnappedIntRect(layerBounds);
     IntRect adjustedLayoutBoundsWithScrollbars = adjustedLayoutBounds;
     IntRect adjustedBackgroundClipRect = pixelSnappedIntRect(backgroundClipRect);
     IntRect adjustedClipRect = pixelSnappedIntRect(clipRect);
     IntRect adjustedOutlineClipRect = pixelSnappedIntRect(outlineClipRect);
 
     Settings* settings = layer.renderer()->document().settings();
@@ skipping 65 matching lines @@
                 << ")";
         }
     }
 
     ts << "\n";
 
     if (paintPhase != LayerPaintPhaseBackground)
         write(ts, *layer.renderer(), indent + 1, behavior);
 }
 
-void LayoutTreeAsText::writeLayers(TextStream& ts, const RenderLayer* rootLayer, RenderLayer* layer,
+void LayoutTreeAsText::writeLayers(TextStream& ts, const Layer* rootLayer, Layer* layer,
     const LayoutRect& paintRect, int indent, LayoutAsTextBehavior behavior)
 {
     // Calculate the clip rects we should use.
     LayoutRect layerBounds;
     ClipRect damageRect, clipRectToApply, outlineRect;
     layer->clipper().calculateRects(ClipRectsContext(rootLayer, UncachedClipRects), paintRect, layerBounds, damageRect, clipRectToApply, outlineRect);
 
     // Ensure our lists are up-to-date.
     layer->stackingNode()->updateLayerListsIfNeeded();
 
     bool shouldPaint = (behavior & LayoutAsTextShowAllLayers) ? true : layer->intersectsDamageRect(layerBounds, damageRect.rect(), rootLayer);
 
-    Vector<RenderLayerStackingNode*>* negList = layer->stackingNode()->negZOrderList();
+    Vector<LayerStackingNode*>* negList = layer->stackingNode()->negZOrderList();
     bool paintsBackgroundSeparately = negList && negList->size() > 0;
     if (shouldPaint && paintsBackgroundSeparately)
         write(ts, *layer, layerBounds, damageRect.rect(), clipRectToApply.rect(), outlineRect.rect(), LayerPaintPhaseBackground, indent, behavior);
 
     if (negList) {
         int currIndent = indent;
         if (behavior & LayoutAsTextShowLayerNesting) {
             writeIndent(ts, indent);
             ts << " negative z-order list(" << negList->size() << ")\n";
             ++currIndent;
         }
         for (unsigned i = 0; i != negList->size(); ++i)
             writeLayers(ts, rootLayer, negList->at(i)->layer(), paintRect, currIndent, behavior);
     }
 
     if (shouldPaint)
         write(ts, *layer, layerBounds, damageRect.rect(), clipRectToApply.rect(), outlineRect.rect(), paintsBackgroundSeparately ? LayerPaintPhaseForeground : LayerPaintPhaseAll, indent, behavior);
 
-    if (Vector<RenderLayerStackingNode*>* normalFlowList = layer->stackingNode()->normalFlowList()) {
+    if (Vector<LayerStackingNode*>* normalFlowList = layer->stackingNode()->normalFlowList()) {
         int currIndent = indent;
         if (behavior & LayoutAsTextShowLayerNesting) {
             writeIndent(ts, indent);
             ts << " normal flow list(" << normalFlowList->size() << ")\n";
             ++currIndent;
         }
         for (unsigned i = 0; i != normalFlowList->size(); ++i)
             writeLayers(ts, rootLayer, normalFlowList->at(i)->layer(), paintRect, currIndent, behavior);
     }
 
-    if (Vector<RenderLayerStackingNode*>* posList = layer->stackingNode()->posZOrderList()) {
+    if (Vector<LayerStackingNode*>* posList = layer->stackingNode()->posZOrderList()) {
         int currIndent = indent;
         if (behavior & LayoutAsTextShowLayerNesting) {
             writeIndent(ts, indent);
             ts << " positive z-order list(" << posList->size() << ")\n";
             ++currIndent;
         }
         for (unsigned i = 0; i != posList->size(); ++i)
             writeLayers(ts, rootLayer, posList->at(i)->layer(), paintRect, currIndent, behavior);
     }
 }
@@ skipping 55 matching lines @@
             << "selection end:   position " << selection.end().deprecatedEditingOffset() << " of " << nodePositionAsStringForTesting(selection.end().deprecatedNode()) << "\n";
     }
 }
 
 static String externalRepresentation(RenderBox* renderer, LayoutAsTextBehavior behavior)
 {
     TextStream ts;
     if (!renderer->hasLayer())
         return ts.release();
 
-    RenderLayer* layer = renderer->layer();
+    Layer* layer = renderer->layer();
     LayoutTreeAsText::writeLayers(ts, layer, layer, layer->rect(), 0, behavior);
     writeSelection(ts, renderer);
     return ts.release();
 }
 
 String externalRepresentation(LocalFrame* frame, LayoutAsTextBehavior behavior)
 {
     if (!(behavior & LayoutAsTextDontUpdateLayout))
         frame->document()->updateLayout();
 
@@ skipping 57 matching lines @@
     element->document().updateLayout();
 
     RenderObject* renderer = element->renderer();
     if (!renderer || !renderer->isListItem())
         return String();
 
     return toRenderListItem(renderer)->markerText();
 }
 
 } // namespace blink