Style Change: NULL->nullptr

src/utils/SkLua.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLua.h"
 
 #if SK_SUPPORT_GPU
@@ skipping 484 matching lines @@
     if (lua_isnumber(L, index)) {
         paint->setAlpha(SkScalarRoundToInt(lua2scalar(L, index) * 255));
         return paint;
     } else if (lua_isuserdata(L, index)) {
         const SkPaint* ptr = get_obj<SkPaint>(L, index);
         if (ptr) {
             *paint = *ptr;
             return paint;
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 static int lcanvas_drawImage(lua_State* L) {
     SkCanvas* canvas = get_ref<SkCanvas>(L, 1);
     SkImage* image = get_ref<SkImage>(L, 2);
-    if (NULL == image) {
+    if (nullptr == image) {
         return 0;
     }
     SkScalar x = lua2scalar(L, 3);
     SkScalar y = lua2scalar(L, 4);
 
     SkPaint paint;
     canvas->drawImage(image, x, y, lua2OptionalPaint(L, 5, &paint));
     return 0;
 }
 
 static int lcanvas_drawImageRect(lua_State* L) {
     SkCanvas* canvas = get_ref<SkCanvas>(L, 1);
     SkImage* image = get_ref<SkImage>(L, 2);
-    if (NULL == image) {
+    if (nullptr == image) {
         return 0;
     }
 
     SkRect srcR, dstR;
-    SkRect* srcRPtr = NULL;
+    SkRect* srcRPtr = nullptr;
     if (!lua_isnil(L, 3)) {
         srcRPtr = lua2rect(L, 3, &srcR);
     }
     lua2rect(L, 4, &dstR);
 
     SkPaint paint;
     canvas->legacy_drawImageRect(image, srcRPtr, dstR, lua2OptionalPaint(L, 5, &paint));
     return 0;
 }
 
 static int lcanvas_drawPatch(lua_State* L) {
     SkPoint cubics[12];
     SkColor colorStorage[4];
     SkPoint texStorage[4];
 
-    const SkColor* colors = NULL;
-    const SkPoint* texs = NULL;
+    const SkColor* colors = nullptr;
+    const SkPoint* texs = nullptr;
 
     getarray_points(L, 2, cubics, 12);
 
     colorStorage[0] = SK_ColorRED;
     colorStorage[1] = SK_ColorGREEN;
     colorStorage[2] = SK_ColorBLUE;
     colorStorage[3] = SK_ColorGRAY;
 
     if (lua_isnil(L, 4)) {
         colors = colorStorage;
     } else {
         getarray_points(L, 4, texStorage, 4);
         texs = texStorage;
     }
 
-    get_ref<SkCanvas>(L, 1)->drawPatch(cubics, colors, texs, NULL, *get_obj<SkPaint>(L, 5));
+    get_ref<SkCanvas>(L, 1)->drawPatch(cubics, colors, texs, nullptr, *get_obj<SkPaint>(L, 5));
     return 0;
 }
 
 static int lcanvas_drawPath(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->drawPath(*get_obj<SkPath>(L, 2),
                                       *get_obj<SkPaint>(L, 3));
     return 0;
 }
 
 // drawPicture(pic, x, y, paint)
 static int lcanvas_drawPicture(lua_State* L) {
     SkCanvas* canvas = get_ref<SkCanvas>(L, 1);
     SkPicture* picture = get_ref<SkPicture>(L, 2);
     SkScalar x = lua2scalar_def(L, 3, 0);
     SkScalar y = lua2scalar_def(L, 4, 0);
-    SkMatrix matrix, *matrixPtr = NULL;
+    SkMatrix matrix, *matrixPtr = nullptr;
     if (x || y) {
         matrix.setTranslate(x, y);
         matrixPtr = &matrix;
     }
     SkPaint paint;
     canvas->drawPicture(picture, matrixPtr, lua2OptionalPaint(L, 5, &paint));
     return 0;
 }
 
 static int lcanvas_drawText(lua_State* L) {
@@ skipping 49 matching lines @@
     SkIRect resultBounds;
 
     const SkClipStack& stack = *canvas->getClipStack();
 
     GrReducedClip::ReduceClipStack(stack,
                                    queryBounds,
                                    &elements,
                                    &genID,
                                    &initialState,
                                    &resultBounds,
-                                   NULL);
+                                   nullptr);
 
     GrReducedClip::ElementList::Iter iter(elements);
     int i = 0;
     lua_newtable(L);
     while(iter.get()) {
         SkLua(L).pushClipStackElement(*iter.get());
         iter.next();
         lua_rawseti(L, -2, ++i);
     }
     // Currently this only returns the element list to lua, not the initial state or result bounds.
     // It could return these as additional items on the lua stack.
     return 1;
 #else
     return 0;
 #endif
 }
 
 static int lcanvas_save(lua_State* L) {
     lua_pushinteger(L, get_ref<SkCanvas>(L, 1)->save());
     return 1;
 }
 
 static int lcanvas_saveLayer(lua_State* L) {
     SkPaint paint;
-    lua_pushinteger(L, get_ref<SkCanvas>(L, 1)->saveLayer(NULL, lua2OptionalPaint(L, 2, &paint)));
+    lua_pushinteger(L, get_ref<SkCanvas>(L, 1)->saveLayer(nullptr, lua2OptionalPaint(L, 2, &paint)));
     return 1;
 }
 
 static int lcanvas_restore(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->restore();
     return 0;
 }
 
 static int lcanvas_scale(lua_State* L) {
     SkScalar sx = lua2scalar_def(L, 2, 1);
@@ skipping 18 matching lines @@
 static int lcanvas_concat(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->concat(*get_obj<SkMatrix>(L, 2));
     return 0;
 }
 
 static int lcanvas_newSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
     int height = lua2int_def(L, 3, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = get_ref<SkCanvas>(L, 1)->newSurface(info);
-    if (NULL == surface) {
+    if (nullptr == surface) {
         lua_pushnil(L);
     } else {
         push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lcanvas_gc(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->unref();
     return 0;
@@ skipping 23 matching lines @@
     { "saveLayer", lcanvas_saveLayer },
     { "restore", lcanvas_restore },
     { "scale", lcanvas_scale },
     { "translate", lcanvas_translate },
     { "rotate", lcanvas_rotate },
     { "concat", lcanvas_concat },
 
     { "newSurface", lcanvas_newSurface },
 
     { "__gc", lcanvas_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int ldocument_beginPage(lua_State* L) {
-    const SkRect* contentPtr = NULL;
+    const SkRect* contentPtr = nullptr;
     push_ref(L, get_ref<SkDocument>(L, 1)->beginPage(lua2scalar(L, 2),
                                                      lua2scalar(L, 3),
                                                      contentPtr));
     return 1;
 }
 
 static int ldocument_endPage(lua_State* L) {
     get_ref<SkDocument>(L, 1)->endPage();
     return 0;
 }
 
 static int ldocument_close(lua_State* L) {
     get_ref<SkDocument>(L, 1)->close();
     return 0;
 }
 
 static int ldocument_gc(lua_State* L) {
     get_ref<SkDocument>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkDocument_Methods[] = {
     { "beginPage", ldocument_beginPage },
     { "endPage", ldocument_endPage },
     { "close", ldocument_close },
     { "__gc", ldocument_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpaint_isAntiAlias(lua_State* L) {
     lua_pushboolean(L, get_obj<SkPaint>(L, 1)->isAntiAlias());
     return 1;
 }
 
 static int lpaint_setAntiAlias(lua_State* L) {
@@ skipping 368 matching lines @@
     { "getStrokeMiter", lpaint_getStrokeMiter },
     { "measureText", lpaint_measureText },
     { "getFontMetrics", lpaint_getFontMetrics },
     { "getEffects", lpaint_getEffects },
     { "getImageFilter", lpaint_getImageFilter },
     { "setImageFilter", lpaint_setImageFilter },
     { "getShader", lpaint_getShader },
     { "setShader", lpaint_setShader },
     { "getPathEffect", lpaint_getPathEffect },
     { "__gc", lpaint_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* mode2string(SkShader::TileMode mode) {
     static const char* gNames[] = { "clamp", "repeat", "mirror" };
     SkASSERT((unsigned)mode < SK_ARRAY_COUNT(gNames));
     return gNames[mode];
 }
 
@@ skipping 63 matching lines @@
 static int lshader_gc(lua_State* L) {
     get_ref<SkShader>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkShader_Methods[] = {
     { "isOpaque",       lshader_isOpaque },
     { "isABitmap",      lshader_isABitmap },
     { "asAGradient",    lshader_asAGradient },
     { "__gc",           lshader_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpatheffect_asADash(lua_State* L) {
     SkPathEffect* pe = get_ref<SkPathEffect>(L, 1);
     if (pe) {
         SkPathEffect::DashInfo info;
         SkPathEffect::DashType dashType = pe->asADash(&info);
         if (SkPathEffect::kDash_DashType == dashType) {
             SkAutoTArray<SkScalar> intervals(info.fCount);
             info.fIntervals = intervals.get();
             pe->asADash(&info);
             SkLua(L).pushDash(info);
             return 1;
         }
     }
     return 0;
 }
 
 static int lpatheffect_gc(lua_State* L) {
     get_ref<SkPathEffect>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkPathEffect_Methods[] = {
     { "asADash",        lpatheffect_asADash },
     { "__gc",           lpatheffect_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpimagefilter_gc(lua_State* L) {
     get_ref<SkImageFilter>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkImageFilter_Methods[] = {
     { "__gc",       lpimagefilter_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lmatrix_getType(lua_State* L) {
     SkMatrix::TypeMask mask = get_obj<SkMatrix>(L, 1)->getType();
 
     lua_newtable(L);
     setfield_boolean(L, "translate",   SkToBool(mask & SkMatrix::kTranslate_Mask));
     setfield_boolean(L, "scale",       SkToBool(mask & SkMatrix::kScale_Mask));
@@ skipping 68 matching lines @@
 
 static const struct luaL_Reg gSkMatrix_Methods[] = {
     { "getType", lmatrix_getType },
     { "getScaleX", lmatrix_getScaleX },
     { "getScaleY", lmatrix_getScaleY },
     { "getTranslateX", lmatrix_getTranslateX },
     { "getTranslateY", lmatrix_getTranslateY },
     { "setRectToRect", lmatrix_setRectToRect },
     { "invert", lmatrix_invert },
     { "mapXY", lmatrix_mapXY },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpath_getBounds(lua_State* L) {
     SkLua(L).pushRect(get_obj<SkPath>(L, 1)->getBounds());
     return 1;
 }
 
 static const char* fill_type_to_str(SkPath::FillType fill) {
@@ skipping 157 matching lines @@
     { "isRect", lpath_isRect },
     { "isNestedFillRects", lpath_isNestedFillRects },
     { "countPoints", lpath_countPoints },
     { "reset", lpath_reset },
     { "moveTo", lpath_moveTo },
     { "lineTo", lpath_lineTo },
     { "quadTo", lpath_quadTo },
     { "cubicTo", lpath_cubicTo },
     { "close", lpath_close },
     { "__gc", lpath_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* rrect_type(const SkRRect& rr) {
     switch (rr.getType()) {
         case SkRRect::kEmpty_Type: return "empty";
         case SkRRect::kRect_Type: return "rect";
         case SkRRect::kOval_Type: return "oval";
         case SkRRect::kSimple_Type: return "simple";
@@ skipping 31 matching lines @@
 static int lrrect_gc(lua_State* L) {
     get_obj<SkRRect>(L, 1)->~SkRRect();
     return 0;
 }
 
 static const struct luaL_Reg gSkRRect_Methods[] = {
     { "rect", lrrect_rect },
     { "type", lrrect_type },
     { "radii", lrrect_radii },
     { "__gc", lrrect_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int limage_width(lua_State* L) {
     lua_pushinteger(L, get_ref<SkImage>(L, 1)->width());
     return 1;
 }
 
 static int limage_height(lua_State* L) {
     lua_pushinteger(L, get_ref<SkImage>(L, 1)->height());
     return 1;
 }
 
 static int limage_newShader(lua_State* L) {
     SkShader::TileMode tmode = SkShader::kClamp_TileMode;
-    const SkMatrix* localM = NULL;
+    const SkMatrix* localM = nullptr;
     SkAutoTUnref<SkShader> shader(get_ref<SkImage>(L, 1)->newShader(tmode, tmode, localM));
     push_ref(L, shader.get());
     return 1;
 }
 
 static int limage_gc(lua_State* L) {
     get_ref<SkImage>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkImage_Methods[] = {
     { "width", limage_width },
     { "height", limage_height },
     { "newShader", limage_newShader },
     { "__gc", limage_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lsurface_width(lua_State* L) {
     lua_pushinteger(L, get_ref<SkSurface>(L, 1)->width());
     return 1;
 }
 
 static int lsurface_height(lua_State* L) {
     lua_pushinteger(L, get_ref<SkSurface>(L, 1)->height());
     return 1;
 }
 
 static int lsurface_getCanvas(lua_State* L) {
     SkCanvas* canvas = get_ref<SkSurface>(L, 1)->getCanvas();
-    if (NULL == canvas) {
+    if (nullptr == canvas) {
         lua_pushnil(L);
     } else {
         push_ref(L, canvas);
         // note: we don't unref canvas, since getCanvas did not ref it.
         // warning: this is weird: now Lua owns a ref on this canvas, but what if they let
         // the real owner (the surface) go away, but still hold onto the canvas?
         // *really* we want to sort of ref the surface again, but have the native object
         // know that it is supposed to be treated as a canvas...
     }
     return 1;
 }
 
 static int lsurface_newImageSnapshot(lua_State* L) {
     SkImage* image = get_ref<SkSurface>(L, 1)->newImageSnapshot();
-    if (NULL == image) {
+    if (nullptr == image) {
         lua_pushnil(L);
     } else {
         push_ref(L, image)->unref();
     }
     return 1;
 }
 
 static int lsurface_newSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
     int height = lua2int_def(L, 3, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = get_ref<SkSurface>(L, 1)->newSurface(info);
-    if (NULL == surface) {
+    if (nullptr == surface) {
         lua_pushnil(L);
     } else {
         push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lsurface_gc(lua_State* L) {
     get_ref<SkSurface>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkSurface_Methods[] = {
     { "width", lsurface_width },
     { "height", lsurface_height },
     { "getCanvas", lsurface_getCanvas },
     { "newImageSnapshot", lsurface_newImageSnapshot },
     { "newSurface", lsurface_newSurface },
     { "__gc", lsurface_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpicturerecorder_beginRecording(lua_State* L) {
     const SkScalar w = lua2scalar_def(L, 2, -1);
     const SkScalar h = lua2scalar_def(L, 3, -1);
     if (w <= 0 || h <= 0) {
         lua_pushnil(L);
         return 1;
     }
 
     SkCanvas* canvas = get_obj<SkPictureRecorder>(L, 1)->beginRecording(w, h);
-    if (NULL == canvas) {
+    if (nullptr == canvas) {
         lua_pushnil(L);
         return 1;
     }
 
     push_ref(L, canvas);
     return 1;
 }
 
 static int lpicturerecorder_getCanvas(lua_State* L) {
     SkCanvas* canvas = get_obj<SkPictureRecorder>(L, 1)->getRecordingCanvas();
-    if (NULL == canvas) {
+    if (nullptr == canvas) {
         lua_pushnil(L);
         return 1;
     }
     push_ref(L, canvas);
     return 1;
 }
 
 static int lpicturerecorder_endRecording(lua_State* L) {
     SkPicture* pic = get_obj<SkPictureRecorder>(L, 1)->endRecording();
-    if (NULL == pic) {
+    if (nullptr == pic) {
         lua_pushnil(L);
         return 1;
     }
     push_ref(L, pic)->unref();
     return 1;
 }
 
 static int lpicturerecorder_gc(lua_State* L) {
     get_obj<SkPictureRecorder>(L, 1)->~SkPictureRecorder();
     return 0;
 }
 
 static const struct luaL_Reg gSkPictureRecorder_Methods[] = {
     { "beginRecording", lpicturerecorder_beginRecording },
     { "getCanvas", lpicturerecorder_getCanvas },
     { "endRecording", lpicturerecorder_endRecording },
     { "__gc", lpicturerecorder_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpicture_width(lua_State* L) {
     lua_pushnumber(L, get_ref<SkPicture>(L, 1)->cullRect().width());
     return 1;
 }
 
 static int lpicture_height(lua_State* L) {
     lua_pushnumber(L, get_ref<SkPicture>(L, 1)->cullRect().height());
     return 1;
 }
 
 static int lpicture_gc(lua_State* L) {
     get_ref<SkPicture>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkPicture_Methods[] = {
     { "width", lpicture_width },
     { "height", lpicture_height },
     { "__gc", lpicture_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int ltextblob_bounds(lua_State* L) {
     SkLua(L).pushRect(get_ref<SkTextBlob>(L, 1)->bounds());
     return 1;
 }
 
 static int ltextblob_gc(lua_State* L) {
     SkSafeUnref(get_ref<SkTextBlob>(L, 1));
     return 0;
 }
 
 static const struct luaL_Reg gSkTextBlob_Methods[] = {
     { "bounds", ltextblob_bounds },
     { "__gc", ltextblob_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int ltypeface_getFamilyName(lua_State* L) {
     SkString str;
     get_ref<SkTypeface>(L, 1)->getFamilyName(&str);
     lua_pushstring(L, str.c_str());
     return 1;
 }
 
 static int ltypeface_getStyle(lua_State* L) {
     lua_pushnumber(L, (double)get_ref<SkTypeface>(L, 1)->style());
     return 1;
 }
 
 static int ltypeface_gc(lua_State* L) {
     SkSafeUnref(get_ref<SkTypeface>(L, 1));
     return 0;
 }
 
 static const struct luaL_Reg gSkTypeface_Methods[] = {
     { "getFamilyName", ltypeface_getFamilyName },
     { "getStyle", ltypeface_getStyle },
     { "__gc", ltypeface_gc },
-    { NULL, NULL }
+    { nullptr, nullptr }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class AutoCallLua {
 public:
     AutoCallLua(lua_State* L, const char func[], const char verb[]) : fL(L) {
         lua_getglobal(L, func);
         if (!lua_isfunction(L, -1)) {
             int t = lua_type(L, -1);
@@ skipping 13 matching lines @@
 
 private:
     lua_State* fL;
 };
 
 #define AUTO_LUA(verb)  AutoCallLua acl(fL, fFunc.c_str(), verb)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lsk_newDocumentPDF(lua_State* L) {
-    const char* file = NULL;
+    const char* file = nullptr;
     if (lua_gettop(L) > 0 && lua_isstring(L, 1)) {
-        file = lua_tolstring(L, 1, NULL);
+        file = lua_tolstring(L, 1, nullptr);
     }
 
     SkDocument* doc = SkDocument::CreatePDF(file);
-    if (NULL == doc) {
+    if (nullptr == doc) {
         // do I need to push a nil on the stack and return 1?
         return 0;
     } else {
         push_ref(L, doc)->unref();
         return 1;
     }
 }
 
 static int lsk_newBlurImageFilter(lua_State* L) {
     SkScalar sigmaX = lua2scalar_def(L, 1, 0);
     SkScalar sigmaY = lua2scalar_def(L, 2, 0);
     SkImageFilter* imf = SkBlurImageFilter::Create(sigmaX, sigmaY);
-    if (NULL == imf) {
+    if (nullptr == imf) {
         lua_pushnil(L);
     } else {
         push_ref(L, imf)->unref();
     }
     return 1;
 }
 
 static int lsk_newLinearGradient(lua_State* L) {
     SkScalar x0 = lua2scalar_def(L, 1, 0);
     SkScalar y0 = lua2scalar_def(L, 2, 0);
     SkColor  c0 = lua2color(L, 3);
     SkScalar x1 = lua2scalar_def(L, 4, 0);
     SkScalar y1 = lua2scalar_def(L, 5, 0);
     SkColor  c1 = lua2color(L, 6);
 
     SkPoint pts[] = { { x0, y0 }, { x1, y1 } };
     SkColor colors[] = { c0, c1 };
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
-    if (NULL == s) {
+    SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    if (nullptr == s) {
         lua_pushnil(L);
     } else {
         push_ref(L, s)->unref();
     }
     return 1;
 }
 
 static int lsk_newMatrix(lua_State* L) {
     push_new<SkMatrix>(L)->reset();
     return 1;
@@ skipping 15 matching lines @@
 }
 
 static int lsk_newRRect(lua_State* L) {
     push_new<SkRRect>(L)->setEmpty();
     return 1;
 }
 
 #include "SkTextBox.h"
 // Sk.newTextBlob(text, rect, paint)
 static int lsk_newTextBlob(lua_State* L) {
-    const char* text = lua_tolstring(L, 1, NULL);
+    const char* text = lua_tolstring(L, 1, nullptr);
     SkRect bounds;
     lua2rect(L, 2, &bounds);
     const SkPaint& paint = *get_obj<SkPaint>(L, 3);
 
     SkTextBox box;
     box.setMode(SkTextBox::kLineBreak_Mode);
     box.setBox(bounds);
     box.setText(text, strlen(text), paint);
 
     SkScalar newBottom;
     SkAutoTUnref<SkTextBlob> blob(box.snapshotTextBlob(&newBottom));
     push_ref<SkTextBlob>(L, blob);
     SkLua(L).pushScalar(newBottom);
     return 2;
 }
 
 static int lsk_newTypeface(lua_State* L) {
-    const char* name = NULL;
+    const char* name = nullptr;
     int style = SkTypeface::kNormal;
 
     int count = lua_gettop(L);
     if (count > 0 && lua_isstring(L, 1)) {
-        name = lua_tolstring(L, 1, NULL);
+        name = lua_tolstring(L, 1, nullptr);
         if (count > 1 && lua_isnumber(L, 2)) {
-            style = lua_tointegerx(L, 2, NULL) & SkTypeface::kBoldItalic;
+            style = lua_tointegerx(L, 2, nullptr) & SkTypeface::kBoldItalic;
         }
     }
 
     SkTypeface* face = SkTypeface::CreateFromName(name,
                                                   (SkTypeface::Style)style);
 //    SkDebugf("---- name <%s> style=%d, face=%p ref=%d\n", name, style, face, face->getRefCnt());
-    if (NULL == face) {
+    if (nullptr == face) {
         face = SkTypeface::RefDefault();
     }
     push_ref(L, face)->unref();
     return 1;
 }
 
 static int lsk_newRasterSurface(lua_State* L) {
     int width = lua2int_def(L, 1, 0);
     int height = lua2int_def(L, 2, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
     SkSurface* surface = SkSurface::NewRaster(info, &props);
-    if (NULL == surface) {
+    if (nullptr == surface) {
         lua_pushnil(L);
     } else {
         push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lsk_loadImage(lua_State* L) {
     if (lua_gettop(L) > 0 && lua_isstring(L, 1)) {
-        const char* name = lua_tolstring(L, 1, NULL);
+        const char* name = lua_tolstring(L, 1, nullptr);
         SkAutoDataUnref data(SkData::NewFromFileName(name));
         if (data.get()) {
             SkImage* image = SkImage::NewFromEncoded(data);
             if (image) {
                 push_ref(L, image)->unref();
                 return 1;
             }
         }
     }
     return 0;
@@ skipping 46 matching lines @@
     REG_CLASS(L, SkSurface);
     REG_CLASS(L, SkTextBlob);
     REG_CLASS(L, SkTypeface);
 }
 
 extern "C" int luaopen_skia(lua_State* L);
 extern "C" int luaopen_skia(lua_State* L) {
     SkLua::Load(L);
     return 0;
 }