Replace ASSERT*() with DCHECK*() in core/events/.

third_party/WebKit/Source/core/events/EventDispatcher.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 28 matching lines @@
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 DispatchEventResult EventDispatcher::dispatchEvent(Node& node, EventDispatchMediator* mediator)
 {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.debug"), "EventDispatcher::dispatchEvent");
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
     EventDispatcher dispatcher(node, &mediator->event());
     return mediator->dispatchEvent(dispatcher);
 }
 
 EventDispatcher::EventDispatcher(Node& node, Event* event)
     : m_node(node)
     , m_event(event)
-#if ENABLE(ASSERT)
-    , m_eventDispatched(false)
-#endif
 {
-    ASSERT(m_event.get());
+    DCHECK(m_event.get());
     m_view = node.document().view();
     m_event->initEventPath(*m_node);
 }
 
 void EventDispatcher::dispatchScopedEvent(Node& node, EventDispatchMediator* mediator)
 {
     // We need to set the target here because it can go away by the time we actually fire the event.
     mediator->event().setTarget(EventPath::eventTargetRespectingTargetRules(node));
     ScopedEventQueue::instance()->enqueueEventDispatchMediator(mediator);
 }
@@ skipping 28 matching lines @@
     // always send click
     EventDispatcher(node, MouseEvent::create(EventTypeNames::click, node.document().domWindow(), underlyingEvent, creationScope)).dispatch();
 
     nodesDispatchingSimulatedClicks.remove(&node);
 }
 
 DispatchEventResult EventDispatcher::dispatch()
 {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.debug"), "EventDispatcher::dispatch");
 
-#if ENABLE(ASSERT)
-    ASSERT(!m_eventDispatched);
+#if DCHECK_IS_ON()
+    DCHECK(!m_eventDispatched);
     m_eventDispatched = true;
 #endif
     if (event().eventPath().isEmpty()) {
         // eventPath() can be empty if event path is shrinked by relataedTarget retargeting.
         return DispatchEventResult::NotCanceled;
     }
     m_event->eventPath().ensureWindowEventContext();
 
     m_event->setTarget(EventPath::eventTargetRespectingTargetRules(*m_node));
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
-    ASSERT(m_event->target());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(m_event->target());
     TRACE_EVENT1("devtools.timeline", "EventDispatch", "data", InspectorEventDispatchEvent::data(*m_event));
     EventDispatchHandlingState* preDispatchEventHandlerResult = nullptr;
     if (dispatchEventPreProcess(preDispatchEventHandlerResult) == ContinueDispatching) {
         if (dispatchEventAtCapturing() == ContinueDispatching) {
             if (dispatchEventAtTarget() == ContinueDispatching)
                 dispatchEventAtBubbling();
         }
     }
     dispatchEventPostProcess(preDispatchEventHandlerResult);
 
@@ skipping 87 matching lines @@
     // should not have their default handlers invoked.
     bool isTrustedOrClick = !RuntimeEnabledFeatures::trustedEventsDefaultActionEnabled() || m_event->isTrusted() || isClick;
 
     // Call default event handlers. While the DOM does have a concept of preventing
     // default handling, the detail of which handlers are called is an internal
     // implementation detail and not part of the DOM.
     if (!m_event->defaultPrevented() && !m_event->defaultHandled() && isTrustedOrClick) {
         // Non-bubbling events call only one default event handler, the one for the target.
         m_node->willCallDefaultEventHandler(*m_event);
         m_node->defaultEventHandler(m_event.get());
-        ASSERT(!m_event->defaultPrevented());
+        DCHECK(!m_event->defaultPrevented());
         // For bubbling events, call default event handlers on the same targets in the
         // same order as the bubbling phase.
         if (!m_event->defaultHandled() && m_event->bubbles()) {
             size_t size = m_event->eventPath().size();
             for (size_t i = 1; i < size; ++i) {
                 m_event->eventPath()[i].node()->willCallDefaultEventHandler(*m_event);
                 m_event->eventPath()[i].node()->defaultEventHandler(m_event.get());
-                ASSERT(!m_event->defaultPrevented());
+                DCHECK(!m_event->defaultPrevented());
                 if (m_event->defaultHandled())
                     break;
             }
         }
         if (m_event->defaultHandled() && !m_event->isTrusted() && !isClick)
             Deprecation::countDeprecation(m_node->document(), UseCounter::UntrustedEventDefaultHandled);
     }
 }
 
 } // namespace blink