Replace ASSERT with DCHECK in core/

third_party/WebKit/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 39 matching lines @@
                                             const LayoutRect&);
 static bool IsScrollableNode(const Node*);
 
 FocusCandidate::FocusCandidate(Node* node, WebFocusType type)
     : visible_node(nullptr),
       focusable_node(nullptr),
       enclosing_scrollable_box(nullptr),
       distance(MaxDistance()),
       is_offscreen(true),
       is_offscreen_after_scrolling(true) {
-  ASSERT(node);
-  ASSERT(node->IsElementNode());
+  DCHECK(node);
+  DCHECK(node->IsElementNode());
 
   if (isHTMLAreaElement(*node)) {
     HTMLAreaElement& area = toHTMLAreaElement(*node);
     HTMLImageElement* image = area.ImageElement();
     if (!image || !image->GetLayoutObject())
       return;
 
     visible_node = image;
     rect = VirtualRectForAreaElementAndDirection(area, type);
   } else {
@@ skipping 73 matching lines @@
 // document. In case it is, one can scroll in direction or take any different
 // desired action later on.
 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* frame_view = node->GetDocument().View();
   if (!frame_view)
     return true;
 
-  ASSERT(!frame_view->NeedsLayout());
+  DCHECK(!frame_view->NeedsLayout());
 
   LayoutRect container_viewport_rect(frame_view->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.
   int pixels_per_line_step =
       ScrollableArea::PixelsPerLineStep(frame_view->GetChromeClient());
   switch (type) {
     case kWebFocusTypeLeft:
@@ skipping 25 matching lines @@
     return true;
 
   LayoutRect rect(layout_object->AbsoluteVisualRect());
   if (rect.IsEmpty())
     return true;
 
   return !container_viewport_rect.Intersects(rect);
 }
 
 bool ScrollInDirection(LocalFrame* frame, WebFocusType type) {
-  ASSERT(frame);
+  DCHECK(frame);
 
   if (frame && CanScrollInDirection(frame->GetDocument(), type)) {
     int dx = 0;
     int dy = 0;
     int pixels_per_line_step =
         ScrollableArea::PixelsPerLineStep(frame->View()->GetChromeClient());
     switch (type) {
       case kWebFocusTypeLeft:
         dx = -pixels_per_line_step;
         break;
@@ skipping 11 matching lines @@
         return false;
     }
 
     frame->View()->ScrollBy(ScrollOffset(dx, dy), kUserScroll);
     return true;
   }
   return false;
 }
 
 bool ScrollInDirection(Node* container, WebFocusType type) {
-  ASSERT(container);
+  DCHECK(container);
   if (container->IsDocumentNode())
     return ScrollInDirection(ToDocument(container)->GetFrame(), type);
 
   if (!container->GetLayoutBox())
     return false;
 
   if (CanScrollInDirection(container, type)) {
     int dx = 0;
     int dy = 0;
     // TODO(leviw): Why are these values truncated (toInt) instead of rounding?
@@ skipping 41 matching lines @@
   if ((a.Width() + 2 * deflate_factor > 0) &&
       (a.Height() + 2 * deflate_factor > 0))
     a.Inflate(deflate_factor);
 
   if ((b.Width() + 2 * deflate_factor > 0) &&
       (b.Height() + 2 * deflate_factor > 0))
     b.Inflate(deflate_factor);
 }
 
 bool IsScrollableNode(const Node* node) {
-  ASSERT(!node->IsDocumentNode());
+  DCHECK(!node->IsDocumentNode());
 
   if (!node)
     return false;
 
   if (LayoutObject* layout_object = node->GetLayoutObject())
     return layout_object->IsBox() &&
            ToLayoutBox(layout_object)->CanBeScrolledAndHasScrollableArea() &&
            node->hasChildren();
 
   return false;
 }
 
 Node* ScrollableEnclosingBoxOrParentFrameForNodeInDirection(WebFocusType type,
                                                             Node* node) {
-  ASSERT(node);
+  DCHECK(node);
   Node* parent = node;
   do {
     // FIXME: Spatial navigation is broken for OOPI.
     if (parent->IsDocumentNode())
       parent = ToDocument(parent)->GetFrame()->DeprecatedLocalOwner();
     else
       parent = parent->ParentOrShadowHostNode();
   } while (parent && !CanScrollInDirection(parent, type) &&
            !parent->IsDocumentNode());
 
   return parent;
 }
 
 bool CanScrollInDirection(const Node* container, WebFocusType type) {
-  ASSERT(container);
+  DCHECK(container);
   if (container->IsDocumentNode())
     return CanScrollInDirection(ToDocument(container)->GetFrame(), type);
 
   if (!IsScrollableNode(container))
     return false;
 
   switch (type) {
     case kWebFocusTypeLeft:
       return (container->GetLayoutObject()->Style()->OverflowX() !=
                   EOverflow::kHidden &&
@@ skipping 333 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 
   return virtual_starting_rect;
 }
 
 LayoutRect VirtualRectForAreaElementAndDirection(HTMLAreaElement& area,
                                                  WebFocusType type) {
-  ASSERT(area.ImageElement());
+  DCHECK(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.GetDocument().GetFrame(),
           area.ComputeAbsoluteRect(area.ImageElement()->GetLayoutObject())),
       LayoutUnit(1));
   return rect;
 }
 
 HTMLFrameOwnerElement* FrameOwnerElement(FocusCandidate& candidate) {
   return candidate.IsFrameOwnerElement()
              ? ToHTMLFrameOwnerElement(candidate.visible_node)
              : nullptr;
 };
 
 }  // namespace blink