Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

third_party/WebKit/Source/platform/graphics/LoggingCanvas.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 68 matching lines @@
 
 String pointModeName(SkCanvas::PointMode mode) {
   switch (mode) {
     case SkCanvas::kPoints_PointMode:
       return "Points";
     case SkCanvas::kLines_PointMode:
       return "Lines";
     case SkCanvas::kPolygon_PointMode:
       return "Polygon";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 std::unique_ptr<JSONObject> objectForSkPoint(const SkPoint& point) {
   std::unique_ptr<JSONObject> pointItem = JSONObject::create();
   pointItem->setDouble("x", point.x());
   pointItem->setDouble("y", point.y());
   return pointItem;
 }
@@ skipping 23 matching lines @@
       return "Rect";
     case SkRRect::kOval_Type:
       return "Oval";
     case SkRRect::kSimple_Type:
       return "Simple";
     case SkRRect::kNinePatch_Type:
       return "Nine-patch";
     case SkRRect::kComplex_Type:
       return "Complex";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String radiusName(SkRRect::Corner corner) {
   switch (corner) {
     case SkRRect::kUpperLeft_Corner:
       return "upperLeftRadius";
     case SkRRect::kUpperRight_Corner:
       return "upperRightRadius";
     case SkRRect::kLowerRight_Corner:
       return "lowerRightRadius";
     case SkRRect::kLowerLeft_Corner:
       return "lowerLeftRadius";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   }
 }
 
 std::unique_ptr<JSONObject> objectForSkRRect(const SkRRect& rrect) {
   std::unique_ptr<JSONObject> rrectItem = JSONObject::create();
   rrectItem->setString("type", rrectTypeName(rrect.type()));
   rrectItem->setDouble("left", rrect.rect().left());
   rrectItem->setDouble("top", rrect.rect().top());
   rrectItem->setDouble("right", rrect.rect().right());
   rrectItem->setDouble("bottom", rrect.rect().bottom());
   for (int i = 0; i < 4; ++i)
     rrectItem->setObject(radiusName((SkRRect::Corner)i),
                          objectForRadius(rrect, (SkRRect::Corner)i));
   return rrectItem;
 }
 
 String fillTypeName(SkPath::FillType type) {
   switch (type) {
     case SkPath::kWinding_FillType:
       return "Winding";
     case SkPath::kEvenOdd_FillType:
       return "EvenOdd";
     case SkPath::kInverseWinding_FillType:
       return "InverseWinding";
     case SkPath::kInverseEvenOdd_FillType:
       return "InverseEvenOdd";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String convexityName(SkPath::Convexity convexity) {
   switch (convexity) {
     case SkPath::kUnknown_Convexity:
       return "Unknown";
     case SkPath::kConvex_Convexity:
       return "Convex";
     case SkPath::kConcave_Convexity:
       return "Concave";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 VerbParams segmentParams(SkPath::Verb verb) {
   switch (verb) {
     case SkPath::kMove_Verb:
       return VerbParams("Move", 1, 0);
     case SkPath::kLine_Verb:
       return VerbParams("Line", 1, 1);
     case SkPath::kQuad_Verb:
       return VerbParams("Quad", 2, 1);
     case SkPath::kConic_Verb:
       return VerbParams("Conic", 2, 1);
     case SkPath::kCubic_Verb:
       return VerbParams("Cubic", 3, 1);
     case SkPath::kClose_Verb:
       return VerbParams("Close", 0, 0);
     case SkPath::kDone_Verb:
       return VerbParams("Done", 0, 0);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return VerbParams("?", 0, 0);
   };
 }
 
 std::unique_ptr<JSONObject> objectForSkPath(const SkPath& path) {
   std::unique_ptr<JSONObject> pathItem = JSONObject::create();
   pathItem->setString("fillType", fillTypeName(path.getFillType()));
   pathItem->setString("convexity", convexityName(path.getConvexity()));
   pathItem->setBoolean("isRect", path.isRect(0));
   SkPath::Iter iter(path, false);
   SkPoint points[4];
   std::unique_ptr<JSONArray> pathPointsArray = JSONArray::create();
   for (SkPath::Verb verb = iter.next(points, false); verb != SkPath::kDone_Verb;
        verb = iter.next(points, false)) {
     VerbParams verbParams = segmentParams(verb);
     std::unique_ptr<JSONObject> pathPointItem = JSONObject::create();
     pathPointItem->setString("verb", verbParams.name);
-    ASSERT(verbParams.pointCount + verbParams.pointOffset <=
-           WTF_ARRAY_LENGTH(points));
+    DCHECK_LE(verbParams.pointCount + verbParams.pointOffset,
+              WTF_ARRAY_LENGTH(points));
     pathPointItem->setArray("points",
                             arrayForSkPoints(verbParams.pointCount,
                                              points + verbParams.pointOffset));
     if (SkPath::kConic_Verb == verb)
       pathPointItem->setDouble("conicWeight", iter.conicWeight());
     pathPointsArray->pushObject(std::move(pathPointItem));
   }
   pathItem->setArray("pathPoints", std::move(pathPointsArray));
   pathItem->setObject("bounds", objectForSkRect(path.getBounds()));
   return pathItem;
 }
 
 String colorTypeName(SkColorType colorType) {
   switch (colorType) {
     case kUnknown_SkColorType:
       return "None";
     case kAlpha_8_SkColorType:
       return "A8";
     case kIndex_8_SkColorType:
       return "Index8";
     case kRGB_565_SkColorType:
       return "RGB565";
     case kARGB_4444_SkColorType:
       return "ARGB4444";
     case kN32_SkColorType:
       return "ARGB8888";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 std::unique_ptr<JSONObject> objectForBitmapData(const SkBitmap& bitmap) {
   Vector<unsigned char> output;
 
   if (sk_sp<SkImage> image = SkImage::MakeFromBitmap(bitmap)) {
     ImagePixelLocker pixelLocker(image, kUnpremul_SkAlphaType,
                                  kRGBA_8888_SkColorType);
@@ skipping 87 matching lines @@
   switch (filterQuality) {
     case kNone_SkFilterQuality:
       return "None";
     case kLow_SkFilterQuality:
       return "Low";
     case kMedium_SkFilterQuality:
       return "Medium";
     case kHigh_SkFilterQuality:
       return "High";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String textAlignName(SkPaint::Align align) {
   switch (align) {
     case SkPaint::kLeft_Align:
       return "Left";
     case SkPaint::kCenter_Align:
       return "Center";
     case SkPaint::kRight_Align:
       return "Right";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String strokeCapName(SkPaint::Cap cap) {
   switch (cap) {
     case SkPaint::kButt_Cap:
       return "Butt";
     case SkPaint::kRound_Cap:
       return "Round";
     case SkPaint::kSquare_Cap:
       return "Square";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String strokeJoinName(SkPaint::Join join) {
   switch (join) {
     case SkPaint::kMiter_Join:
       return "Miter";
     case SkPaint::kRound_Join:
       return "Round";
     case SkPaint::kBevel_Join:
       return "Bevel";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String styleName(SkPaint::Style style) {
   switch (style) {
     case SkPaint::kFill_Style:
       return "Fill";
     case SkPaint::kStroke_Style:
       return "Stroke";
     case SkPaint::kStrokeAndFill_Style:
       return "StrokeAndFill";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String textEncodingName(SkPaint::TextEncoding encoding) {
   switch (encoding) {
     case SkPaint::kUTF8_TextEncoding:
       return "UTF-8";
     case SkPaint::kUTF16_TextEncoding:
       return "UTF-16";
     case SkPaint::kUTF32_TextEncoding:
       return "UTF-32";
     case SkPaint::kGlyphID_TextEncoding:
       return "GlyphID";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 String hintingName(SkPaint::Hinting hinting) {
   switch (hinting) {
     case SkPaint::kNo_Hinting:
       return "None";
     case SkPaint::kSlight_Hinting:
       return "Slight";
     case SkPaint::kNormal_Hinting:
       return "Normal";
     case SkPaint::kFull_Hinting:
       return "Full";
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   };
 }
 
 std::unique_ptr<JSONObject> objectForSkPaint(const SkPaint& paint) {
   std::unique_ptr<JSONObject> paintItem = JSONObject::create();
   paintItem->setDouble("textSize", paint.getTextSize());
   paintItem->setDouble("textScaleX", paint.getTextScaleX());
   paintItem->setDouble("textSkewX", paint.getTextSkewX());
   if (SkShader* shader = paint.getShader())
@@ skipping 68 matching lines @@
       return stringForUTFText(text, byteLength, encoding);
     case SkPaint::kGlyphID_TextEncoding: {
       WTF::Vector<SkUnichar> dataVector(byteLength / 2);
       SkUnichar* textData = dataVector.data();
       paint.glyphsToUnichars(static_cast<const uint16_t*>(text), byteLength / 2,
                              textData);
       return WTF::UTF32LittleEndianEncoding().decode(
           reinterpret_cast<const char*>(textData), byteLength * 2);
     }
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   }
 }
 
 }  // namespace
 
 class AutoLogger
     : InterceptingCanvasBase::CanvasInterceptorBase<LoggingCanvas> {
  public:
   explicit AutoLogger(LoggingCanvas* canvas)
@@ skipping 357 matching lines @@
   recordAsJSON->setArray("operations", canvas.log());
   return recordAsJSON->toPrettyJSONString();
 }
 
 void showPaintRecord(const PaintRecord* record) {
   WTFLogAlways("%s\n", recordAsDebugString(record).utf8().data());
 }
 #endif
 
 }  // namespace blink