Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * 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 150 matching lines @@
 enum NoCursorChangeType { kNoCursorChange };
 
 class OptionalCursor {
  public:
   OptionalCursor(NoCursorChangeType) : is_cursor_change_(false) {}
   OptionalCursor(const Cursor& cursor)
       : is_cursor_change_(true), cursor_(cursor) {}
 
   bool IsCursorChange() const { return is_cursor_change_; }
   const Cursor& GetCursor() const {
-    ASSERT(is_cursor_change_);
+    DCHECK(is_cursor_change_);
     return cursor_;
   }
 
  private:
   bool is_cursor_change_;
   Cursor cursor_;
 };
 
 EventHandler::EventHandler(LocalFrame& frame)
     : frame_(frame),
@@ skipping 179 matching lines @@
 }
 
 bool EventHandler::UseHandCursor(Node* node, bool is_over_link) {
   if (!node)
     return false;
 
   return ((is_over_link || IsSubmitImage(node)) && !HasEditableStyle(*node));
 }
 
 void EventHandler::CursorUpdateTimerFired(TimerBase*) {
-  ASSERT(frame_);
-  ASSERT(frame_->GetDocument());
+  DCHECK(frame_);
+  DCHECK(frame_->GetDocument());
 
   UpdateCursor();
 }
 
 void EventHandler::UpdateCursor() {
   TRACE_EVENT0("input", "EventHandler::updateCursor");
 
   // We must do a cross-frame hit test because the frame that triggered the
   // cursor update could be occluded by a different frame.
   DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
@@ skipping 402 matching lines @@
     page->GetChromeClient().ClearToolTip(*frame_);
   HandleMouseMoveOrLeaveEvent(event, Vector<WebMouseEvent>(), 0, false, true);
 }
 
 WebInputEventResult EventHandler::HandleMouseMoveOrLeaveEvent(
     const WebMouseEvent& mouse_event,
     const Vector<WebMouseEvent>& coalesced_events,
     HitTestResult* hovered_node,
     bool only_update_scrollbars,
     bool force_leave) {
-  ASSERT(frame_);
-  ASSERT(frame_->View());
+  DCHECK(frame_);
+  DCHECK(frame_->View());
 
   mouse_event_manager_->SetLastKnownMousePosition(mouse_event);
 
   hover_timer_.Stop();
   cursor_update_timer_.Stop();
 
   mouse_event_manager_->CancelFakeMouseMoveEvent();
   mouse_event_manager_->HandleSvgPanIfNeeded(false);
 
   if (frame_set_being_resized_) {
     return UpdatePointerTargetAndDispatchEvents(
         EventTypeNames::mousemove, frame_set_being_resized_.Get(), String(),
         mouse_event, coalesced_events);
   }
 
   // Send events right to a scrollbar if the mouse is pressed.
   if (last_scrollbar_under_mouse_ && mouse_event_manager_->MousePressed()) {
     last_scrollbar_under_mouse_->MouseMoved(mouse_event);
     return WebInputEventResult::kHandledSystem;
   }
 
   // Mouse events simulated from touch should not hit-test again.
-  ASSERT(!mouse_event.FromTouch());
+  DCHECK(!mouse_event.FromTouch());
 
   HitTestRequest::HitTestRequestType hit_type = HitTestRequest::kMove;
   if (mouse_event_manager_->MousePressed()) {
     hit_type |= HitTestRequest::kActive;
   } else if (only_update_scrollbars) {
     // Mouse events should be treated as "read-only" if we're updating only
     // scrollbars. This means that :hover and :active freeze in the state they
     // were in, rather than updating for nodes the mouse moves while the window
     // is not key (which will be the case if onlyUpdateScrollbars is true).
     hit_type |= HitTestRequest::kReadOnly;
@@ skipping 121 matching lines @@
 
   if (last_scrollbar_under_mouse_) {
     mouse_event_manager_->InvalidateClick();
     last_scrollbar_under_mouse_->MouseUp(mouse_event);
     return UpdatePointerTargetAndDispatchEvents(
         EventTypeNames::mouseup, mouse_event_manager_->GetNodeUnderMouse(),
         String(), mouse_event, Vector<WebMouseEvent>());
   }
 
   // Mouse events simulated from touch should not hit-test again.
-  ASSERT(!mouse_event.FromTouch());
+  DCHECK(!mouse_event.FromTouch());
 
   HitTestRequest::HitTestRequestType hit_type = HitTestRequest::kRelease;
   HitTestRequest request(hit_type);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::PerformMouseEventHitTest(frame_, request, mouse_event);
   Element* mouse_release_target = mev.InnerElement();
   LocalFrame* subframe =
       capturing_mouse_events_node_.Get()
           ? SubframeForTargetNode(capturing_mouse_events_node_.Get())
           : SubframeForHitTestResult(mev);
@@ skipping 362 matching lines @@
   TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
   if (!frame_->GetPage())
     return WebInputEventResult::kNotHandled;
 
   // Propagation to inner frames is handled below this function.
   DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   // Non-scrolling related gesture events do a single cross-frame hit-test and
   // jump directly to the inner most frame. This matches handleMousePressEvent
   // etc.
-  ASSERT(!targeted_event.Event().IsScrollEvent());
+  DCHECK(!targeted_event.Event().IsScrollEvent());
 
   // Update mouseout/leave/over/enter events before jumping directly to the
   // inner most frame.
   if (targeted_event.Event().GetType() == WebInputEvent::kGestureTap)
     UpdateGestureTargetNodeForMouseEvent(targeted_event);
 
   // Route to the correct frame.
   if (LocalFrame* inner_frame =
           targeted_event.GetHitTestResult().InnerNodeFrame())
     return inner_frame->GetEventHandler().HandleGestureEventInFrame(
@@ skipping 41 matching lines @@
   return !event.TapAreaInRootFrame().IsEmpty();
 }
 
 bool EventHandler::BestClickableNodeForHitTestResult(
     const HitTestResult& result,
     IntPoint& target_point,
     Node*& target_node) {
   // FIXME: Unify this with the other best* functions which are very similar.
 
   TRACE_EVENT0("input", "EventHandler::bestClickableNodeForHitTestResult");
-  ASSERT(result.IsRectBasedTest());
+  DCHECK(result.IsRectBasedTest());
 
   // If the touch is over a scrollbar, don't adjust the touch point since touch
   // adjustment only takes into account DOM nodes so a touch over a scrollbar
   // will be adjusted towards nearby nodes. This leads to things like textarea
   // scrollbars being untouchable.
   if (result.GetScrollbar()) {
     target_node = 0;
     return false;
   }
 
   IntPoint touch_center =
       frame_->View()->ContentsToRootFrame(result.RoundedPointInMainFrame());
   IntRect touch_rect = frame_->View()->ContentsToRootFrame(
       result.GetHitTestLocation().BoundingBox());
 
   HeapVector<Member<Node>, 11> nodes;
   CopyToVector(result.ListBasedTestResult(), nodes);
 
   // FIXME: the explicit Vector conversion copies into a temporary and is
   // wasteful.
   return FindBestClickableCandidate(target_node, target_point, touch_center,
                                     touch_rect,
                                     HeapVector<Member<Node>>(nodes));
 }
 
 bool EventHandler::BestContextMenuNodeForHitTestResult(
     const HitTestResult& result,
     IntPoint& target_point,
     Node*& target_node) {
-  ASSERT(result.IsRectBasedTest());
+  DCHECK(result.IsRectBasedTest());
   IntPoint touch_center =
       frame_->View()->ContentsToRootFrame(result.RoundedPointInMainFrame());
   IntRect touch_rect = frame_->View()->ContentsToRootFrame(
       result.GetHitTestLocation().BoundingBox());
   HeapVector<Member<Node>, 11> nodes;
   CopyToVector(result.ListBasedTestResult(), nodes);
 
   // FIXME: the explicit Vector conversion copies into a temporary and is
   // wasteful.
   return FindBestContextMenuCandidate(target_node, target_point, touch_center,
@@ skipping 186 matching lines @@
   }
 }
 
 GestureEventWithHitTestResults EventHandler::TargetGestureEvent(
     const WebGestureEvent& gesture_event,
     bool read_only) {
   TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
   DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
   // Scrolling events get hit tested per frame (like wheel events do).
-  ASSERT(!gesture_event.IsScrollEvent());
+  DCHECK(!gesture_event.IsScrollEvent());
 
   HitTestRequest::HitTestRequestType hit_type =
       gesture_manager_->GetHitTypeForGestureType(gesture_event.GetType());
   TimeDelta active_interval;
   bool should_keep_active_for_min_interval = false;
   if (read_only) {
     hit_type |= HitTestRequest::kReadOnly;
   } else if (gesture_event.GetType() == WebInputEvent::kGestureTap &&
              gesture_manager_->GetLastShowPressTimestamp()) {
     // If the Tap is received very shortly after ShowPress, we want to
@@ skipping 65 matching lines @@
     hit_test_result = EventHandlingUtil::HitTestResultInFrame(
         hit_frame,
         hit_frame->View()->RootFrameToContents(
             FlooredIntPoint(adjusted_event.PositionInRootFrame())),
         (hit_type | HitTestRequest::kReadOnly) & ~HitTestRequest::kListBased);
   }
 
   // If we did a rect-based hit test it must be resolved to the best single node
   // by now to ensure consumers don't accidentally use one of the other
   // candidates.
-  ASSERT(!hit_test_result.IsRectBasedTest());
+  DCHECK(!hit_test_result.IsRectBasedTest());
 
   return GestureEventWithHitTestResults(adjusted_event, hit_test_result);
 }
 
 void EventHandler::ApplyTouchAdjustment(WebGestureEvent* gesture_event,
                                         HitTestResult* hit_test_result) {
   if (!ShouldApplyTouchAdjustment(*gesture_event))
     return;
 
   Node* adjusted_node = nullptr;
@@ skipping 189 matching lines @@
   frame_set_being_resized_ = frame_set;
 }
 
 void EventHandler::ResizeScrollableAreaDestroyed() {
   scroll_manager_->ClearResizeScrollableArea(true);
 }
 
 void EventHandler::HoverTimerFired(TimerBase*) {
   TRACE_EVENT0("input", "EventHandler::hoverTimerFired");
 
-  ASSERT(frame_);
-  ASSERT(frame_->GetDocument());
+  DCHECK(frame_);
+  DCHECK(frame_->GetDocument());
 
   if (LayoutViewItem layout_item = frame_->ContentLayoutItem()) {
     if (FrameView* view = frame_->View()) {
       HitTestRequest request(HitTestRequest::kMove);
       HitTestResult result(request,
                            view->RootFrameToContents(
                                mouse_event_manager_->LastKnownMousePosition()));
       layout_item.HitTest(result);
       frame_->GetDocument()->UpdateHoverActiveState(request,
                                                     result.InnerElement());
@@ skipping 166 matching lines @@
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   WebInputEventResult result =
       subframe->GetEventHandler().HandleMouseReleaseEvent(mev.Event());
   if (result != WebInputEventResult::kNotHandled)
     return result;
   return WebInputEventResult::kHandledSystem;
 }
 
 }  // namespace blink