Replace ASSERT with DCHECK in core/svg/

third_party/WebKit/Source/core/svg/animation/SVGSMILElement.cpp

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 295 matching lines @@
 
   UseCounter::count(document(), UseCounter::SVGSMILElementInDocument);
   if (document().isLoadCompleted())
     UseCounter::count(&document(), UseCounter::SVGSMILElementInsertedAfterLoad);
 
   SVGSVGElement* owner = ownerSVGElement();
   if (!owner)
     return InsertionDone;
 
   m_timeContainer = owner->timeContainer();
-  ASSERT(m_timeContainer);
+  DCHECK(m_timeContainer);
   m_timeContainer->setDocumentOrderIndexesDirty();
 
   // "If no attribute is present, the default begin value (an offset-value of 0)
   // must be evaluated."
   if (!fastHasAttribute(SVGNames::beginAttr))
     m_beginTimes.push_back(SMILTimeWithOrigin());
 
   if (m_isWaitingForFirstInterval)
     resolveFirstInterval();
 
@@ skipping 421 matching lines @@
   const SMILTime& currentTime = list[indexOfResult].time();
 
   // The special value "indefinite" does not yield an instance time in the begin
   // list.
   if (currentTime.isIndefinite() && beginOrEnd == Begin)
     return SMILTime::unresolved();
 
   if (currentTime > minimumTime)
     return currentTime;
 
-  ASSERT(currentTime == minimumTime);
+  DCHECK(currentTime == minimumTime);

[tkent, 2017/03/14 22:33:14]

Use DCHECK_EQ if possible

[mrunal, 2017/03/14 23:52:14]

It throws compiler error,
../../base/logging.h:659:3: error: no matching function for call to
'MakeCheckOpValueString'
  MakeCheckOpValueString(&ss, v1);
  ^~~~~~~~~~~~~~~~~~~~~~
../../base/logging.h:703:1: note: in instantiation of function template
specialization 'logging::MakeCheckOpString<blink::SMILTime, blink::SMILTime>'
requested here
DEFINE_CHECK_OP_IMPL(EQ, ==)
^
../../base/logging.h:695:25: note: expanded from macro 'DEFINE_CHECK_OP_IMPL'
      return ::logging::MakeCheckOpString(v1, v2, names);                    \
                        ^
../../third_party/WebKit/Source/core/svg/animation/SVGSMILElement.cpp:758:3:
note: in instantiation of function template specialization
'logging::CheckEQImpl<blink::SMILTime, blink::SMILTime>' requested here
  DCHECK_EQ(currentTime, minimumTime);
  ^
../../base/logging.h:899:31: note: expanded from macro 'DCHECK_EQ'
#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
                              ^
../../base/logging.h:853:18: note: expanded from macro 'DCHECK_OP'
      ::logging::Check##name##Impl((val1), (val2),                     \

   if (equalsMinimumOK)
     return currentTime;
 
   // If the equals is not accepted, return the next bigger item in the list.
   SMILTime nextTime = currentTime;
   while (indexOfResult < sizeOfList - 1) {
     nextTime = list[indexOfResult + 1].time();
     if (nextTime > minimumTime)
       return nextTime;
     ++indexOfResult;
@@ skipping 74 matching lines @@
       return SMILInterval(tempBegin, tempEnd);
 
     beginAfter = tempEnd;
     lastIntervalTempEnd = tempEnd;
   }
   return SMILInterval(SMILTime::unresolved(), SMILTime::unresolved());
 }
 
 void SVGSMILElement::resolveFirstInterval() {
   SMILInterval firstInterval = resolveInterval(FirstInterval);
-  ASSERT(!firstInterval.begin.isIndefinite());
+  DCHECK(!firstInterval.begin.isIndefinite());
 
   if (!firstInterval.begin.isUnresolved() && firstInterval != m_interval) {
     m_interval = firstInterval;
     notifyDependentsIntervalChanged();
     m_nextProgressTime = m_nextProgressTime.isUnresolved()
                              ? m_interval.begin
                              : std::min(m_nextProgressTime, m_interval.begin);
 
     if (m_timeContainer)
       m_timeContainer->notifyIntervalsChanged();
   }
 }
 
 bool SVGSMILElement::resolveNextInterval() {
   SMILInterval nextInterval = resolveInterval(NextInterval);
-  ASSERT(!nextInterval.begin.isIndefinite());
+  DCHECK(!nextInterval.begin.isIndefinite());
 
   if (!nextInterval.begin.isUnresolved() &&
       nextInterval.begin != m_interval.begin) {
     m_interval = nextInterval;
     notifyDependentsIntervalChanged();
     m_nextProgressTime = m_nextProgressTime.isUnresolved()
                              ? m_interval.begin
                              : std::min(m_nextProgressTime, m_interval.begin);
     return true;
   }
 
   return false;
 }
 
 SMILTime SVGSMILElement::nextProgressTime() const {
   return m_nextProgressTime;
 }
 
 void SVGSMILElement::beginListChanged(SMILTime eventTime) {
   if (m_isWaitingForFirstInterval) {
     resolveFirstInterval();
   } else if (this->getRestart() != RestartNever) {
     SMILTime newBegin = findInstanceTime(Begin, eventTime, true);
     if (newBegin.isFinite() &&
         (m_interval.end <= eventTime || newBegin < m_interval.begin)) {
       // Begin time changed, re-resolve the interval.
       SMILTime oldBegin = m_interval.begin;
       m_interval.end = eventTime;
       m_interval = resolveInterval(NextInterval);
-      ASSERT(!m_interval.begin.isUnresolved());
+      DCHECK(!m_interval.begin.isUnresolved());
       if (m_interval.begin != oldBegin) {
         if (m_activeState == Active && m_interval.begin > eventTime) {
           m_activeState = determineActiveState(eventTime);
           if (m_activeState != Active)
             endedActiveInterval();
         }
         notifyDependentsIntervalChanged();
       }
     }
   }
@@ skipping 158 matching lines @@
 bool SVGSMILElement::isContributing(double elapsed) const {
   // Animation does not contribute during the active time if it is past its
   // repeating duration and has fill=remove.
   return (m_activeState == Active &&
           (fill() == FillFreeze ||
            elapsed <= m_interval.begin + repeatingDuration())) ||
          m_activeState == Frozen;
 }
 
 bool SVGSMILElement::progress(double elapsed, bool seekToTime) {
-  ASSERT(m_timeContainer);
-  ASSERT(m_isWaitingForFirstInterval || m_interval.begin.isFinite());
+  DCHECK(m_timeContainer);
+  DCHECK(m_isWaitingForFirstInterval || m_interval.begin.isFinite());
 
   if (!m_syncBaseConditionsConnected)
     connectSyncBaseConditions();
 
   if (!m_interval.begin.isFinite()) {
-    ASSERT(m_activeState == Inactive);
+    DCHECK_EQ(m_activeState, Inactive);
     m_nextProgressTime = SMILTime::unresolved();
     return false;
   }
 
   if (elapsed < m_interval.begin) {
-    ASSERT(m_activeState != Active);
+    DCHECK_NE(m_activeState, Active);
     m_nextProgressTime = m_interval.begin;
     // If the animation is frozen, it's still contributing.
     return m_activeState == Frozen;
   }
 
   m_previousIntervalBegin = m_interval.begin;
 
   if (m_isWaitingForFirstInterval) {
     m_isWaitingForFirstInterval = false;
     resolveFirstInterval();
@@ skipping 52 matching lines @@
 
     if (m_activeState == Inactive || m_activeState == Frozen)
       scheduleEvent(EventTypeNames::endEvent);
   }
 
   m_nextProgressTime = calculateNextProgressTime(elapsed);
   return animationIsContributing;
 }
 
 void SVGSMILElement::notifyDependentsIntervalChanged() {
-  ASSERT(m_interval.begin.isFinite());
+  DCHECK(m_interval.begin.isFinite());
   // |loopBreaker| is used to avoid infinite recursions which may be caused by:
   // |notifyDependentsIntervalChanged| -> |createInstanceTimesFromSyncbase| ->
   // |add{Begin,End}Time| -> |{begin,end}TimeChanged| ->
   // |notifyDependentsIntervalChanged|
   //
   // As the set here records SVGSMILElements on the stack, it is acceptable to
   // use a HashSet of untraced heap references -- any conservative GC which
   // strikes before unwinding will find these elements on the stack.
   DEFINE_STATIC_LOCAL(HashSet<UntracedMember<SVGSMILElement>>, loopBreaker, ());
   if (!loopBreaker.insert(this).isNewEntry)
     return;
 
   for (SVGSMILElement* element : m_syncBaseDependents)
     element->createInstanceTimesFromSyncbase(*this);
 
   loopBreaker.erase(this);
 }
 
 void SVGSMILElement::createInstanceTimesFromSyncbase(SVGSMILElement& syncBase) {
   // FIXME: To be really correct, this should handle updating exising interval
   // by changing the associated times instead of creating new ones.
   for (Condition* condition : m_conditions) {
     if (condition->getType() == Condition::Syncbase &&
         condition->syncBaseEquals(syncBase)) {
-      ASSERT(condition->name() == "begin" || condition->name() == "end");
+      DCHECK(condition->name() == "begin" || condition->name() == "end");
       // No nested time containers in SVG, no need for crazy time space
       // conversions. Phew!
       SMILTime time = 0;
       if (condition->name() == "begin")
         time = syncBase.m_interval.begin + condition->offset();
       else
         time = syncBase.m_interval.end + condition->offset();
       if (!time.isFinite())
         continue;
       addInstanceTime(condition->getBeginOrEnd(), time);
@@ skipping 74 matching lines @@
   visitor->trace(m_targetElement);
   visitor->trace(m_targetIdObserver);
   visitor->trace(m_timeContainer);
   visitor->trace(m_conditions);
   visitor->trace(m_syncBaseDependents);
   SVGElement::trace(visitor);
   SVGTests::trace(visitor);
 }
 
 }  // namespace blink