Replace ASSERT with DCHECK in platform/

third_party/WebKit/Source/platform/Length.h

 /*
     Copyright (C) 1999 Lars Knoll (knoll@kde.org)
     Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
     Copyright (C) 2011 Rik Cabanier (cabanier@adobe.com)
     Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 123 matching lines @@
       float_value_ = static_cast<float>(float_value_ * v);
     else
       int_value_ = static_cast<int>(int_value_ * v);
 
     return *this;
   }
 
   // FIXME: Make this private (if possible) or at least rename it
   // (http://crbug.com/432707).
   inline float Value() const {
-    ASSERT(!IsCalculated());
+    DCHECK(!IsCalculated());
     return GetFloatValue();
   }
 
   int IntValue() const {
     if (IsCalculated()) {
       ASSERT_NOT_REACHED();
       return 0;
     }
     return GetIntValue();
   }
@@ skipping 45 matching lines @@
 
   void SetValue(float value) { *this = Length(value, kFixed); }
 
   bool IsMaxSizeNone() const { return GetType() == kMaxSizeNone; }
 
   // FIXME calc: https://bugs.webkit.org/show_bug.cgi?id=80357. A calculated
   // Length always contains a percentage, and without a maxValue passed to these
   // functions it's impossible to determine the sign or zero-ness. We assume all
   // calc values are positive and non-zero for now.
   bool IsZero() const {
-    ASSERT(!IsMaxSizeNone());
+    DCHECK(!IsMaxSizeNone());
     if (IsCalculated())
       return false;
 
     return is_float_ ? !float_value_ : !int_value_;
   }
   bool IsPositive() const {
     if (IsMaxSizeNone())
       return false;
     if (IsCalculated())
       return true;
@@ skipping 52 matching lines @@
     if (IsZero())
       result_type = from.GetType();
 
     float blended_value = blink::Blend(from.Value(), Value(), progress);
     if (range == kValueRangeNonNegative)
       blended_value = clampTo<float>(blended_value, 0);
     return Length(blended_value, result_type);
   }
 
   float GetFloatValue() const {
-    ASSERT(!IsMaxSizeNone());
+    DCHECK(!IsMaxSizeNone());
     return is_float_ ? float_value_ : int_value_;
   }
   float NonNanCalculatedValue(LayoutUnit max_value) const;
 
   Length SubtractFromOneHundredPercent() const;
 
   Length Zoom(double factor) const;
 
  private:
   int GetIntValue() const {
-    ASSERT(!IsMaxSizeNone());
+    DCHECK(!IsMaxSizeNone());
     return is_float_ ? static_cast<int>(float_value_) : int_value_;
   }
 
   Length BlendMixedTypes(const Length& from, double progress, ValueRange) const;
 
   int CalculationHandle() const {
-    ASSERT(IsCalculated());
+    DCHECK(IsCalculated());
     return GetIntValue();
   }
   void IncrementCalculatedRef() const;
   void DecrementCalculatedRef() const;
 
   union {
     int int_value_;
     float float_value_;
   };
   bool quirk_;
   unsigned char type_;
   bool is_float_;
 };
 
 }  // namespace blink
 
 #endif  // Length_h