Style Change: NULL->nullptr

src/svg/SkSVGDevice.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSVGDevice.h"
 
 #include "SkBase64.h"
@@ skipping 20 matching lines @@
                           SkColorGetG(color),
                           SkColorGetB(color));
 }
 
 static SkScalar svg_opacity(SkColor color) {
     return SkIntToScalar(SkColorGetA(color)) / SK_AlphaOPAQUE;
 }
 
 // Keep in sync with SkPaint::Cap
 static const char* cap_map[]  = {
-    NULL,    // kButt_Cap (default)
+    nullptr,    // kButt_Cap (default)
     "round", // kRound_Cap
     "square" // kSquare_Cap
 };
 static_assert(SK_ARRAY_COUNT(cap_map) == SkPaint::kCapCount, "missing_cap_map_entry");
 
 static const char* svg_cap(SkPaint::Cap cap) {
     SkASSERT(cap < SK_ARRAY_COUNT(cap_map));
     return cap_map[cap];
 }
 
 // Keep in sync with SkPaint::Join
 static const char* join_map[] = {
-    NULL,    // kMiter_Join (default)
+    nullptr,    // kMiter_Join (default)
     "round", // kRound_Join
     "bevel"  // kBevel_Join
 };
 static_assert(SK_ARRAY_COUNT(join_map) == SkPaint::kJoinCount, "missing_join_map_entry");
 
 static const char* svg_join(SkPaint::Join join) {
     SkASSERT(join < SK_ARRAY_COUNT(join_map));
     return join_map[join];
 }
 
 // Keep in sync with SkPaint::Align
 static const char* text_align_map[] = {
-    NULL,     // kLeft_Align (default)
+    nullptr,     // kLeft_Align (default)
     "middle", // kCenter_Align
     "end"     // kRight_Align
 };
 static_assert(SK_ARRAY_COUNT(text_align_map) == SkPaint::kAlignCount,
               "missing_text_align_map_entry");
 static const char* svg_text_align(SkPaint::Align align) {
     SkASSERT(align < SK_ARRAY_COUNT(text_align_map));
     return text_align_map[align];
 }
 
@@ skipping 30 matching lines @@
     Resources(const SkPaint& paint)
         : fPaintServer(svg_color(paint.getColor())) {}
 
     SkString fPaintServer;
     SkString fClip;
 };
 
 class SVGTextBuilder : SkNoncopyable {
 public:
     SVGTextBuilder(const void* text, size_t byteLen, const SkPaint& paint, const SkPoint& offset,
-                   unsigned scalarsPerPos, const SkScalar pos[] = NULL)
+                   unsigned scalarsPerPos, const SkScalar pos[] = nullptr)
         : fOffset(offset)
         , fScalarsPerPos(scalarsPerPos)
         , fPos(pos)
         , fLastCharWasWhitespace(true) // start off in whitespace mode to strip all leading space
     {
         SkASSERT(scalarsPerPos <= 2);
         SkASSERT(scalarsPerPos == 0 || SkToBool(pos));
 
         int count = paint.countText(text, byteLen);
 
@@ skipping 141 matching lines @@
     uint32_t fGradientCount;
     uint32_t fClipCount;
     uint32_t fPathCount;
     uint32_t fImageCount;
 };
 
 class SkSVGDevice::AutoElement : ::SkNoncopyable {
 public:
     AutoElement(const char name[], SkXMLWriter* writer)
         : fWriter(writer)
-        , fResourceBucket(NULL) {
+        , fResourceBucket(nullptr) {
         fWriter->startElement(name);
     }
 
     AutoElement(const char name[], SkXMLWriter* writer, ResourceBucket* bucket,
                 const SkDraw& draw, const SkPaint& paint)
         : fWriter(writer)
         , fResourceBucket(bucket) {
 
         Resources res = this->addResources(draw, paint);
         if (!res.fClip.isEmpty()) {
@@ skipping 265 matching lines @@
         familyName.appendf((familyName.isEmpty() ? "%s" : ", %s"), familyString.fString.c_str());
     }
 
     if (!familyName.isEmpty()) {
         this->addAttribute("font-family", familyName);
     }
 }
 
 SkBaseDevice* SkSVGDevice::Create(const SkISize& size, SkXMLWriter* writer) {
     if (!writer) {
-        return NULL;
+        return nullptr;
     }
 
     return new SkSVGDevice(size, writer);
 }
 
 SkSVGDevice::SkSVGDevice(const SkISize& size, SkXMLWriter* writer)
     : INHERITED(SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fWriter(writer)
     , fResourceBucket(new ResourceBucket) {
     SkASSERT(writer);
@@ skipping 86 matching lines @@
 }
 
 void SkSVGDevice::drawBitmapCommon(const SkDraw& draw, const SkBitmap& bm,
                                    const SkPaint& paint) {
     SkAutoTUnref<const SkData> pngData(
         SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality));
     if (!pngData) {
         return;
     }
 
-    size_t b64Size = SkBase64::Encode(pngData->data(), pngData->size(), NULL);
+    size_t b64Size = SkBase64::Encode(pngData->data(), pngData->size(), nullptr);
     SkAutoTMalloc<char> b64Data(b64Size);
     SkBase64::Encode(pngData->data(), pngData->size(), b64Data.get());
 
     SkString svgImageData("data:image/png;base64,");
     svgImageData.append(b64Data.get(), b64Size);
 
     SkString imageID = fResourceBucket->addImage();
     {
         AutoElement defs("defs", fWriter);
         {
@@ skipping 125 matching lines @@
                                const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawVertices()\n");
 }
 
 void SkSVGDevice::drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                              const SkPaint&) {
     // todo
     SkDebugf("unsupported operation: drawDevice()\n");
 }