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> point_item = JSONObject::Create();
   point_item->SetDouble("x", point.x());
   point_item->SetDouble("y", point.y());
   return point_item;
 }
@@ 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> rrect_item = JSONObject::Create();
   rrect_item->SetString("type", RrectTypeName(rrect.type()));
   rrect_item->SetDouble("left", rrect.rect().left());
   rrect_item->SetDouble("top", rrect.rect().top());
   rrect_item->SetDouble("right", rrect.rect().right());
   rrect_item->SetDouble("bottom", rrect.rect().bottom());
   for (int i = 0; i < 4; ++i)
     rrect_item->SetObject(RadiusName((SkRRect::Corner)i),
                           ObjectForRadius(rrect, (SkRRect::Corner)i));
   return rrect_item;
 }
 
 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> path_item = JSONObject::Create();
   path_item->SetString("fillType", FillTypeName(path.getFillType()));
   path_item->SetString("convexity", ConvexityName(path.getConvexity()));
   path_item->SetBoolean("isRect", path.isRect(0));
   SkPath::Iter iter(path, false);
   SkPoint points[4];
   std::unique_ptr<JSONArray> path_points_array = JSONArray::Create();
   for (SkPath::Verb verb = iter.next(points, false); verb != SkPath::kDone_Verb;
        verb = iter.next(points, false)) {
     VerbParams verb_params = SegmentParams(verb);
     std::unique_ptr<JSONObject> path_point_item = JSONObject::Create();
     path_point_item->SetString("verb", verb_params.name);
-    ASSERT(verb_params.point_count + verb_params.point_offset <=
-           WTF_ARRAY_LENGTH(points));
+    DCHECK_LE(verb_params.point_count + verb_params.point_offset,
+              WTF_ARRAY_LENGTH(points));
     path_point_item->SetArray(
         "points", ArrayForSkPoints(verb_params.point_count,
                                    points + verb_params.point_offset));
     if (SkPath::kConic_Verb == verb)
       path_point_item->SetDouble("conicWeight", iter.conicWeight());
     path_points_array->PushObject(std::move(path_point_item));
   }
   path_item->SetArray("pathPoints", std::move(path_points_array));
   path_item->SetObject("bounds", ObjectForSkRect(path.getBounds()));
   return path_item;
 }
 
 String ColorTypeName(SkColorType color_type) {
   switch (color_type) {
     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 pixel_locker(image, kUnpremul_SkAlphaType,
                                   kRGBA_8888_SkColorType);
@@ skipping 87 matching lines @@
   switch (filter_quality) {
     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> paint_item = JSONObject::Create();
   paint_item->SetDouble("textSize", paint.getTextSize());
   paint_item->SetDouble("textScaleX", paint.getTextScaleX());
   paint_item->SetDouble("textSkewX", paint.getTextSkewX());
   if (SkShader* shader = paint.getShader())
@@ skipping 68 matching lines @@
       return StringForUTFText(text, byte_length, encoding);
     case SkPaint::kGlyphID_TextEncoding: {
       WTF::Vector<SkUnichar> data_vector(byte_length / 2);
       SkUnichar* text_data = data_vector.Data();
       paint.glyphsToUnichars(static_cast<const uint16_t*>(text),
                              byte_length / 2, text_data);
       return WTF::UTF32LittleEndianEncoding().Decode(
           reinterpret_cast<const char*>(text_data), byte_length * 2);
     }
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "?";
   }
 }
 
 }  // namespace
 
 class AutoLogger
     : InterceptingCanvasBase::CanvasInterceptorBase<LoggingCanvas> {
  public:
   explicit AutoLogger(LoggingCanvas* canvas)
@@ skipping 357 matching lines @@
   record_as_json->SetArray("operations", canvas.Log());
   return record_as_json->ToPrettyJSONString();
 }
 
 void ShowPaintRecord(const PaintRecord* record) {
   WTFLogAlways("%s\n", RecordAsDebugString(record).Utf8().Data());
 }
 #endif
 
 }  // namespace blink