Rename renderer() to layoutObject().

Source/core/page/SpatialNavigation.cpp

 /*
  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Antonio Gomes <tonikitoo@webkit.org>
  *
  * 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
@@ skipping 45 matching lines @@
     , distance(maxDistance())
     , isOffscreen(true)
     , isOffscreenAfterScrolling(true)
 {
     ASSERT(node);
     ASSERT(node->isElementNode());
 
     if (isHTMLAreaElement(*node)) {
         HTMLAreaElement& area = toHTMLAreaElement(*node);
         HTMLImageElement* image = area.imageElement();
-        if (!image || !image->renderer())
+        if (!image || !image->layoutObject())
             return;
 
         visibleNode = image;
         rect = virtualRectForAreaElementAndDirection(area, type);
     } else {
-        if (!node->renderer())
+        if (!node->layoutObject())
             return;
 
         visibleNode = node;
         rect = nodeRectInAbsoluteCoordinates(node, true /* ignore border */);
     }
 
     focusableNode = node;
     isOffscreen = hasOffscreenRect(visibleNode);
     isOffscreenAfterScrolling = hasOffscreenRect(visibleNode, type);
 }
@@ skipping 89 matching lines @@
         containerViewportRect.setY(containerViewportRect.y() - ScrollableArea::pixelsPerLineStep());
         containerViewportRect.setHeight(containerViewportRect.height() + ScrollableArea::pixelsPerLineStep());
         break;
     case WebFocusTypeDown:
         containerViewportRect.setHeight(containerViewportRect.height() + ScrollableArea::pixelsPerLineStep());
         break;
     default:
         break;
     }
 
-    LayoutObject* render = node->renderer();
+    LayoutObject* render = node->layoutObject();
     if (!render)
         return true;
 
     LayoutRect rect(render->absoluteClippedOverflowRect());
     if (rect.isEmpty())
         return true;
 
     return !containerViewportRect.intersects(rect);
 }
 
@@ skipping 82 matching lines @@
         b.inflate(deflateFactor);
 }
 
 bool isScrollableNode(const Node* node)
 {
     ASSERT(!node->isDocumentNode());
 
     if (!node)
         return false;
 
-    if (LayoutObject* renderer = node->renderer())
+    if (LayoutObject* renderer = node->layoutObject())
         return renderer->isBox() && toLayoutBox(renderer)->canBeScrolledAndHasScrollableArea() && node->hasChildren();
 
     return false;
 }
 
 Node* scrollableEnclosingBoxOrParentFrameForNodeInDirection(WebFocusType type, Node* node)
 {
     ASSERT(node);
     Node* parent = node;
     do {
@@ skipping 11 matching lines @@
 {
     ASSERT(container);
     if (container->isDocumentNode())
         return canScrollInDirection(toDocument(container)->frame(), type);
 
     if (!isScrollableNode(container))
         return false;
 
     switch (type) {
     case WebFocusTypeLeft:
-        return (container->renderer()->style()->overflowX() != OHIDDEN && container->layoutBox()->scrollLeft() > 0);
+        return (container->layoutObject()->style()->overflowX() != OHIDDEN && container->layoutBox()->scrollLeft() > 0);
     case WebFocusTypeUp:
-        return (container->renderer()->style()->overflowY() != OHIDDEN && container->layoutBox()->scrollTop() > 0);
+        return (container->layoutObject()->style()->overflowY() != OHIDDEN && container->layoutBox()->scrollTop() > 0);
     case WebFocusTypeRight:
-        return (container->renderer()->style()->overflowX() != OHIDDEN && container->layoutBox()->scrollLeft() + container->layoutBox()->clientWidth() < container->layoutBox()->scrollWidth());
+        return (container->layoutObject()->style()->overflowX() != OHIDDEN && container->layoutBox()->scrollLeft() + container->layoutBox()->clientWidth() < container->layoutBox()->scrollWidth());
     case WebFocusTypeDown:
-        return (container->renderer()->style()->overflowY() != OHIDDEN && container->layoutBox()->scrollTop() + container->layoutBox()->clientHeight() < container->layoutBox()->scrollHeight());
+        return (container->layoutObject()->style()->overflowY() != OHIDDEN && container->layoutBox()->scrollTop() + container->layoutBox()->clientHeight() < container->layoutBox()->scrollHeight());
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 }
 
 bool canScrollInDirection(const LocalFrame* frame, WebFocusType type)
 {
     if (!frame->view())
         return false;
@@ skipping 35 matching lines @@
             for (; element; element = element->offsetParent())
                 rect.move(element->offsetLeft(), element->offsetTop());
             rect.move((-toLocalFrame(frame)->view()->scrollOffset()));
         }
     }
     return rect;
 }
 
 LayoutRect nodeRectInAbsoluteCoordinates(Node* node, bool ignoreBorder)
 {
-    ASSERT(node && node->renderer() && !node->document().view()->needsLayout());
+    ASSERT(node && node->layoutObject() && !node->document().view()->needsLayout());
 
     if (node->isDocumentNode())
         return frameRectInAbsoluteCoordinates(toDocument(node)->frame());
     LayoutRect rect = rectToAbsoluteCoordinates(node->document().frame(), node->boundingBox());
 
     // For authors that use border instead of outline in their CSS, we compensate by ignoring the border when calculating
     // the rect of the focused element.
     if (ignoreBorder) {
-        rect.move(node->renderer()->style()->borderLeftWidth(), node->renderer()->style()->borderTopWidth());
-        rect.setWidth(rect.width() - node->renderer()->style()->borderLeftWidth() - node->renderer()->style()->borderRightWidth());
-        rect.setHeight(rect.height() - node->renderer()->style()->borderTopWidth() - node->renderer()->style()->borderBottomWidth());
+        rect.move(node->layoutObject()->style()->borderLeftWidth(), node->layoutObject()->style()->borderTopWidth());
+        rect.setWidth(rect.width() - node->layoutObject()->style()->borderLeftWidth() - node->layoutObject()->style()->borderRightWidth());
+        rect.setHeight(rect.height() - node->layoutObject()->style()->borderTopWidth() - node->layoutObject()->style()->borderBottomWidth());
     }
     return rect;
 }
 
 LayoutRect frameRectInAbsoluteCoordinates(LocalFrame* frame)
 {
     return rectToAbsoluteCoordinates(frame, LayoutRect(frame->view()->visibleContentRect()));
 }
 
 // This method calculates the exitPoint from the startingRect and the entryPoint into the candidate rect.
@@ skipping 77 matching lines @@
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 bool areElementsOnSameLine(const FocusCandidate& firstCandidate, const FocusCandidate& secondCandidate)
 {
     if (firstCandidate.isNull() || secondCandidate.isNull())
         return false;
 
-    if (!firstCandidate.visibleNode->renderer() || !secondCandidate.visibleNode->renderer())
+    if (!firstCandidate.visibleNode->layoutObject() || !secondCandidate.visibleNode->layoutObject())
         return false;
 
     if (!firstCandidate.rect.intersects(secondCandidate.rect))
         return false;
 
     if (isHTMLAreaElement(*firstCandidate.focusableNode) || isHTMLAreaElement(*secondCandidate.focusableNode))
         return false;
 
-    if (!firstCandidate.visibleNode->renderer()->isLayoutInline() || !secondCandidate.visibleNode->renderer()->isLayoutInline())
+    if (!firstCandidate.visibleNode->layoutObject()->isLayoutInline() || !secondCandidate.visibleNode->layoutObject()->isLayoutInline())
         return false;
 
-    if (firstCandidate.visibleNode->renderer()->containingBlock() != secondCandidate.visibleNode->renderer()->containingBlock())
+    if (firstCandidate.visibleNode->layoutObject()->containingBlock() != secondCandidate.visibleNode->layoutObject()->containingBlock())
         return false;
 
     return true;
 }
 
 void distanceDataForNode(WebFocusType type, const FocusCandidate& current, FocusCandidate& candidate)
 {
     if (areElementsOnSameLine(current, candidate)) {
         if ((type == WebFocusTypeUp && current.rect.y() > candidate.rect.y()) || (type == WebFocusTypeDown && candidate.rect.y() > current.rect.y())) {
             candidate.distance = 0;
@@ skipping 57 matching lines @@
     candidate.distance = sqrt(euclidianDistancePow2) + navigationAxisDistance + weightedOrthogonalAxisDistance - sqrt(overlap);
 }
 
 bool canBeScrolledIntoView(WebFocusType type, const FocusCandidate& candidate)
 {
     ASSERT(candidate.visibleNode && candidate.isOffscreen);
     LayoutRect candidateRect = candidate.rect;
     for (Node* parentNode = candidate.visibleNode->parentNode(); parentNode; parentNode = parentNode->parentNode()) {
         LayoutRect parentRect = nodeRectInAbsoluteCoordinates(parentNode);
         if (!candidateRect.intersects(parentRect)) {
-            if (((type == WebFocusTypeLeft || type == WebFocusTypeRight) && parentNode->renderer()->style()->overflowX() == OHIDDEN)
-                || ((type == WebFocusTypeUp || type == WebFocusTypeDown) && parentNode->renderer()->style()->overflowY() == OHIDDEN))
+            if (((type == WebFocusTypeLeft || type == WebFocusTypeRight) && parentNode->layoutObject()->style()->overflowX() == OHIDDEN)
+                || ((type == WebFocusTypeUp || type == WebFocusTypeDown) && parentNode->layoutObject()->style()->overflowY() == OHIDDEN))
                 return false;
         }
         if (parentNode == candidate.enclosingScrollableBox)
             return canScrollInDirection(parentNode, type);
     }
     return true;
 }
 
 // The starting rect is the rect of the focused node, in document coordinates.
 // Compose a virtual starting rect if there is no focused node or if it is off screen.
@@ skipping 22 matching lines @@
     }
 
     return virtualStartingRect;
 }
 
 LayoutRect virtualRectForAreaElementAndDirection(HTMLAreaElement& area, WebFocusType type)
 {
     ASSERT(area.imageElement());
     // Area elements tend to overlap more than other focusable elements. We flatten the rect of the area elements
     // to minimize the effect of overlapping areas.
-    LayoutRect rect = virtualRectForDirection(type, rectToAbsoluteCoordinates(area.document().frame(), area.computeRect(area.imageElement()->renderer())), 1);
+    LayoutRect rect = virtualRectForDirection(type, rectToAbsoluteCoordinates(area.document().frame(), area.computeRect(area.imageElement()->layoutObject())), 1);
     return rect;
 }
 
 HTMLFrameOwnerElement* frameOwnerElement(FocusCandidate& candidate)
 {
     return candidate.isFrameOwnerElement() ? toHTMLFrameOwnerElement(candidate.visibleNode) : nullptr;
 };
 
 } // namespace blink