Move rendering/RenderObject to layout/LayoutObject.

Source/core/page/scrolling/ScrollingCoordinator.cpp

 /*
  * Copyright (C) 2011 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 197 matching lines @@
 {
     if (layer && layer != except && toWebLayer(layer))
         toWebLayer(layer)->setPositionConstraint(WebLayerPositionConstraint());
 }
 
 static WebLayerPositionConstraint computePositionConstraint(const Layer* layer)
 {
     ASSERT(layer->hasCompositedLayerMapping());
     do {
         if (layer->renderer()->style()->position() == FixedPosition) {
-            const RenderObject* fixedPositionObject = layer->renderer();
+            const LayoutObject* fixedPositionObject = layer->renderer();
             bool fixedToRight = !fixedPositionObject->style()->right().isAuto();
             bool fixedToBottom = !fixedPositionObject->style()->bottom().isAuto();
             return WebLayerPositionConstraint::fixedPosition(fixedToRight, fixedToBottom);
         }
 
         layer = layer->parent();
 
         // Composited layers that inherit a fixed position state will be positioned with respect to the nearest compositedLayerMapping's GraphicsLayer.
-        // So, once we find a layer that has its own compositedLayerMapping, we can stop searching for a fixed position RenderObject.
+        // So, once we find a layer that has its own compositedLayerMapping, we can stop searching for a fixed position LayoutObject.
     } while (layer && !layer->hasCompositedLayerMapping());
     return WebLayerPositionConstraint();
 }
 
 void ScrollingCoordinator::updateLayerPositionConstraint(Layer* layer)
 {
     ASSERT(layer->hasCompositedLayerMapping());
     CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
     GraphicsLayer* mainLayer = compositedLayerMapping->childForSuperlayers();
 
@@ skipping 197 matching lines @@
 // current frame which we can consult while walking the layers of that frame.
 // Whenever we descend into a new frame, a new map will be created.
 using LayerFrameMap = HashMap<const Layer*, Vector<const LocalFrame*>>;
 static void makeLayerChildFrameMap(const LocalFrame* currentFrame, LayerFrameMap* map)
 {
     map->clear();
     const FrameTree& tree = currentFrame->tree();
     for (const Frame* child = tree.firstChild(); child; child = child->tree().nextSibling()) {
         if (!child->isLocalFrame())
             continue;
-        const RenderObject* ownerRenderer = toLocalFrame(child)->ownerRenderer();
+        const LayoutObject* ownerRenderer = toLocalFrame(child)->ownerRenderer();
         if (!ownerRenderer)
             continue;
         const Layer* containingLayer = ownerRenderer->enclosingLayer();
         LayerFrameMap::iterator iter = map->find(containingLayer);
         if (iter == map->end())
             map->add(containingLayer, Vector<const LocalFrame*>()).storedValue->value.append(toLocalFrame(child));
         else
             iter->value.append(toLocalFrame(child));
     }
 }
@@ skipping 77 matching lines @@
     // all documents on the page).
     HashSet<const Layer*> layersWithRects;
     for (const auto& layerRect : layerRects) {
         const Layer* layer = layerRect.key;
         do {
             if (!layersWithRects.add(layer).isNewEntry)
                 break;
 
             if (layer->parent()) {
                 layer = layer->parent();
-            } else if (RenderObject* parentDocRenderer = layer->renderer()->frame()->ownerRenderer()) {
+            } else if (LayoutObject* parentDocRenderer = layer->renderer()->frame()->ownerRenderer()) {
                 layer = parentDocRenderer->enclosingLayer();
                 touchHandlerInChildFrame = true;
             }
         } while (layer);
     }
 
     // Now walk the layer projecting rects while maintaining a RenderGeometryMap
     MapCoordinatesFlags flags = UseTransforms;
     if (touchHandlerInChildFrame)
         flags |= TraverseDocumentBoundaries;
@@ skipping 270 matching lines @@
         if (!node || !node->inDocument())
             continue;
 
         // If the document belongs to an invisible subframe it does not have a composited layer
         // and should be skipped.
         if (node->document().isInInvisibleSubframe())
             continue;
 
         if (node->isDocumentNode() && node != document) {
             accumulateDocumentTouchEventTargetRects(rects, toDocument(node));
-        } else if (RenderObject* renderer = node->renderer()) {
+        } else if (LayoutObject* renderer = node->renderer()) {
             // If the set also contains one of our ancestor nodes then processing
             // this node would be redundant.
             bool hasTouchEventTargetAncestor = false;
             for (Node* ancestor = node->parentNode(); ancestor && !hasTouchEventTargetAncestor; ancestor = ancestor->parentNode()) {
                 if (targets->contains(ancestor))
                     hasTouchEventTargetAncestor = true;
             }
             if (!hasTouchEventTargetAncestor) {
                 // Walk up the tree to the outermost non-composited scrollable layer.
                 Layer* enclosingNonCompositedScrollLayer = nullptr;
@@ skipping 106 matching lines @@
     frameView->scrollAnimator()->handleWheelEventPhase(phase);
 }
 #endif
 
 bool ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects(FrameView* frameView) const
 {
     const FrameView::ViewportConstrainedObjectSet* viewportConstrainedObjects = frameView->viewportConstrainedObjects();
     if (!viewportConstrainedObjects)
         return false;
 
-    for (const RenderObject* renderer : *viewportConstrainedObjects) {
+    for (const LayoutObject* renderer : *viewportConstrainedObjects) {
         ASSERT(renderer->isBoxModelObject() && renderer->hasLayer());
         ASSERT(renderer->style()->position() == FixedPosition);
         Layer* layer = toRenderBoxModelObject(renderer)->layer();
 
         // Whether the Layer scrolls with the viewport is a tree-depenent
         // property and our viewportConstrainedObjects collection is maintained
-        // with only RenderObject-level information.
+        // with only LayoutObject-level information.
         if (!layer->scrollsWithViewport())
             continue;
 
         // If the whole subtree is invisible, there's no reason to scroll on
         // the main thread because we don't need to generate invalidations
         // for invisible content.
         if (layer->subtreeIsInvisible())
             continue;
 
         // We're only smart enough to scroll viewport-constrainted objects
@@ skipping 66 matching lines @@
     bool frameIsScrollable = frameView && frameView->isScrollable();
     if (frameIsScrollable != m_wasFrameScrollable)
         return true;
 
     if (WebLayer* scrollLayer = frameView ? toWebLayer(frameView->layerForScrolling()) : nullptr)
         return blink::WebSize(frameView->contentsSize()) != scrollLayer->bounds();
     return false;
 }
 
 } // namespace blink