Propagate focus type to plugins

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 27 matching lines @@
 #include "core/html/HTMLImageElement.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderLayer.h"
 #include "platform/geometry/IntRect.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static RectsAlignment alignmentForRects(FocusType, const LayoutRect&, const LayoutRect&, const LayoutSize& viewSize);
-static bool areRectsFullyAligned(FocusType, const LayoutRect&, const LayoutRect&);
-static bool areRectsPartiallyAligned(FocusType, const LayoutRect&, const LayoutRect&);
-static bool areRectsMoreThanFullScreenApart(FocusType, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize);
-static bool isRectInDirection(FocusType, const LayoutRect&, const LayoutRect&);
+static RectsAlignment alignmentForRects(WebFocusType, const LayoutRect&, const LayoutRect&, const LayoutSize& viewSize);
+static bool areRectsFullyAligned(WebFocusType, const LayoutRect&, const LayoutRect&);
+static bool areRectsPartiallyAligned(WebFocusType, const LayoutRect&, const LayoutRect&);
+static bool areRectsMoreThanFullScreenApart(WebFocusType, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize);
+static bool isRectInDirection(WebFocusType, const LayoutRect&, const LayoutRect&);
 static void deflateIfOverlapped(LayoutRect&, LayoutRect&);
 static LayoutRect rectToAbsoluteCoordinates(LocalFrame* initialFrame, const LayoutRect&);
 static bool isScrollableNode(const Node*);
 
-FocusCandidate::FocusCandidate(Node* node, FocusType type)
+FocusCandidate::FocusCandidate(Node* node, WebFocusType type)
     : visibleNode(nullptr)
     , focusableNode(nullptr)
     , enclosingScrollableBox(nullptr)
     , distance(maxDistance())
     , alignment(None)
     , isOffscreen(true)
     , isOffscreenAfterScrolling(true)
 {
     ASSERT(node);
     ASSERT(node->isElementNode());
@@ skipping 17 matching lines @@
     focusableNode = node;
     isOffscreen = hasOffscreenRect(visibleNode);
     isOffscreenAfterScrolling = hasOffscreenRect(visibleNode, type);
 }
 
 bool isSpatialNavigationEnabled(const LocalFrame* frame)
 {
     return (frame && frame->settings() && frame->settings()->spatialNavigationEnabled());
 }
 
-static RectsAlignment alignmentForRects(FocusType type, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
+static RectsAlignment alignmentForRects(WebFocusType type, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
 {
     // If we found a node in full alignment, but it is too far away, ignore it.
     if (areRectsMoreThanFullScreenApart(type, curRect, targetRect, viewSize))
         return None;
 
     if (areRectsFullyAligned(type, curRect, targetRect))
         return Full;
 
     if (areRectsPartiallyAligned(type, curRect, targetRect))
         return Partial;
 
     return None;
 }
 
-static inline bool isHorizontalMove(FocusType type)
+static inline bool isHorizontalMove(WebFocusType type)
 {
-    return type == FocusTypeLeft || type == FocusTypeRight;
+    return type == WebFocusTypeLeft || type == WebFocusTypeRight;
 }
 
-static inline LayoutUnit start(FocusType type, const LayoutRect& rect)
+static inline LayoutUnit start(WebFocusType type, const LayoutRect& rect)
 {
     return isHorizontalMove(type) ? rect.y() : rect.x();
 }
 
-static inline LayoutUnit middle(FocusType type, const LayoutRect& rect)
+static inline LayoutUnit middle(WebFocusType type, const LayoutRect& rect)
 {
     LayoutPoint center(rect.center());
     return isHorizontalMove(type) ? center.y(): center.x();
 }
 
-static inline LayoutUnit end(FocusType type, const LayoutRect& rect)
+static inline LayoutUnit end(WebFocusType type, const LayoutRect& rect)
 {
     return isHorizontalMove(type) ? rect.maxY() : rect.maxX();
 }
 
 // This method checks if rects |a| and |b| are fully aligned either vertically or
 // horizontally. In general, rects whose central point falls between the top or
 // bottom of each other are considered fully aligned.
 // Rects that match this criteria are preferable target nodes in move focus changing
 // operations.
 // * a = Current focused node's rect.
 // * b = Focus candidate node's rect.
-static bool areRectsFullyAligned(FocusType type, const LayoutRect& a, const LayoutRect& b)
+static bool areRectsFullyAligned(WebFocusType type, const LayoutRect& a, const LayoutRect& b)
 {
     LayoutUnit aStart, bStart, aEnd, bEnd;
 
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         aStart = a.x();
         bEnd = b.x();
         break;
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         aStart = b.x();
         bEnd = a.x();
         break;
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         aStart = a.y();
         bEnd = b.y();
         break;
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         aStart = b.y();
         bEnd = a.y();
         break;
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 
     if (aStart < bEnd)
         return false;
@@ skipping 24 matching lines @@
         || (aMiddle >= bStart && aMiddle <= bEnd); // (2)
 }
 
 // This method checks if rects |a| and |b| are partially aligned either vertically or
 // horizontally. In general, rects whose either of edges falls between the top or
 // bottom of each other are considered partially-aligned.
 // This is a separate set of conditions from "fully-aligned" and do not include cases
 // that satisfy the former.
 // * a = Current focused node's rect.
 // * b = Focus candidate node's rect.
-static bool areRectsPartiallyAligned(FocusType type, const LayoutRect& a, const LayoutRect& b)
+static bool areRectsPartiallyAligned(WebFocusType type, const LayoutRect& a, const LayoutRect& b)
 {
     LayoutUnit aStart  = start(type, a);
     LayoutUnit bStart  = start(type, b);
     LayoutUnit aEnd = end(type, a);
     LayoutUnit bEnd = end(type, b);
 
     // Picture of the partially aligned logic:
     //
     //    Horizontal       Vertical
     // ********************************
     // *  _            *   _ _ _      *
     // * |_|           *  |_|_|_|     *
     // * |_|.... _     *      . .     *
     // * |_|    |_|    *      . .     *
     // * |_|....|_|    *      ._._ _  *
     // *        |_|    *      |_|_|_| *
     // *        |_|    *              *
     // *               *              *
     // ********************************
     //
     // ... and variants of the above cases.
     return (bStart >= aStart && bStart <= aEnd)
         || (bEnd >= aStart && bEnd <= aEnd);
 }
 
-static bool areRectsMoreThanFullScreenApart(FocusType type, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
+static bool areRectsMoreThanFullScreenApart(WebFocusType type, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
 {
     ASSERT(isRectInDirection(type, curRect, targetRect));
 
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         return curRect.x() - targetRect.maxX() > viewSize.width();
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         return targetRect.x() - curRect.maxX() > viewSize.width();
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         return curRect.y() - targetRect.maxY() > viewSize.height();
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         return targetRect.y() - curRect.maxY() > viewSize.height();
     default:
         ASSERT_NOT_REACHED();
         return true;
     }
 }
 
 // Return true if rect |a| is below |b|. False otherwise.
 // For overlapping rects, |a| is considered to be below |b|
 // if both edges of |a| are below the respective ones of |b|
 static inline bool below(const LayoutRect& a, const LayoutRect& b)
 {
     return a.y() >= b.maxY()
         || (a.y() >= b.y() && a.maxY() > b.maxY() && a.x() < b.maxX() && a.maxX() > b.x());
 }
 
 // Return true if rect |a| is on the right of |b|. False otherwise.
 // For overlapping rects, |a| is considered to be on the right of |b|
 // if both edges of |a| are on the right of the respective ones of |b|
 static inline bool rightOf(const LayoutRect& a, const LayoutRect& b)
 {
     return a.x() >= b.maxX()
         || (a.x() >= b.x() && a.maxX() > b.maxX() && a.y() < b.maxY() && a.maxY() > b.y());
 }
 
-static bool isRectInDirection(FocusType type, const LayoutRect& curRect, const LayoutRect& targetRect)
+static bool isRectInDirection(WebFocusType type, const LayoutRect& curRect, const LayoutRect& targetRect)
 {
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         return rightOf(curRect, targetRect);
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         return rightOf(targetRect, curRect);
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         return below(curRect, targetRect);
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         return below(targetRect, curRect);
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 }
 
 // Checks if |node| is offscreen the visible area (viewport) of its container
 // document. In case it is, one can scroll in direction or take any different
 // desired action later on.
-bool hasOffscreenRect(Node* node, FocusType type)
+bool hasOffscreenRect(Node* node, WebFocusType type)
 {
     // Get the FrameView in which |node| is (which means the current viewport if |node|
     // is not in an inner document), so we can check if its content rect is visible
     // before we actually move the focus to it.
     FrameView* frameView = node->document().view();
     if (!frameView)
         return true;
 
     ASSERT(!frameView->needsLayout());
 
     LayoutRect containerViewportRect = frameView->visibleContentRect();
     // We want to select a node if it is currently off screen, but will be
     // exposed after we scroll. Adjust the viewport to post-scrolling position.
     // If the container has overflow:hidden, we cannot scroll, so we do not pass direction
     // and we do not adjust for scrolling.
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         containerViewportRect.setX(containerViewportRect.x() - ScrollableArea::pixelsPerLineStep());
         containerViewportRect.setWidth(containerViewportRect.width() + ScrollableArea::pixelsPerLineStep());
         break;
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         containerViewportRect.setWidth(containerViewportRect.width() + ScrollableArea::pixelsPerLineStep());
         break;
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         containerViewportRect.setY(containerViewportRect.y() - ScrollableArea::pixelsPerLineStep());
         containerViewportRect.setHeight(containerViewportRect.height() + ScrollableArea::pixelsPerLineStep());
         break;
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         containerViewportRect.setHeight(containerViewportRect.height() + ScrollableArea::pixelsPerLineStep());
         break;
     default:
         break;
     }
 
     RenderObject* render = node->renderer();
     if (!render)
         return true;
 
     LayoutRect rect(render->absoluteClippedOverflowRect());
     if (rect.isEmpty())
         return true;
 
     return !containerViewportRect.intersects(rect);
 }
 
-bool scrollInDirection(LocalFrame* frame, FocusType type)
+bool scrollInDirection(LocalFrame* frame, WebFocusType type)
 {
     ASSERT(frame);
 
     if (frame && canScrollInDirection(frame->document(), type)) {
         LayoutUnit dx = 0;
         LayoutUnit dy = 0;
         switch (type) {
-        case FocusTypeLeft:
+        case WebFocusTypeLeft:
             dx = - ScrollableArea::pixelsPerLineStep();
             break;
-        case FocusTypeRight:
+        case WebFocusTypeRight:
             dx = ScrollableArea::pixelsPerLineStep();
             break;
-        case FocusTypeUp:
+        case WebFocusTypeUp:
             dy = - ScrollableArea::pixelsPerLineStep();
             break;
-        case FocusTypeDown:
+        case WebFocusTypeDown:
             dy = ScrollableArea::pixelsPerLineStep();
             break;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
 
         frame->view()->scrollBy(IntSize(dx, dy));
         return true;
     }
     return false;
 }
 
-bool scrollInDirection(Node* container, FocusType type)
+bool scrollInDirection(Node* container, WebFocusType type)
 {
     ASSERT(container);
     if (container->isDocumentNode())
         return scrollInDirection(toDocument(container)->frame(), type);
 
     if (!container->renderBox())
         return false;
 
     if (canScrollInDirection(container, type)) {
         LayoutUnit dx = 0;
         LayoutUnit dy = 0;
         switch (type) {
-        case FocusTypeLeft:
+        case WebFocusTypeLeft:
             dx = - std::min<LayoutUnit>(ScrollableArea::pixelsPerLineStep(), container->renderBox()->scrollLeft());
             break;
-        case FocusTypeRight:
+        case WebFocusTypeRight:
             ASSERT(container->renderBox()->scrollWidth() > (container->renderBox()->scrollLeft() + container->renderBox()->clientWidth()));
             dx = std::min<LayoutUnit>(ScrollableArea::pixelsPerLineStep(), container->renderBox()->scrollWidth() - (container->renderBox()->scrollLeft() + container->renderBox()->clientWidth()));
             break;
-        case FocusTypeUp:
+        case WebFocusTypeUp:
             dy = - std::min<LayoutUnit>(ScrollableArea::pixelsPerLineStep(), container->renderBox()->scrollTop());
             break;
-        case FocusTypeDown:
+        case WebFocusTypeDown:
             ASSERT(container->renderBox()->scrollHeight() - (container->renderBox()->scrollTop() + container->renderBox()->clientHeight()));
             dy = std::min<LayoutUnit>(ScrollableArea::pixelsPerLineStep(), container->renderBox()->scrollHeight() - (container->renderBox()->scrollTop() + container->renderBox()->clientHeight()));
             break;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
 
         container->renderBox()->scrollByRecursively(IntSize(dx, dy));
         return true;
@@ skipping 23 matching lines @@
 
     if (!node)
         return false;
 
     if (RenderObject* renderer = node->renderer())
         return renderer->isBox() && toRenderBox(renderer)->canBeScrolledAndHasScrollableArea() && node->hasChildren();
 
     return false;
 }
 
-Node* scrollableEnclosingBoxOrParentFrameForNodeInDirection(FocusType type, Node* node)
+Node* scrollableEnclosingBoxOrParentFrameForNodeInDirection(WebFocusType type, Node* node)
 {
     ASSERT(node);
     Node* parent = node;
     do {
         // FIXME: Spatial navigation is broken for OOPI.
         if (parent->isDocumentNode())
             parent = toDocument(parent)->frame()->deprecatedLocalOwner();
         else
             parent = parent->parentOrShadowHostNode();
     } while (parent && !canScrollInDirection(parent, type) && !parent->isDocumentNode());
 
     return parent;
 }
 
-bool canScrollInDirection(const Node* container, FocusType type)
+bool canScrollInDirection(const Node* container, WebFocusType type)
 {
     ASSERT(container);
     if (container->isDocumentNode())
         return canScrollInDirection(toDocument(container)->frame(), type);
 
     if (!isScrollableNode(container))
         return false;
 
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         return (container->renderer()->style()->overflowX() != OHIDDEN && container->renderBox()->scrollLeft() > 0);
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         return (container->renderer()->style()->overflowY() != OHIDDEN && container->renderBox()->scrollTop() > 0);
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         return (container->renderer()->style()->overflowX() != OHIDDEN && container->renderBox()->scrollLeft() + container->renderBox()->clientWidth() < container->renderBox()->scrollWidth());
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         return (container->renderer()->style()->overflowY() != OHIDDEN && container->renderBox()->scrollTop() + container->renderBox()->clientHeight() < container->renderBox()->scrollHeight());
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 }
 
-bool canScrollInDirection(const LocalFrame* frame, FocusType type)
+bool canScrollInDirection(const LocalFrame* frame, WebFocusType type)
 {
     if (!frame->view())
         return false;
     ScrollbarMode verticalMode;
     ScrollbarMode horizontalMode;
     frame->view()->calculateScrollbarModesForLayoutAndSetViewportRenderer(horizontalMode, verticalMode);
-    if ((type == FocusTypeLeft || type == FocusTypeRight) && ScrollbarAlwaysOff == horizontalMode)
+    if ((type == WebFocusTypeLeft || type == WebFocusTypeRight) && ScrollbarAlwaysOff == horizontalMode)
         return false;
-    if ((type == FocusTypeUp || type == FocusTypeDown) &&  ScrollbarAlwaysOff == verticalMode)
+    if ((type == WebFocusTypeUp || type == WebFocusTypeDown) &&  ScrollbarAlwaysOff == verticalMode)
         return false;
     LayoutSize size(frame->view()->contentsSize());
     LayoutSize offset(frame->view()->scrollOffset());
     LayoutRect rect(frame->view()->visibleContentRect(IncludeScrollbars));
 
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         return offset.width() > 0;
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         return offset.height() > 0;
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         return rect.width() + offset.width() < size.width();
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         return rect.height() + offset.height() < size.height();
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 }
 
 static LayoutRect rectToAbsoluteCoordinates(LocalFrame* initialFrame, const LayoutRect& initialRect)
 {
     LayoutRect rect = initialRect;
@@ skipping 31 matching lines @@
 
 LayoutRect frameRectInAbsoluteCoordinates(LocalFrame* frame)
 {
     return rectToAbsoluteCoordinates(frame, frame->view()->visibleContentRect());
 }
 
 // This method calculates the exitPoint from the startingRect and the entryPoint into the candidate rect.
 // The line between those 2 points is the closest distance between the 2 rects.
 // Takes care of overlapping rects, defining points so that the distance between them
 // is zero where necessary
-void entryAndExitPointsForDirection(FocusType type, const LayoutRect& startingRect, const LayoutRect& potentialRect, LayoutPoint& exitPoint, LayoutPoint& entryPoint)
+void entryAndExitPointsForDirection(WebFocusType type, const LayoutRect& startingRect, const LayoutRect& potentialRect, LayoutPoint& exitPoint, LayoutPoint& entryPoint)
 {
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         exitPoint.setX(startingRect.x());
         if (potentialRect.maxX() < startingRect.x())
             entryPoint.setX(potentialRect.maxX());
         else
             entryPoint.setX(startingRect.x());
         break;
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         exitPoint.setY(startingRect.y());
         if (potentialRect.maxY() < startingRect.y())
             entryPoint.setY(potentialRect.maxY());
         else
             entryPoint.setY(startingRect.y());
         break;
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         exitPoint.setX(startingRect.maxX());
         if (potentialRect.x() > startingRect.maxX())
             entryPoint.setX(potentialRect.x());
         else
             entryPoint.setX(startingRect.maxX());
         break;
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         exitPoint.setY(startingRect.maxY());
         if (potentialRect.y() > startingRect.maxY())
             entryPoint.setY(potentialRect.y());
         else
             entryPoint.setY(startingRect.maxY());
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     switch (type) {
-    case FocusTypeLeft:
-    case FocusTypeRight:
+    case WebFocusTypeLeft:
+    case WebFocusTypeRight:
         if (below(startingRect, potentialRect)) {
             exitPoint.setY(startingRect.y());
             if (potentialRect.maxY() < startingRect.y())
                 entryPoint.setY(potentialRect.maxY());
             else
                 entryPoint.setY(startingRect.y());
         } else if (below(potentialRect, startingRect)) {
             exitPoint.setY(startingRect.maxY());
             if (potentialRect.y() > startingRect.maxY())
                 entryPoint.setY(potentialRect.y());
             else
                 entryPoint.setY(startingRect.maxY());
         } else {
             exitPoint.setY(max(startingRect.y(), potentialRect.y()));
             entryPoint.setY(exitPoint.y());
         }
         break;
-    case FocusTypeUp:
-    case FocusTypeDown:
+    case WebFocusTypeUp:
+    case WebFocusTypeDown:
         if (rightOf(startingRect, potentialRect)) {
             exitPoint.setX(startingRect.x());
             if (potentialRect.maxX() < startingRect.x())
                 entryPoint.setX(potentialRect.maxX());
             else
                 entryPoint.setX(startingRect.x());
         } else if (rightOf(potentialRect, startingRect)) {
             exitPoint.setX(startingRect.maxX());
             if (potentialRect.x() > startingRect.maxX())
                 entryPoint.setX(potentialRect.x());
@@ skipping 25 matching lines @@
 
     if (!firstCandidate.visibleNode->renderer()->isRenderInline() || !secondCandidate.visibleNode->renderer()->isRenderInline())
         return false;
 
     if (firstCandidate.visibleNode->renderer()->containingBlock() != secondCandidate.visibleNode->renderer()->containingBlock())
         return false;
 
     return true;
 }
 
-void distanceDataForNode(FocusType type, const FocusCandidate& current, FocusCandidate& candidate)
+void distanceDataForNode(WebFocusType type, const FocusCandidate& current, FocusCandidate& candidate)
 {
     if (areElementsOnSameLine(current, candidate)) {
-        if ((type == FocusTypeUp && current.rect.y() > candidate.rect.y()) || (type == FocusTypeDown && candidate.rect.y() > current.rect.y())) {
+        if ((type == WebFocusTypeUp && current.rect.y() > candidate.rect.y()) || (type == WebFocusTypeDown && candidate.rect.y() > current.rect.y())) {
             candidate.distance = 0;
             candidate.alignment = Full;
             return;
         }
     }
 
     LayoutRect nodeRect = candidate.rect;
     LayoutRect currentRect = current.rect;
     deflateIfOverlapped(currentRect, nodeRect);
 
     if (!isRectInDirection(type, currentRect, nodeRect))
         return;
 
     LayoutPoint exitPoint;
     LayoutPoint entryPoint;
     entryAndExitPointsForDirection(type, currentRect, nodeRect, exitPoint, entryPoint);
 
     LayoutUnit xAxis = exitPoint.x() - entryPoint.x();
     LayoutUnit yAxis = exitPoint.y() - entryPoint.y();
 
     LayoutUnit navigationAxisDistance;
     LayoutUnit orthogonalAxisDistance;
 
     switch (type) {
-    case FocusTypeLeft:
-    case FocusTypeRight:
+    case WebFocusTypeLeft:
+    case WebFocusTypeRight:
         navigationAxisDistance = xAxis.abs();
         orthogonalAxisDistance = yAxis.abs();
         break;
-    case FocusTypeUp:
-    case FocusTypeDown:
+    case WebFocusTypeUp:
+    case WebFocusTypeDown:
         navigationAxisDistance = yAxis.abs();
         orthogonalAxisDistance = xAxis.abs();
         break;
     default:
         ASSERT_NOT_REACHED();
         return;
     }
 
     double euclidianDistancePow2 = (xAxis * xAxis + yAxis * yAxis).toDouble();
     LayoutRect intersectionRect = intersection(currentRect, nodeRect);
     double overlap = (intersectionRect.width() * intersectionRect.height()).toDouble();
 
     // Distance calculation is based on http://www.w3.org/TR/WICD/#focus-handling
     candidate.distance = sqrt(euclidianDistancePow2) + navigationAxisDistance+ orthogonalAxisDistance * 2 - sqrt(overlap);
 
     LayoutSize viewSize = LayoutSize(candidate.visibleNode->document().page()->deprecatedLocalMainFrame()->view()->visibleContentRect().size());
     candidate.alignment = alignmentForRects(type, currentRect, nodeRect, viewSize);
 }
 
-bool canBeScrolledIntoView(FocusType type, const FocusCandidate& candidate)
+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 == FocusTypeLeft || type == FocusTypeRight) && parentNode->renderer()->style()->overflowX() == OHIDDEN)
-                || ((type == FocusTypeUp || type == FocusTypeDown) && parentNode->renderer()->style()->overflowY() == OHIDDEN))
+            if (((type == WebFocusTypeLeft || type == WebFocusTypeRight) && parentNode->renderer()->style()->overflowX() == OHIDDEN)
+                || ((type == WebFocusTypeUp || type == WebFocusTypeDown) && parentNode->renderer()->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.
 // The virtual rect is the edge of the container or frame. We select which
 // edge depending on the direction of the navigation.
-LayoutRect virtualRectForDirection(FocusType type, const LayoutRect& startingRect, LayoutUnit width)
+LayoutRect virtualRectForDirection(WebFocusType type, const LayoutRect& startingRect, LayoutUnit width)
 {
     LayoutRect virtualStartingRect = startingRect;
     switch (type) {
-    case FocusTypeLeft:
+    case WebFocusTypeLeft:
         virtualStartingRect.setX(virtualStartingRect.maxX() - width);
         virtualStartingRect.setWidth(width);
         break;
-    case FocusTypeUp:
+    case WebFocusTypeUp:
         virtualStartingRect.setY(virtualStartingRect.maxY() - width);
         virtualStartingRect.setHeight(width);
         break;
-    case FocusTypeRight:
+    case WebFocusTypeRight:
         virtualStartingRect.setWidth(width);
         break;
-    case FocusTypeDown:
+    case WebFocusTypeDown:
         virtualStartingRect.setHeight(width);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     return virtualStartingRect;
 }
 
-LayoutRect virtualRectForAreaElementAndDirection(HTMLAreaElement& area, FocusType type)
+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);
     return rect;
 }
 
 HTMLFrameOwnerElement* frameOwnerElement(FocusCandidate& candidate)
 {
     return candidate.isFrameOwnerElement() ? toHTMLFrameOwnerElement(candidate.visibleNode) : nullptr;
 };
 
 } // namespace blink