ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/UserActionElementSet.cpp

 /*
  * Copyright (C) 2012 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 23 matching lines @@
 UserActionElementSet::UserActionElementSet()
 {
 }
 
 UserActionElementSet::~UserActionElementSet()
 {
 }
 
 void UserActionElementSet::didDetach(Element& element)
 {
-    ASSERT(element.isUserActionElement());
+    DCHECK(element.isUserActionElement());
     clearFlags(&element, IsActiveFlag | InActiveChainFlag | IsHoveredFlag);
 }
 
 #if !ENABLE(OILPAN)
 void UserActionElementSet::documentDidRemoveLastRef()
 {
     m_elements.clear();
 }
 #endif
 
 bool UserActionElementSet::hasFlags(const Node* node, unsigned flags) const
 {
-    ASSERT(node->isUserActionElement() && node->isElementNode());
+    DCHECK(node->isUserActionElement() && node->isElementNode());
     return hasFlags(toElement(node), flags);
 }
 
 void UserActionElementSet::setFlags(Node* node, unsigned flags)
 {
     if (!node->isElementNode())
         return;
     return setFlags(toElement(node), flags);
 }
 
 void UserActionElementSet::clearFlags(Node* node, unsigned flags)
 {
     if (!node->isElementNode())
         return;
     return clearFlags(toElement(node), flags);
 }
 
 inline bool UserActionElementSet::hasFlags(const Element* element, unsigned flags) const
 {
-    ASSERT(element->isUserActionElement());
+    DCHECK(element->isUserActionElement());
     ElementFlagMap::const_iterator found = m_elements.find(const_cast<Element*>(element));
     if (found == m_elements.end())
         return false;
     return found->value & flags;
 }
 
 inline void UserActionElementSet::clearFlags(Element* element, unsigned flags)
 {
     if (!element->isUserActionElement()) {
-        ASSERT(m_elements.end() == m_elements.find(element));
+        DCHECK(m_elements.end() == m_elements.find(element));
         return;
     }
 
     ElementFlagMap::iterator found = m_elements.find(element);
     if (found == m_elements.end()) {
         element->setUserActionElement(false);
         return;
     }
 
     unsigned updated = found->value & ~flags;
     if (!updated) {
         element->setUserActionElement(false);
         m_elements.remove(found);
         return;
     }
 
     found->value = updated;
 }
 
 inline void UserActionElementSet::setFlags(Element* element, unsigned flags)
 {
     ElementFlagMap::iterator result = m_elements.find(element);
     if (result != m_elements.end()) {
-        ASSERT(element->isUserActionElement());
+        DCHECK(element->isUserActionElement());
         result->value |= flags;
         return;
     }
 
     element->setUserActionElement(true);
     m_elements.add(element, flags);
 }
 
 DEFINE_TRACE(UserActionElementSet)
 {
     visitor->trace(m_elements);
 }
 
 } // namespace blink