Replace ASSERT_NOT_REACHED with NOTREACHED

third_party/WebKit/Source/core/animation/CompositorAnimations.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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 70 matching lines @@
     switch (animation.playStateInternal()) {
     case Animation::Idle:
         return false;
     case Animation::Pending:
     case Animation::Running:
         return true;
     case Animation::Paused:
     case Animation::Finished:
         return Animation::hasLowerPriority(&animationToAdd, &animation);
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return true;
     }
 }
 
 bool isTransformRelatedCSSProperty(const PropertyHandle property)
 {
     return property.isCSSProperty()
         && (property.cssProperty() == CSSPropertyRotate
         || property.cssProperty() == CSSPropertyScale
         || property.cssProperty() == CSSPropertyTransform
@@ skipping 260 matching lines @@
         compositorPlayer->removeAnimation(id);
 }
 
 void CompositorAnimations::pauseAnimationForTestingOnCompositor(const Element& element, const Animation& animation, int id, double pauseTime)
 {
     // FIXME: canStartAnimationOnCompositor queries compositingState, which is not necessarily up to date.
     // https://code.google.com/p/chromium/issues/detail?id=339847
     DisableCompositingQueryAsserts disabler;
 
     if (!canStartAnimationOnCompositor(element)) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return;
     }
     CompositorAnimationPlayer* compositorPlayer = animation.compositorPlayer();
     ASSERT(compositorPlayer);
     compositorPlayer->pauseAnimation(id, pauseTime);
 }
 
 void CompositorAnimations::attachCompositedLayers(Element& element, const Animation& animation)
 {
     if (!animation.compositorPlayer())
@@ skipping 206 matching lines @@
         case CSSPropertyTranslate:
         case CSSPropertyTransform: {
             targetProperty = CompositorTargetProperty::TRANSFORM;
             std::unique_ptr<CompositorTransformAnimationCurve> transformCurve = CompositorTransformAnimationCurve::create();
             addKeyframesToCurve(*transformCurve, values);
             setTimingFunctionOnCurve(*transformCurve, timing.timingFunction.get());
             curve = std::move(transformCurve);
             break;
         }
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             continue;
         }
         ASSERT(curve.get());
 
         std::unique_ptr<CompositorAnimation> animation = CompositorAnimation::create(*curve, targetProperty, group, 0);
 
         if (!std::isnan(startTime))
             animation->setStartTime(startTime);
 
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setIterationStart(compositorTiming.iterationStart);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
 
         switch (compositorTiming.direction) {
         case Timing::PlaybackDirectionNormal:
             animation->setDirection(CompositorAnimation::Direction::NORMAL);
             break;
         case Timing::PlaybackDirectionReverse:
             animation->setDirection(CompositorAnimation::Direction::REVERSE);
             break;
         case Timing::PlaybackDirectionAlternate:
             animation->setDirection(CompositorAnimation::Direction::ALTERNATE_NORMAL);
             break;
         case Timing::PlaybackDirectionAlternateReverse:
             animation->setDirection(CompositorAnimation::Direction::ALTERNATE_REVERSE);
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         animation->setPlaybackRate(compositorTiming.playbackRate);
 
         switch (compositorTiming.fillMode) {
         case Timing::FillModeNone:
             animation->setFillMode(CompositorAnimation::FillMode::NONE);
             break;
         case Timing::FillModeForwards:
             animation->setFillMode(CompositorAnimation::FillMode::FORWARDS);
             break;
         case Timing::FillModeBackwards:
             animation->setFillMode(CompositorAnimation::FillMode::BACKWARDS);
             break;
         case Timing::FillModeBoth:
             animation->setFillMode(CompositorAnimation::FillMode::BOTH);
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         animations.append(std::move(animation));
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace blink