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

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 24 matching lines @@
 #include "core/events/TouchEvent.h"
 #include "core/events/TouchEventContext.h"
 #include "core/html/HTMLSlotElement.h"
 #include "core/svg/SVGUseElement.h"
 
 namespace blink {
 
 EventTarget* EventPath::eventTargetRespectingTargetRules(Node& referenceNode)
 {
     if (referenceNode.isPseudoElement()) {
-        ASSERT(referenceNode.parentNode());
+        DCHECK(referenceNode.parentNode());
         return referenceNode.parentNode();
     }
 
     return &referenceNode;
 }
 
 static inline bool shouldStopAtShadowRoot(Event& event, ShadowRoot& shadowRoot, EventTarget& target)
 {
     if (shadowRoot.isV1()) {
         // In v1, an event is scoped by default unless event.composed flag is set.
@@ skipping 40 matching lines @@
     if (eventPathShouldBeEmptyFor(*m_node, m_event))
         return;
 
     calculatePath();
     calculateAdjustedTargets();
     calculateTreeOrderAndSetNearestAncestorClosedTree();
 }
 
 void EventPath::calculatePath()
 {
-    ASSERT(m_node);
-    ASSERT(m_nodeEventContexts.isEmpty());
+    DCHECK(m_node);
+    DCHECK(m_nodeEventContexts.isEmpty());
     m_node->updateDistribution();
 
     // For performance and memory usage reasons we want to store the
     // path using as few bytes as possible and with as few allocations
     // as possible which is why we gather the data on the stack before
     // storing it in a perfectly sized m_nodeEventContexts Vector.
     HeapVector<Member<Node>, 64> nodesInPath;
     Node* current = m_node;
 
     // Exclude nodes in SVG <use>'s shadow tree from event path.
     // See crbug.com/630870
     while (current->isSVGElement()) {
         SVGUseElement* correspondingUseElement = toSVGElement(current)->correspondingUseElement();
         if (!correspondingUseElement)
             break;
         current = correspondingUseElement;
     }
 
     nodesInPath.append(current);
     while (current) {
         if (m_event && current->keepEventInNode(m_event))
             break;
         HeapVector<Member<InsertionPoint>, 8> insertionPoints;
         collectDestinationInsertionPoints(*current, insertionPoints);
         if (!insertionPoints.isEmpty()) {
             for (const auto& insertionPoint : insertionPoints) {
                 if (insertionPoint->isShadowInsertionPoint()) {
                     ShadowRoot* containingShadowRoot = insertionPoint->containingShadowRoot();
-                    ASSERT(containingShadowRoot);
+                    DCHECK(containingShadowRoot);
                     if (!containingShadowRoot->isOldest())
                         nodesInPath.append(containingShadowRoot->olderShadowRoot());
                 }
                 nodesInPath.append(insertionPoint);
             }
             current = insertionPoints.last();
             continue;
         }
         if (current->isChildOfV1ShadowHost()) {
             if (HTMLSlotElement* slot = current->assignedSlot()) {
@@ skipping 28 matching lines @@
     HeapHashMap<Member<const TreeScope>, Member<TreeScopeEventContext>> treeScopeEventContextMap;
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts)
         treeScopeEventContextMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext.get());
     TreeScopeEventContext* rootTree = nullptr;
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         // Use olderShadowRootOrParentTreeScope here for parent-child relationships.
         // See the definition of trees of trees in the Shadow DOM spec:
         // http://w3c.github.io/webcomponents/spec/shadow/
         TreeScope* parent = treeScopeEventContext.get()->treeScope().olderShadowRootOrParentTreeScope();
         if (!parent) {
-            ASSERT(!rootTree);
+            DCHECK(!rootTree);
             rootTree = treeScopeEventContext.get();
             continue;
         }
+        // TODO(tkent): Add a stream printer for HashMap::iterator.
         ASSERT(treeScopeEventContextMap.find(parent) != treeScopeEventContextMap.end());
         treeScopeEventContextMap.find(parent)->value->addChild(*treeScopeEventContext.get());
     }
-    ASSERT(rootTree);
+    DCHECK(rootTree);
     rootTree->calculateTreeOrderAndSetNearestAncestorClosedTree(0, nullptr);
 }
 
 TreeScopeEventContext* EventPath::ensureTreeScopeEventContext(Node* currentTarget, TreeScope* treeScope, TreeScopeEventContextMap& treeScopeEventContextMap)
 {
     if (!treeScope)
         return nullptr;
     TreeScopeEventContext* treeScopeEventContext;
     bool isNewEntry;
     {
@@ skipping 22 matching lines @@
 
     TreeScopeEventContextMap treeScopeEventContextMap;
     TreeScopeEventContext* lastTreeScopeEventContext = nullptr;
 
     for (size_t i = 0; i < size(); ++i) {
         Node* currentNode = at(i).node();
         TreeScope& currentTreeScope = currentNode->treeScope();
         if (lastTreeScope != &currentTreeScope) {
             lastTreeScopeEventContext = ensureTreeScopeEventContext(currentNode, &currentTreeScope, treeScopeEventContextMap);
         }
-        ASSERT(lastTreeScopeEventContext);
+        DCHECK(lastTreeScopeEventContext);
         at(i).setTreeScopeEventContext(lastTreeScopeEventContext);
         lastTreeScope = &currentTreeScope;
     }
     m_treeScopeEventContexts.appendRange(treeScopeEventContextMap.values().begin(), treeScopeEventContextMap.values().end());
 }
 
 void EventPath::buildRelatedNodeMap(const Node& relatedNode, RelatedTargetMap& relatedTargetMap)
 {
     EventPath* relatedTargetEventPath = new EventPath(const_cast<Node&>(relatedNode));
     for (size_t i = 0; i < relatedTargetEventPath->m_treeScopeEventContexts.size(); ++i) {
@@ skipping 10 matching lines @@
     HeapVector<Member<TreeScope>, 32> parentTreeScopes;
     EventTarget* relatedNode = nullptr;
     for (TreeScope* current = &scope; current; current = current->olderShadowRootOrParentTreeScope()) {
         parentTreeScopes.append(current);
         RelatedTargetMap::const_iterator iter = relatedTargetMap.find(current);
         if (iter != relatedTargetMap.end() && iter->value) {
             relatedNode = iter->value;
             break;
         }
     }
-    ASSERT(relatedNode);
+    DCHECK(relatedNode);
     for (const auto& entry : parentTreeScopes)
         relatedTargetMap.add(entry, relatedNode);
 
     return relatedNode;
 }
 
 void EventPath::adjustForRelatedTarget(Node& target, EventTarget* relatedTarget)
 {
     if (!relatedTarget)
         return;
     Node* relatedNode = relatedTarget->toNode();
     if (!relatedNode)
         return;
     if (target.document() != relatedNode->document())
         return;
     retargetRelatedTarget(*relatedNode);
     shrinkForRelatedTarget(target, *relatedNode);
 }
 
 void EventPath::retargetRelatedTarget(const Node& relatedTargetNode)
 {
     RelatedTargetMap relatedNodeMap;
     buildRelatedNodeMap(relatedTargetNode, relatedNodeMap);
 
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         EventTarget* adjustedRelatedTarget = findRelatedNode(treeScopeEventContext->treeScope(), relatedNodeMap);
-        ASSERT(adjustedRelatedTarget);
+        DCHECK(adjustedRelatedTarget);
         treeScopeEventContext.get()->setRelatedTarget(adjustedRelatedTarget);
     }
 }
 
 void EventPath::shrinkForRelatedTarget(const Node& target, const Node& relatedTarget)
 {
     if (!target.isInShadowTree() && !relatedTarget.isInShadowTree())
         return;
     for (size_t i = 0; i < size(); ++i) {
         if (at(i).target() == at(i).relatedTarget()) {
@@ skipping 16 matching lines @@
         adjustedTouches.append(&touchEventContext->touches());
         adjustedTargetTouches.append(&touchEventContext->targetTouches());
         adjustedChangedTouches.append(&touchEventContext->changedTouches());
         treeScopes.append(&treeScopeEventContext->treeScope());
     }
 
     adjustTouchList(touchEvent.touches(), adjustedTouches, treeScopes);
     adjustTouchList(touchEvent.targetTouches(), adjustedTargetTouches, treeScopes);
     adjustTouchList(touchEvent.changedTouches(), adjustedChangedTouches, treeScopes);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         TreeScope& treeScope = treeScopeEventContext->treeScope();
         TouchEventContext* touchEventContext = treeScopeEventContext->touchEventContext();
         checkReachability(treeScope, touchEventContext->touches());
         checkReachability(treeScope, touchEventContext->targetTouches());
         checkReachability(treeScope, touchEventContext->changedTouches());
     }
 #endif
 }
 
@@ skipping 13 matching lines @@
         RelatedTargetMap relatedNodeMap;
         buildRelatedNodeMap(*targetNode, relatedNodeMap);
         for (size_t j = 0; j < treeScopes.size(); ++j) {
             adjustedTouchList[j]->append(touch.cloneWithNewTarget(findRelatedNode(*treeScopes[j], relatedNodeMap)));
         }
     }
 }
 
 const NodeEventContext& EventPath::topNodeEventContext()
 {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     return last();
 }
 
 void EventPath::ensureWindowEventContext()
 {
-    ASSERT(m_event);
+    DCHECK(m_event);
     if (!m_windowEventContext)
         m_windowEventContext = new WindowEventContext(*m_event, topNodeEventContext());
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 void EventPath::checkReachability(TreeScope& treeScope, TouchList& touchList)
 {
     for (size_t i = 0; i < touchList.length(); ++i)
-        ASSERT(touchList.item(i)->target()->toNode()->treeScope().isInclusiveOlderSiblingShadowRootOrAncestorTreeScopeOf(treeScope));
+        DCHECK(touchList.item(i)->target()->toNode()->treeScope().isInclusiveOlderSiblingShadowRootOrAncestorTreeScopeOf(treeScope));
 }
 #endif
 
 DEFINE_TRACE(EventPath)
 {
     visitor->trace(m_nodeEventContexts);
     visitor->trace(m_node);
     visitor->trace(m_event);
     visitor->trace(m_treeScopeEventContexts);
     visitor->trace(m_windowEventContext);
 }
 
 } // namespace blink