Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/Layer.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 346 matching lines @@
     }
 
     updateTransformationMatrix();
 
     if (had3DTransform != has3DTransform())
         dirty3DTransformedDescendantStatus();
 }
 
 static Layer* enclosingLayerForContainingBlock(Layer* layer)
 {
-    if (RenderObject* containingBlock = layer->renderer()->containingBlock())
+    if (LayoutObject* containingBlock = layer->renderer()->containingBlock())
         return containingBlock->enclosingLayer();
     return 0;
 }
 
 Layer* Layer::renderingContextRoot()
 {
     Layer* renderingContext = 0;
 
     if (shouldPreserve3D())
         renderingContext = this;
@@ skipping 173 matching lines @@
     }
 }
 
 void Layer::clearPaginationRecursive()
 {
     m_enclosingPaginationLayer = 0;
     for (Layer* child = firstChild(); child; child = child->nextSibling())
         child->clearPaginationRecursive();
 }
 
-LayoutPoint Layer::positionFromPaintInvalidationBacking(const RenderObject* renderObject, const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
+LayoutPoint Layer::positionFromPaintInvalidationBacking(const LayoutObject* layoutObject, const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
-    FloatPoint point = renderObject->localToContainerPoint(FloatPoint(), paintInvalidationContainer, 0, 0, paintInvalidationState);
+    FloatPoint point = layoutObject->localToContainerPoint(FloatPoint(), paintInvalidationContainer, 0, 0, paintInvalidationState);
 
     // FIXME: Eventually we are going to unify coordinates in GraphicsLayer space.
     if (paintInvalidationContainer && paintInvalidationContainer->layer()->groupedMapping())
         mapPointToPaintBackingCoordinates(paintInvalidationContainer, point);
 
     return LayoutPoint(point);
 }
 
 void Layer::mapPointToPaintBackingCoordinates(const LayoutLayerModelObject* paintInvalidationContainer, FloatPoint& point)
 {
@@ skipping 26 matching lines @@
     if (!transformedAncestor)
         return;
 
     // |paintInvalidationContainer| may have a local 2D transform on it, so take that into account when mapping into the space of the
     // transformed ancestor.
     rect = LayoutRect(paintInvalidationContainer->localToContainerQuad(FloatRect(rect), transformedAncestor).boundingBox());
 
     rect.moveBy(-paintInvalidationLayer->groupedMapping()->squashingOffsetFromTransformedAncestor());
 }
 
-void Layer::mapRectToPaintInvalidationBacking(const RenderObject* renderObject, const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState)
+void Layer::mapRectToPaintInvalidationBacking(const LayoutObject* layoutObject, const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState)
 {
     if (!paintInvalidationContainer->layer()->groupedMapping()) {
-        renderObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
+        layoutObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
         return;
     }
 
     // This code adjusts the paint invalidation rectangle to be in the space of the transformed ancestor of the grouped (i.e. squashed)
     // layer. This is because all layers that squash together need to issue paint invalidations w.r.t. a single container that is
     // an ancestor of all of them, in order to properly take into account any local transforms etc.
     // FIXME: remove this special-case code that works around the paint invalidation code structure.
-    renderObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
+    layoutObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 
     mapRectToPaintBackingCoordinates(paintInvalidationContainer, rect);
 }
 
-LayoutRect Layer::computePaintInvalidationRect(const RenderObject* renderObject, const Layer* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
+LayoutRect Layer::computePaintInvalidationRect(const LayoutObject* layoutObject, const Layer* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     if (!paintInvalidationContainer->groupedMapping())
-        return renderObject->computePaintInvalidationRect(paintInvalidationContainer->renderer(), paintInvalidationState);
+        return layoutObject->computePaintInvalidationRect(paintInvalidationContainer->renderer(), paintInvalidationState);
 
-    LayoutRect rect = renderObject->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer->renderer(), paintInvalidationState);
+    LayoutRect rect = layoutObject->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer->renderer(), paintInvalidationState);
     mapRectToPaintBackingCoordinates(paintInvalidationContainer->renderer(), rect);
     return rect;
 }
 
 void Layer::dirtyVisibleContentStatus()
 {
     m_visibleContentStatusDirty = true;
     if (parent())
         parent()->dirtyAncestorChainVisibleDescendantStatus();
 }
@@ skipping 16 matching lines @@
         layer->m_visibleDescendantStatusDirty = true;
     }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the Render tree.
 void Layer::updateScrollingStateAfterCompositingChange()
 {
     TRACE_EVENT0("blink", "Layer::updateScrollingStateAfterCompositingChange");
     m_hasVisibleNonLayerContent = false;
-    for (RenderObject* r = renderer()->slowFirstChild(); r; r = r->nextSibling()) {
+    for (LayoutObject* r = renderer()->slowFirstChild(); r; r = r->nextSibling()) {
         if (!r->hasLayer()) {
             m_hasVisibleNonLayerContent = true;
             break;
         }
     }
 
     m_hasNonCompositedChild = false;
     for (Layer* child = firstChild(); child; child = child->nextSibling()) {
         if (child->compositingState() == NotComposited) {
             m_hasNonCompositedChild = true;
@@ skipping 35 matching lines @@
         m_visibleDescendantStatusDirty = false;
     }
 
     if (m_visibleContentStatusDirty) {
         bool previouslyHasVisibleContent = m_hasVisibleContent;
         if (renderer()->style()->visibility() == VISIBLE) {
             m_hasVisibleContent = true;
         } else {
             // layer may be hidden but still have some visible content, check for this
             m_hasVisibleContent = false;
-            RenderObject* r = renderer()->slowFirstChild();
+            LayoutObject* r = renderer()->slowFirstChild();
             while (r) {
                 if (r->style()->visibility() == VISIBLE && !r->hasLayer()) {
                     m_hasVisibleContent = true;
                     break;
                 }
-                RenderObject* rendererFirstChild = r->slowFirstChild();
+                LayoutObject* rendererFirstChild = r->slowFirstChild();
                 if (rendererFirstChild && !r->hasLayer()) {
                     r = rendererFirstChild;
                 } else if (r->nextSibling()) {
                     r = r->nextSibling();
                 } else {
                     do {
                         r = r->parent();
                         if (r == renderer())
                             r = 0;
                     } while (r && !r->nextSibling());
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }
         m_visibleContentStatusDirty = false;
 
         if (hasVisibleContent() != previouslyHasVisibleContent) {
             setNeedsCompositingInputsUpdate();
             // We need to tell m_renderer to recheck its rect because we
-            // pretend that invisible RenderObjects have 0x0 rects. Changing
+            // pretend that invisible LayoutObjects have 0x0 rects. Changing
             // visibility therefore changes our rect and we need to visit
-            // this RenderObject during the invalidateTreeIfNeeded walk.
+            // this LayoutObject during the invalidateTreeIfNeeded walk.
             m_renderer->setMayNeedPaintInvalidation();
         }
     }
 }
 
 void Layer::dirty3DTransformedDescendantStatus()
 {
     LayerStackingNode* stackingNode = m_stackingNode->ancestorStackingContextNode();
     if (!stackingNode)
         return;
@@ skipping 45 matching lines @@
         inlineBoundingBoxOffset = lineBox.location();
         localPoint.moveBy(inlineBoundingBoxOffset);
     } else if (RenderBox* box = renderBox()) {
         m_size = pixelSnappedIntSize(box->size(), box->location());
         localPoint.moveBy(box->topLeftLocation());
     }
 
     if (!renderer()->isOutOfFlowPositioned() && !renderer()->isColumnSpanAll() && renderer()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
-        RenderObject* curr = renderer()->parent();
+        LayoutObject* curr = renderer()->parent();
         while (curr && !curr->hasLayer()) {
             if (curr->isBox() && !curr->isTableRow()) {
                 // Rows and cells share the same coordinate space (that of the section).
                 // Omit them when computing our xpos/ypos.
                 localPoint.moveBy(toRenderBox(curr)->topLeftLocation());
             }
             curr = curr->parent();
         }
         if (curr->isBox() && curr->isTableRow()) {
             // Put ourselves into the row coordinate space.
@@ skipping 166 matching lines @@
 
 // Return the enclosingCompositedLayerForPaintInvalidation for the given Layer
 // including crossing frame boundaries.
 Layer* Layer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const
 {
     const Layer* layer = this;
     Layer* compositedLayer = 0;
     while (!compositedLayer) {
         compositedLayer = layer->enclosingLayerForPaintInvalidation();
         if (!compositedLayer) {
-            RenderObject* owner = layer->renderer()->frame()->ownerRenderer();
+            LayoutObject* owner = layer->renderer()->frame()->ownerRenderer();
             if (!owner)
                 break;
             layer = owner->enclosingLayer();
         }
     }
     return compositedLayer;
 }
 
 Layer* Layer::enclosingLayerForPaintInvalidation() const
 {
@@ skipping 308 matching lines @@
     if (!m_parent && renderer()->parent()) {
         // We need to connect ourselves when our renderer() has a parent.
         // Find our enclosingLayer and add ourselves.
         Layer* parentLayer = renderer()->parent()->enclosingLayer();
         ASSERT(parentLayer);
         Layer* beforeChild = !parentLayer->reflectionInfo() || parentLayer->reflectionInfo()->reflectionLayer() != this ? renderer()->parent()->findNextLayer(parentLayer, renderer()) : 0;
         parentLayer->addChild(this, beforeChild);
     }
 
     // Remove all descendant layers from the hierarchy and add them to the new position.
-    for (RenderObject* curr = renderer()->slowFirstChild(); curr; curr = curr->nextSibling())
+    for (LayoutObject* curr = renderer()->slowFirstChild(); curr; curr = curr->nextSibling())
         curr->moveLayers(m_parent, this);
 
     // Clear out all the clip rects.
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const Layer* accumulateOffsetTowardsAncestor(const Layer* layer, const Layer* ancestorLayer, LayoutPoint& location)
 {
     ASSERT(ancestorLayer != layer);
@@ skipping 280 matching lines @@
         // Intersect the fragment with our ancestor's background clip so that e.g., columns in an overflow:hidden block are
         // properly clipped by the overflow.
         fragment.intersect(ancestorClipRect.rect());
 
         // Now intersect with our pagination clip. This will typically mean we're just intersecting the dirty rect with the column
         // clip, so the column clip ends up being all we apply.
         fragment.intersect(fragment.paginationClip);
     }
 }
 
-static inline LayoutRect frameVisibleRect(RenderObject* renderer)
+static inline LayoutRect frameVisibleRect(LayoutObject* renderer)
 {
     FrameView* frameView = renderer->document().view();
     if (!frameView)
         return LayoutRect();
 
     return frameView->visibleContentRect();
 }
 
 bool Layer::hitTest(const HitTestRequest& request, HitTestResult& result)
 {
@@ skipping 32 matching lines @@
     if (node && !result.URLElement())
         result.setURLElement(node->enclosingLinkEventParentOrSelf());
 
     // Now return whether we were inside this layer (this will always be true for the root
     // layer).
     return insideLayer;
 }
 
 Node* Layer::enclosingElement() const
 {
-    for (RenderObject* r = renderer(); r; r = r->parent()) {
+    for (LayoutObject* r = renderer(); r; r = r->parent()) {
         if (Node* e = r->node())
             return e;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 bool Layer::isInTopLayer() const
 {
     Node* node = renderer()->node();
@@ skipping 29 matching lines @@
         transformState = HitTestingTransformState::create(*containerTransformState);
         convertToLayerCoords(containerLayer, offset);
     } else {
         // If this is the first time we need to make transform state, then base it off of hitTestLocation,
         // which is relative to rootLayer.
         transformState = HitTestingTransformState::create(hitTestLocation.transformedPoint(), hitTestLocation.transformedRect(), FloatQuad(hitTestRect));
         convertToLayerCoords(rootLayer, offset);
     }
     offset.moveBy(translationOffset);
 
-    RenderObject* containerRenderer = containerLayer ? containerLayer->renderer() : 0;
+    LayoutObject* containerRenderer = containerLayer ? containerLayer->renderer() : 0;
     if (renderer()->shouldUseTransformFromContainer(containerRenderer)) {
         TransformationMatrix containerTransform;
         renderer()->getTransformFromContainer(containerRenderer, toLayoutSize(offset), containerTransform);
         transformState->applyTransform(containerTransform, HitTestingTransformState::AccumulateTransform);
     } else {
         transformState->translate(offset.x(), offset.y(), HitTestingTransformState::AccumulateTransform);
     }
 
     return transformState;
 }
@@ skipping 127 matching lines @@
 
     // Collect the fragments. This will compute the clip rectangles for each layer fragment.
     LayerFragments layerFragments;
     collectFragments(layerFragments, rootLayer, hitTestRect, RootRelativeClipRects, IncludeOverlayScrollbarSize);
 
     if (m_scrollableArea && m_scrollableArea->hitTestResizerInFragments(layerFragments, hitTestLocation)) {
         renderer()->updateHitTestResult(result, hitTestLocation.point());
         return this;
     }
 
-    // Next we want to see if the mouse pos is inside the child RenderObjects of the layer. Check
+    // Next we want to see if the mouse pos is inside the child LayoutObjects of the layer. Check
     // every fragment in reverse order.
     if (isSelfPaintingLayer()) {
         // Hit test with a temporary HitTestResult, because we only want to commit to 'result' if we know we're frontmost.
         HitTestResult tempResult(result.hitTestLocation());
         bool insideFragmentForegroundRect = false;
         if (hitTestContentsForFragments(layerFragments, request, tempResult, hitTestLocation, HitTestDescendants, insideFragmentForegroundRect)
             && isHitCandidate(this, false, zOffsetForContentsPtr, unflattenedTransformState.get())) {
             if (result.isRectBasedTest())
                 result.append(tempResult);
             else
@@ skipping 403 matching lines @@
     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
     // overflow, we have to create a bounding box that will extend to include this overflow.
     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
     // floats.
     LayoutRect result;
     if (renderer()->isInline() && renderer()->isRenderInline()) {
         result = toRenderInline(renderer())->linesVisualOverflowBoundingBox();
     } else if (renderer()->isTableRow()) {
         // Our bounding box is just the union of all of our cells' border/overflow rects.
-        for (RenderObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
+        for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
             if (child->isTableCell()) {
                 LayoutRect bbox = toRenderBox(child)->borderBoxRect();
                 result.unite(bbox);
                 LayoutRect overflowRect = renderBox()->visualOverflowRect();
                 if (bbox != overflowRect)
                     result.unite(overflowRect);
             }
         }
     } else {
         RenderBox* box = renderBox();
         ASSERT(box);
         result = box->borderBoxRect();
         result.unite(box->visualOverflowRect());
     }
 
     ASSERT(renderer()->view());
     return result;
 }
 
-static inline LayoutRect flippedLogicalBoundingBox(LayoutRect boundingBox, RenderObject* renderer)
+static inline LayoutRect flippedLogicalBoundingBox(LayoutRect boundingBox, LayoutObject* renderer)
 {
     LayoutRect result = boundingBox;
     if (renderer->isBox())
         toRenderBox(renderer)->flipForWritingMode(result);
     else
         renderer->containingBlock()->flipForWritingMode(result);
     return result;
 }
 
 LayoutRect Layer::physicalBoundingBox(const Layer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
@@ skipping 311 matching lines @@
         parent()->dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 }
 
 bool Layer::hasNonEmptyChildRenderers() const
 {
     // Some HTML can cause whitespace text nodes to have renderers, like:
     // <div>
     // <img src=...>
     // </div>
     // so test for 0x0 RenderTexts here
-    for (RenderObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->hasLayer()) {
             if (child->isRenderInline() || !child->isBox())
                 return true;
 
             if (!toRenderBox(child)->size().isEmpty())
                 return true;
         }
     }
     return false;
 }
@@ skipping 248 matching lines @@
 {
     if (!layer)
         return;
 
     if (blink::LocalFrame* frame = layer->renderer()->frame()) {
         WTF::String output = externalRepresentation(frame, blink::LayoutAsTextShowAllLayers | blink::LayoutAsTextShowLayerNesting | blink::LayoutAsTextShowCompositedLayers | blink::LayoutAsTextShowAddresses | blink::LayoutAsTextShowIDAndClass | blink::LayoutAsTextDontUpdateLayout | blink::LayoutAsTextShowLayoutState);
         fprintf(stderr, "%s\n", output.utf8().data());
     }
 }
 
-void showLayerTree(const blink::RenderObject* renderer)
+void showLayerTree(const blink::LayoutObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif