Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/css/

third_party/WebKit/Source/core/css/resolver/AnimatedStyleBuilder.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 53 matching lines @@
 
 namespace blink {
 
 namespace {
 
 Length animatableValueToLengthWithZoom(const AnimatableValue* value,
                                        float zoom,
                                        ValueRange range = ValueRangeAll) {
   if (value->isLength())
     return toAnimatableLength(value)->getLength(zoom, range);
-  ASSERT(toAnimatableUnknown(value)->toCSSValueID() == CSSValueAuto);
+  DCHECK_EQ(toAnimatableUnknown(value)->toCSSValueID(), CSSValueAuto);
   return Length(Auto);
 }
 
 Length animatableValueToLength(const AnimatableValue* value,
                                const StyleResolverState& state,
                                ValueRange range = ValueRangeAll) {
   return animatableValueToLengthWithZoom(value, state.style()->effectiveZoom(),
                                          range);
 }
 
 UnzoomedLength animatableValueToUnzoomedLength(
     const AnimatableValue* value,
     const StyleResolverState&,
     ValueRange range = ValueRangeAll) {
   return UnzoomedLength(animatableValueToLengthWithZoom(value, 1, range));
 }
 
 BorderImageLength animatableValueToBorderImageLength(
     const AnimatableValue* value,
     const StyleResolverState& state) {
   if (value->isLength())
     return BorderImageLength(toAnimatableLength(value)->getLength(
         state.style()->effectiveZoom(), ValueRangeNonNegative));
   if (value->isDouble())
     return BorderImageLength(
         clampTo<double>(toAnimatableDouble(value)->toDouble(), 0));
-  ASSERT(toAnimatableUnknown(value)->toCSSValueID() == CSSValueAuto);
+  DCHECK_EQ(toAnimatableUnknown(value)->toCSSValueID(), CSSValueAuto);
   return Length(Auto);
 }
 
 double animatableValueToPixels(const AnimatableValue* value,
                                const StyleResolverState& state) {
   return toAnimatableLength(value)
       ->getLength(state.style()->effectiveZoom(), ValueRangeAll)
       .pixels();
 }
 
@@ skipping 92 matching lines @@
     CSSToStyleMap::mapFillSize(state, fillLayer,
                                *toAnimatableUnknown(value)->toCSSValue());
 }
 
 template <CSSPropertyID property>
 void setOnFillLayers(FillLayer& fillLayers,
                      const AnimatableValue* value,
                      StyleResolverState& state) {
   const Vector<RefPtr<AnimatableValue>>& values =
       toAnimatableRepeatable(value)->values();
-  ASSERT(!values.isEmpty());
+  DCHECK(!values.isEmpty());
   FillLayer* fillLayer = &fillLayers;
   FillLayer* prev = 0;
   for (size_t i = 0; i < values.size(); ++i) {
     if (!fillLayer)
       fillLayer = prev->ensureNext();
     const AnimatableValue* layerValue = values[i].get();
     switch (property) {
       case CSSPropertyBackgroundImage:
       case CSSPropertyWebkitMaskImage:
         if (layerValue->isImage()) {
           fillLayer->setImage(state.styleImage(
               property, *toAnimatableImage(layerValue)->toCSSValue()));
         } else {
-          ASSERT(toAnimatableUnknown(layerValue)->toCSSValueID() ==
-                 CSSValueNone);
+          DCHECK_EQ(toAnimatableUnknown(layerValue)->toCSSValueID(),
+                    CSSValueNone);
           fillLayer->setImage(nullptr);
         }
         break;
       case CSSPropertyBackgroundPositionX:
       case CSSPropertyWebkitMaskPositionX:
         fillLayer->setXPosition(animatableValueToLength(layerValue, state));
         break;
       case CSSPropertyBackgroundPositionY:
       case CSSPropertyWebkitMaskPositionY:
         fillLayer->setYPosition(animatableValueToLength(layerValue, state));
         break;
       case CSSPropertyBackgroundSize:
       case CSSPropertyWebkitMaskSize:
         setFillSize(fillLayer, layerValue, state);
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     prev = fillLayer;
     fillLayer = fillLayer->next();
   }
   while (fillLayer) {
     switch (property) {
       case CSSPropertyBackgroundImage:
       case CSSPropertyWebkitMaskImage:
         fillLayer->clearImage();
         break;
       case CSSPropertyBackgroundPositionX:
       case CSSPropertyWebkitMaskPositionX:
         fillLayer->clearXPosition();
         break;
       case CSSPropertyBackgroundPositionY:
       case CSSPropertyWebkitMaskPositionY:
         fillLayer->clearYPosition();
         break;
       case CSSPropertyBackgroundSize:
       case CSSPropertyWebkitMaskSize:
         fillLayer->clearSize();
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     fillLayer = fillLayer->next();
   }
 }
 
 FontStretch animatableValueToFontStretch(const AnimatableValue* value) {
-  ASSERT(FontStretchUltraCondensed == 1 && FontStretchUltraExpanded == 9);
+  DCHECK_EQ(FontStretchUltraCondensed, 1);
+  DCHECK_EQ(FontStretchUltraExpanded,  9);
   unsigned index = round(toAnimatableDouble(value)->toDouble()) - 1;
   static const FontStretch stretchValues[] = {
       FontStretchUltraCondensed, FontStretchExtraCondensed,
       FontStretchCondensed,      FontStretchSemiCondensed,
       FontStretchNormal,         FontStretchSemiExpanded,
       FontStretchExpanded,       FontStretchExtraExpanded,
       FontStretchUltraExpanded};
 
   index = clampTo<unsigned>(index, 0, WTF_ARRAY_LENGTH(stretchValues) - 1);
   return stretchValues[index];
@@ skipping 16 matching lines @@
   return FontDescription::Size(0, size, true);
 }
 
 TransformOperation* animatableValueToTransformOperation(
     const AnimatableValue* value,
     TransformOperation::OperationType type) {
   const TransformOperations& transformList =
       toAnimatableTransform(value)->transformOperations();
   if (transformList.size() == 0)
     return nullptr;
-  ASSERT(transformList.size() == 1);
-  ASSERT(transformList.operations()[0].get()->type() == type);
+  DCHECK_EQ(transformList.size(), static_cast<unsigned>(1));
+  DCHECK(transformList.operations()[0].get()->type() == type);

[Srirama, 2017/03/16 14:22:24]

DCHECK_EQ

   return transformList.operations()[0].get();
 }
 
 }  // namespace
 
 // FIXME: Generate this function.
 void AnimatedStyleBuilder::applyProperty(CSSPropertyID property,
                                          StyleResolverState& state,
                                          const AnimatableValue* value) {
-  ASSERT(CSSPropertyMetadata::isInterpolableProperty(property));
+  DCHECK(CSSPropertyMetadata::isInterpolableProperty(property));
   if (value->isUnknown()) {
     StyleBuilder::applyProperty(property, state,
                                 *toAnimatableUnknown(value)->toCSSValue());
     return;
   }
   ComputedStyle* style = state.style();
   switch (property) {
     case CSSPropertyBackgroundColor:
       style->setBackgroundColor(toAnimatableColor(value)->getColor());
       style->setVisitedLinkBackgroundColor(
@@ skipping 524 matching lines @@
     case CSSPropertyRx:
       style->setRx(
           animatableValueToLength(value, state, ValueRangeNonNegative));
       return;
     case CSSPropertyRy:
       style->setRy(
           animatableValueToLength(value, state, ValueRangeNonNegative));
       return;
 
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 }  // namespace blink