Style Change: NULL->nullptr

src/pdf/SkPDFDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFDevice.h"
 
 #include "SkAnnotation.h"
@@ skipping 25 matching lines @@
 
 #define DPI_FOR_RASTER_SCALE_ONE 72
 
 // Utility functions
 
 // If the paint will definitely draw opaquely, replace kSrc_Mode with
 // kSrcOver_Mode.  http://crbug.com/473572
 static void replace_srcmode_on_opaque_paint(SkPaint* paint) {
     if (kSrcOver_SkXfermodeInterpretation
         == SkInterpretXfermode(*paint, false)) {
-        paint->setXfermode(NULL);
+        paint->setXfermode(nullptr);
     }
 }
 
 static void emit_pdf_color(SkColor color, SkWStream* result) {
     SkASSERT(SkColorGetA(color) == 0xFF);  // We handle alpha elsewhere.
     SkScalar colorScale = SkScalarInvert(0xFF);
     SkPDFUtils::AppendScalar(SkColorGetR(color) * colorScale, result);
     result->writeText(" ");
     SkPDFUtils::AppendScalar(SkColorGetG(color) * colorScale, result);
     result->writeText(" ");
@@ skipping 22 matching lines @@
 // Stolen from measure_text in SkDraw.cpp and then tweaked.
 static void align_text(SkDrawCacheProc glyphCacheProc, const SkPaint& paint,
                        const uint16_t* glyphs, size_t len,
                        SkScalar* x, SkScalar* y) {
     if (paint.getTextAlign() == SkPaint::kLeft_Align) {
         return;
     }
 
     SkMatrix ident;
     ident.reset();
-    SkAutoGlyphCache autoCache(paint, NULL, &ident);
+    SkAutoGlyphCache autoCache(paint, nullptr, &ident);
     SkGlyphCache* cache = autoCache.getCache();
 
     const char* start = reinterpret_cast<const char*>(glyphs);
     const char* stop = reinterpret_cast<const char*>(glyphs + len);
     SkFixed xAdv = 0, yAdv = 0;
 
     // TODO(vandebo): This probably needs to take kerning into account.
     while (start < stop) {
         const SkGlyph& glyph = glyphCacheProc(cache, &start, 0, 0);
         xAdv += glyph.fAdvanceX;
@@ skipping 19 matching lines @@
     return typeface->countGlyphs() - 1;
 }
 
 typedef SkAutoSTMalloc<128, uint16_t> SkGlyphStorage;
 
 static int force_glyph_encoding(const SkPaint& paint, const void* text,
                                 size_t len, SkGlyphStorage* storage,
                                 const uint16_t** glyphIDs) {
     // Make sure we have a glyph id encoding.
     if (paint.getTextEncoding() != SkPaint::kGlyphID_TextEncoding) {
-        int numGlyphs = paint.textToGlyphs(text, len, NULL);
+        int numGlyphs = paint.textToGlyphs(text, len, nullptr);
         storage->reset(numGlyphs);
         paint.textToGlyphs(text, len, storage->get());
         *glyphIDs = storage->get();
         return numGlyphs;
     }
 
     // For user supplied glyph ids we need to validate them.
     SkASSERT((len & 1) == 0);
     int numGlyphs = SkToInt(len / 2);
     const uint16_t* input = static_cast<const uint16_t*>(text);
@@ skipping 57 matching lines @@
 
     // When emitting the content entry, we will ensure the graphic state
     // is set to these values first.
     SkColor fColor;
     SkScalar fTextScaleX;  // Zero means we don't care what the value is.
     SkPaint::Style fTextFill;  // Only if TextScaleX is non-zero.
     int fShaderIndex;
     int fGraphicStateIndex;
 
     // We may change the font (i.e. for Type1 support) within a
-    // ContentEntry.  This is the one currently in effect, or NULL if none.
+    // ContentEntry.  This is the one currently in effect, or nullptr if none.
     SkPDFFont* fFont;
     // In PDF, text size has no default value. It is only valid if fFont is
-    // not NULL.
+    // not nullptr.
     SkScalar fTextSize;
 };
 
 GraphicStateEntry::GraphicStateEntry() : fColor(SK_ColorBLACK),
                                          fTextScaleX(SK_Scalar1),
                                          fTextFill(SkPaint::kFill_Style),
                                          fShaderIndex(-1),
                                          fGraphicStateIndex(-1),
-                                         fFont(NULL),
+                                         fFont(nullptr),
                                          fTextSize(SK_ScalarNaN) {
     fMatrix.reset();
 }
 
 bool GraphicStateEntry::compareInitialState(const GraphicStateEntry& cur) {
     return fColor == cur.fColor &&
            fShaderIndex == cur.fShaderIndex &&
            fGraphicStateIndex == cur.fGraphicStateIndex &&
            fMatrix == cur.fMatrix &&
            fClipStack == cur.fClipStack &&
@@ skipping 72 matching lines @@
             SkASSERT(prefixEntry->getOp() == SkRegion::kIntersect_Op);
             SkASSERT(iterEntry->getOp() == SkRegion::kIntersect_Op);
             SkASSERT(iterEntry->getType() == prefixEntry->getType());
             // back up the iterator by one
             iter->prev();
             prefixEntry = prefixIter.next();
             break;
         }
     }
 
-    SkASSERT(prefixEntry == NULL);
+    SkASSERT(prefixEntry == nullptr);
 }
 
 static void emit_clip(SkPath* clipPath, SkRect* clipRect,
                       SkWStream* contentStream) {
     SkASSERT(clipPath || clipRect);
 
     SkPath::FillType clipFill;
     if (clipPath) {
         SkPDFUtils::EmitPath(*clipPath, SkPaint::kFill_Style, contentStream);
         clipFill = clipPath->getFillType();
@@ skipping 114 matching lines @@
 
     currentEntry()->fClipStack = clipStack;
     currentEntry()->fClipRegion = clipRegion;
 
     SkMatrix transform;
     transform.setTranslate(translation.fX, translation.fY);
 
 #ifdef SK_PDF_USE_PATHOPS_CLIPPING
     SkPath clipPath;
     if (get_clip_stack_path(transform, clipStack, clipRegion, &clipPath)) {
-        emit_clip(&clipPath, NULL, fContentStream);
+        emit_clip(&clipPath, nullptr, fContentStream);
         return;
     }
 #endif
     // gsState->initialEntry()->fClipStack/Region specifies the clip that has
     // already been applied.  (If this is a top level device, then it specifies
     // a clip to the content area.  If this is a layer, then it specifies
     // the clip in effect when the layer was created.)  There's no need to
     // reapply that clip; SKCanvas's SkDrawIter will draw anything outside the
     // initial clip on the parent layer.  (This means there's a bug if the user
     // expands the clip and then uses any xfer mode that uses dst:
     // http://code.google.com/p/skia/issues/detail?id=228 )
     SkClipStack::Iter iter;
     skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
 
     // If the clip stack does anything other than intersect or if it uses
     // an inverse fill type, we have to fall back to the clip region.
     bool needRegion = false;
     const SkClipStack::Element* clipEntry;
     for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
         if (clipEntry->getOp() != SkRegion::kIntersect_Op ||
                 clipEntry->isInverseFilled()) {
             needRegion = true;
             break;
         }
     }
 
     if (needRegion) {
         SkPath clipPath;
         SkAssertResult(clipRegion.getBoundaryPath(&clipPath));
-        emit_clip(&clipPath, NULL, fContentStream);
+        emit_clip(&clipPath, nullptr, fContentStream);
     } else {
         skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
         const SkClipStack::Element* clipEntry;
         for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
             SkASSERT(clipEntry->getOp() == SkRegion::kIntersect_Op);
             switch (clipEntry->getType()) {
                 case SkClipStack::Element::kRect_Type: {
                     SkRect translatedClip;
                     transform.mapRect(&translatedClip, clipEntry->getRect());
-                    emit_clip(NULL, &translatedClip, fContentStream);
+                    emit_clip(nullptr, &translatedClip, fContentStream);
                     break;
                 }
                 default: {
                     SkPath translatedPath;
                     clipEntry->asPath(&translatedPath);
                     translatedPath.transform(transform, &translatedPath);
-                    emit_clip(&translatedPath, NULL, fContentStream);
+                    emit_clip(&translatedPath, nullptr, fContentStream);
                     break;
                 }
             }
         }
     }
 }
 
 void GraphicStackState::updateMatrix(const SkMatrix& matrix) {
     if (matrix == currentEntry()->fMatrix) {
         return;
@@ skipping 60 matching lines @@
 }
 
 static bool not_supported_for_layers(const SkPaint& layerPaint) {
     // PDF does not support image filters, so render them on CPU.
     // Note that this rendering is done at "screen" resolution (100dpi), not
     // printer resolution.
     // FIXME: It may be possible to express some filters natively using PDF
     // to improve quality and file size (http://skbug.com/3043)
 
     // TODO: should we return true if there is a colorfilter?
-    return layerPaint.getImageFilter() != NULL;
+    return layerPaint.getImageFilter() != nullptr;
 }
 
 SkBaseDevice* SkPDFDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) {
     if (cinfo.fForImageFilter ||
         (layerPaint && not_supported_for_layers(*layerPaint))) {
-        return NULL;
+        return nullptr;
     }
     SkISize size = SkISize::Make(cinfo.fInfo.width(), cinfo.fInfo.height());
     return SkPDFDevice::Create(size, fRasterDpi, fCanon);
 }
 
 
 struct ContentEntry {
     GraphicStateEntry fState;
     SkDynamicMemoryWStream fContent;
     SkAutoTDelete<ContentEntry> fNext;
 
     // If the stack is too deep we could get Stack Overflow.
     // So we manually destruct the object.
     ~ContentEntry() {
         ContentEntry* val = fNext.detach();
-        while (val != NULL) {
+        while (val != nullptr) {
             ContentEntry* valNext = val->fNext.detach();
-            // When the destructor is called, fNext is NULL and exits.
+            // When the destructor is called, fNext is nullptr and exits.
             delete val;
             val = valNext;
         }
     }
 };
 
 // A helper class to automatically finish a ContentEntry at the end of a
 // drawing method and maintain the state needed between set up and finish.
 class ScopedContentEntry {
 public:
     ScopedContentEntry(SkPDFDevice* device, const SkDraw& draw,
                        const SkPaint& paint, bool hasText = false)
         : fDevice(device),
-          fContentEntry(NULL),
+          fContentEntry(nullptr),
           fXfermode(SkXfermode::kSrcOver_Mode),
-          fDstFormXObject(NULL) {
+          fDstFormXObject(nullptr) {
         init(draw.fClipStack, *draw.fClip, *draw.fMatrix, paint, hasText);
     }
     ScopedContentEntry(SkPDFDevice* device, const SkClipStack* clipStack,
                        const SkRegion& clipRegion, const SkMatrix& matrix,
                        const SkPaint& paint, bool hasText = false)
         : fDevice(device),
-          fContentEntry(NULL),
+          fContentEntry(nullptr),
           fXfermode(SkXfermode::kSrcOver_Mode),
-          fDstFormXObject(NULL) {
+          fDstFormXObject(nullptr) {
         init(clipStack, clipRegion, matrix, paint, hasText);
     }
 
     ~ScopedContentEntry() {
         if (fContentEntry) {
             SkPath* shape = &fShape;
             if (shape->isEmpty()) {
-                shape = NULL;
+                shape = nullptr;
             }
             fDevice->finishContentEntry(fXfermode, fDstFormXObject, shape);
         }
         SkSafeUnref(fDstFormXObject);
     }
 
     ContentEntry* entry() { return fContentEntry; }
 
     /* Returns true when we explicitly need the shape of the drawing. */
     bool needShape() {
@@ skipping 52 matching lines @@
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFDevice::SkPDFDevice(SkISize pageSize, SkScalar rasterDpi, SkPDFCanon* canon, bool flip)
     : INHERITED(SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fPageSize(pageSize)
     , fContentSize(pageSize)
     , fExistingClipRegion(SkIRect::MakeSize(pageSize))
-    , fAnnotations(NULL)
-    , fLastContentEntry(NULL)
-    , fLastMarginContentEntry(NULL)
+    , fAnnotations(nullptr)
+    , fLastContentEntry(nullptr)
+    , fLastMarginContentEntry(nullptr)
     , fDrawingArea(kContent_DrawingArea)
-    , fClipStack(NULL)
+    , fClipStack(nullptr)
     , fFontGlyphUsage(new SkPDFGlyphSetMap)
     , fRasterDpi(rasterDpi)
     , fCanon(canon) {
     SkASSERT(pageSize.width() > 0);
     SkASSERT(pageSize.height() > 0);
     fLegacyBitmap.setInfo(
             SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()));
     if (flip) {
         // Skia generally uses the top left as the origin but PDF
         // natively has the origin at the bottom left. This matrix
         // corrects for that.  But that only needs to be done once, we
         // don't do it when layering.
         fInitialTransform.setTranslate(0, SkIntToScalar(pageSize.fHeight));
         fInitialTransform.preScale(SK_Scalar1, -SK_Scalar1);
     } else {
         fInitialTransform.setIdentity();
     }
 }
 
 SkPDFDevice::~SkPDFDevice() {
     this->cleanUp(true);
 }
 
 void SkPDFDevice::init() {
-    fAnnotations = NULL;
+    fAnnotations = nullptr;
     fContentEntries.free();
-    fLastContentEntry = NULL;
+    fLastContentEntry = nullptr;
     fMarginContentEntries.free();
-    fLastMarginContentEntry = NULL;
+    fLastMarginContentEntry = nullptr;
     fDrawingArea = kContent_DrawingArea;
-    if (fFontGlyphUsage.get() == NULL) {
+    if (fFontGlyphUsage.get() == nullptr) {
         fFontGlyphUsage.reset(new SkPDFGlyphSetMap);
     }
 }
 
 void SkPDFDevice::cleanUp(bool clearFontUsage) {
     fGraphicStateResources.unrefAll();
     fXObjectResources.unrefAll();
     fFontResources.unrefAll();
     fShaderResources.unrefAll();
     SkSafeUnref(fAnnotations);
@@ skipping 188 matching lines @@
     SkASSERT(annotation);
     SkData* urlData = annotation->find(SkAnnotationKeys::URL_Key());
     if (urlData) {
         return create_link_to_url(urlData, r);
     }
     SkData* linkToName =
             annotation->find(SkAnnotationKeys::Link_Named_Dest_Key());
     if (linkToName) {
         return create_link_named_dest(linkToName, r);
     }
-    return NULL;
+    return nullptr;
 }
 
 void SkPDFDevice::drawRect(const SkDraw& d,
                            const SkRect& rect,
                            const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkRect r = rect;
     r.sort();
 
     if (paint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         SkPath path;
         path.addRect(r);
-        drawPath(d, path, paint, NULL, true);
+        drawPath(d, path, paint, nullptr, true);
         return;
     }
 
     if (SkAnnotation* annotation = paint.getAnnotation()) {
         SkPath path;
         path.addRect(rect);
         SkRect transformedRect =
                 transform_and_clip_path(d, path, fInitialTransform).getBounds();
         SkAutoTUnref<SkPDFDict> annot(
                 create_rect_annotation(transformedRect, annotation));
@@ skipping 12 matching lines @@
                           &content.entry()->fContent);
 }
 
 void SkPDFDevice::drawRRect(const SkDraw& draw,
                             const SkRRect& rrect,
                             const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkPath  path;
     path.addRRect(rrect);
-    this->drawPath(draw, path, paint, NULL, true);
+    this->drawPath(draw, path, paint, nullptr, true);
 }
 
 void SkPDFDevice::drawOval(const SkDraw& draw,
                            const SkRect& oval,
                            const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkPath  path;
     path.addOval(oval);
-    this->drawPath(draw, path, paint, NULL, true);
+    this->drawPath(draw, path, paint, nullptr, true);
 }
 
 void SkPDFDevice::drawPath(const SkDraw& d,
                            const SkPath& origPath,
                            const SkPaint& srcPaint,
                            const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkPath modifiedPath;
@@ skipping 16 matching lines @@
         if (d.fClip->isEmpty()) {
             return;
         }
         if (!pathIsMutable) {
             pathPtr = &modifiedPath;
             pathIsMutable = true;
         }
         bool fill = paint.getFillPath(origPath, pathPtr);
 
         SkPaint noEffectPaint(paint);
-        noEffectPaint.setPathEffect(NULL);
+        noEffectPaint.setPathEffect(nullptr);
         if (fill) {
             noEffectPaint.setStyle(SkPaint::kFill_Style);
         } else {
             noEffectPaint.setStyle(SkPaint::kStroke_Style);
             noEffectPaint.setStrokeWidth(0);
         }
-        drawPath(d, *pathPtr, noEffectPaint, NULL, true);
+        drawPath(d, *pathPtr, noEffectPaint, nullptr, true);
         return;
     }
 
     if (handleInversePath(d, origPath, paint, pathIsMutable, prePathMatrix)) {
         return;
     }
 
     if (SkAnnotation* annotation = paint.getAnnotation()) {
         SkRect transformedRect =
                 transform_and_clip_path(d, *pathPtr, fInitialTransform)
@@ skipping 83 matching lines @@
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix transform = matrix;
     transform.postConcat(*d.fMatrix);
-    this->internalDrawBitmap(transform, d.fClipStack, *d.fClip, bitmap, NULL,
+    this->internalDrawBitmap(transform, d.fClipStack, *d.fClip, bitmap, nullptr,
                              paint);
 }
 
 void SkPDFDevice::drawSprite(const SkDraw& d, const SkBitmap& bitmap,
                              int x, int y, const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
-    this->internalDrawBitmap(matrix, d.fClipStack, *d.fClip, bitmap, NULL,
+    this->internalDrawBitmap(matrix, d.fClipStack, *d.fClip, bitmap, nullptr,
                              paint);
 }
 
 //  Create a PDF string. Maximum length (in bytes) is 65,535.
 //  @param input     A string value.
 //  @param len       The length of the input array.
 //  @param wideChars True iff the upper byte in each uint16_t is
 //                   significant and should be encoded and not
 //                   discarded.  If true, the upper byte is encoded
 //                   first.  Otherwise, we assert the upper byte is
@@ skipping 23 matching lines @@
         }
         return SkPDFUtils::FormatString(tmp.c_str(), tmp.size());
     }
 }
 
 void SkPDFDevice::drawText(const SkDraw& d, const void* text, size_t len,
                            SkScalar x, SkScalar y, const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
 
-    NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
-    if (paint.getMaskFilter() != NULL) {
+    NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
+    if (paint.getMaskFilter() != nullptr) {
         // Don't pretend we support drawing MaskFilters, it makes for artifacts
         // making text unreadable (e.g. same text twice when using CSS shadows).
         return;
     }
     SkPaint textPaint = calculate_text_paint(paint);
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
         return;
     }
 
     SkGlyphStorage storage(0);
-    const uint16_t* glyphIDs = NULL;
+    const uint16_t* glyphIDs = nullptr;
     int numGlyphs = force_glyph_encoding(paint, text, len, &storage, &glyphIDs);
     textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
     SkDrawCacheProc glyphCacheProc = textPaint.getDrawCacheProc();
     align_text(glyphCacheProc, textPaint, glyphIDs, numGlyphs, &x, &y);
     content.entry()->fContent.writeText("BT\n");
     set_text_transform(x, y, textPaint.getTextSkewX(),
                        &content.entry()->fContent);
     int consumedGlyphCount = 0;
 
@@ skipping 18 matching lines @@
     }
     content.entry()->fContent.writeText("ET\n");
 }
 
 void SkPDFDevice::drawPosText(const SkDraw& d, const void* text, size_t len,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
 
-    NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
-    if (paint.getMaskFilter() != NULL) {
+    NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
+    if (paint.getMaskFilter() != nullptr) {
         // Don't pretend we support drawing MaskFilters, it makes for artifacts
         // making text unreadable (e.g. same text twice when using CSS shadows).
         return;
     }
     SkASSERT(1 == scalarsPerPos || 2 == scalarsPerPos);
     SkPaint textPaint = calculate_text_paint(paint);
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
         return;
     }
 
     SkGlyphStorage storage(0);
-    const uint16_t* glyphIDs = NULL;
+    const uint16_t* glyphIDs = nullptr;
     size_t numGlyphs = force_glyph_encoding(paint, text, len, &storage, &glyphIDs);
     textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
     SkDrawCacheProc glyphCacheProc = textPaint.getDrawCacheProc();
     content.entry()->fContent.writeText("BT\n");
     this->updateFont(textPaint, glyphIDs[0], content.entry());
     for (size_t i = 0; i < numGlyphs; i++) {
         SkPDFFont* font = content.entry()->fState.fFont;
         uint16_t encodedValue = glyphIDs[i];
         if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
@@ skipping 72 matching lines @@
 void SkPDFDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
     fClipStack = canvas->getClipStack();
 }
 
 void SkPDFDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
 
-    fClipStack = NULL;
+    fClipStack = nullptr;
 }
 
 SkSurface* SkPDFDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     return SkSurface::NewRaster(info, &props);
 }
 
 ContentEntry* SkPDFDevice::getLastContentEntry() {
     if (fDrawingArea == kContent_DrawingArea) {
         return fLastContentEntry;
     } else {
@@ skipping 56 matching lines @@
     SkDynamicMemoryWStream buffer;
     this->writeContent(&buffer);
     return buffer.detachAsStream();
 }
 
 void SkPDFDevice::copyContentEntriesToData(ContentEntry* entry,
         SkWStream* data) const {
     // TODO(ctguil): For margins, I'm not sure fExistingClipStack/Region is the
     // right thing to pass here.
     GraphicStackState gsState(fExistingClipStack, fExistingClipRegion, data);
-    while (entry != NULL) {
+    while (entry != nullptr) {
         SkPoint translation;
         translation.iset(this->getOrigin());
         translation.negate();
         gsState.updateClip(entry->fState.fClipStack, entry->fState.fClipRegion,
                            translation);
         gsState.updateMatrix(entry->fState.fMatrix);
         gsState.updateDrawingState(entry->fState);
 
         entry->fContent.writeToStream(data);
         entry = entry->fNext.get();
@@ skipping 13 matching lines @@
     // sent across account for that)
     SkPDFDevice::copyContentEntriesToData(fMarginContentEntries.get(), out);
 
     // If the content area is the entire page, then we don't need to clip
     // the content area (PDF area clips to the page size).  Otherwise,
     // we have to clip to the content area; we've already applied the
     // initial transform, so just clip to the device size.
     if (fPageSize != fContentSize) {
         SkRect r = SkRect::MakeWH(SkIntToScalar(this->width()),
                                   SkIntToScalar(this->height()));
-        emit_clip(NULL, &r, out);
+        emit_clip(nullptr, &r, out);
     }
 
     SkPDFDevice::copyContentEntriesToData(fContentEntries.get(), out);
 }
 
 /* Draws an inverse filled path by using Path Ops to compute the positive
  * inverse using the current clip as the inverse bounds.
  * Return true if this was an inverse path and was properly handled,
  * otherwise returns false and the normal drawing routine should continue,
  * either as a (incorrect) fallback or because the path was not inverse
@@ skipping 19 matching lines @@
         SkPaint::kStrokeAndFill_Style == paint.getStyle()) {
         bool doFillPath = paint.getFillPath(origPath, &modifiedPath);
         if (doFillPath) {
             noInversePaint.setStyle(SkPaint::kFill_Style);
             noInversePaint.setStrokeWidth(0);
             pathPtr = &modifiedPath;
         } else {
             // To be consistent with the raster output, hairline strokes
             // are rendered as non-inverted.
             modifiedPath.toggleInverseFillType();
-            drawPath(d, modifiedPath, paint, NULL, true);
+            drawPath(d, modifiedPath, paint, nullptr, true);
             return true;
         }
     }
 
     // Get bounds of clip in current transform space
     // (clip bounds are given in device space).
     SkRect bounds;
     SkMatrix transformInverse;
     SkMatrix totalMatrix = *d.fMatrix;
     if (prePathMatrix) {
@@ skipping 38 matching lines @@
             SkPoint translatedPoint;
             transform.mapXY(points[i].x(), points[i].y(), &translatedPoint);
             fNamedDestinations.push(new NamedDestination(nameData, translatedPoint));
         }
         return true;
     }
     return false;
 }
 
 void SkPDFDevice::addAnnotation(SkPDFDict* annotation) {
-    if (NULL == fAnnotations) {
+    if (nullptr == fAnnotations) {
         fAnnotations = new SkPDFArray;
     }
     fAnnotations->appendObject(annotation);
 }
 
 
 void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const {
     int nDest = fNamedDestinations.count();
     for (int i = 0; i < nDest; i++) {
         NamedDestination* dest = fNamedDestinations[i];
@@ skipping 48 matching lines @@
     SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
                                   &content.entry()->fContent);
 }
 
 ContentEntry* SkPDFDevice::setUpContentEntry(const SkClipStack* clipStack,
                                              const SkRegion& clipRegion,
                                              const SkMatrix& matrix,
                                              const SkPaint& paint,
                                              bool hasText,
                                              SkPDFFormXObject** dst) {
-    *dst = NULL;
+    *dst = nullptr;
     if (clipRegion.isEmpty()) {
-        return NULL;
+        return nullptr;
     }
 
     // The clip stack can come from an SkDraw where it is technically optional.
     SkClipStack synthesizedClipStack;
-    if (clipStack == NULL) {
+    if (clipStack == nullptr) {
         if (clipRegion == fExistingClipRegion) {
             clipStack = &fExistingClipStack;
         } else {
             // GraphicStackState::updateClip expects the clip stack to have
             // fExistingClip as a prefix, so start there, then set the clip
             // to the passed region.
             synthesizedClipStack = fExistingClipStack;
             SkPath clipPath;
             clipRegion.getBoundaryPath(&clipPath);
             synthesizedClipStack.clipDevPath(clipPath, SkRegion::kReplace_Op,
@@ skipping 18 matching lines @@
             xfermode == SkXfermode::kSrcATop_Mode ||
             xfermode == SkXfermode::kDstATop_Mode ||
             xfermode == SkXfermode::kModulate_Mode) {
         if (!isContentEmpty()) {
             *dst = createFormXObjectFromDevice();
             SkASSERT(isContentEmpty());
         } else if (xfermode != SkXfermode::kSrc_Mode &&
                    xfermode != SkXfermode::kSrcOut_Mode) {
             // Except for Src and SrcOut, if there isn't anything already there,
             // then we're done.
-            return NULL;
+            return nullptr;
         }
     }
     // TODO(vandebo): Figure out how/if we can handle the following modes:
     // Xor, Plus.
 
     // Dst xfer mode doesn't draw source at all.
     if (xfermode == SkXfermode::kDst_Mode) {
-        return NULL;
+        return nullptr;
     }
 
     ContentEntry* entry;
     SkAutoTDelete<ContentEntry> newEntry;
 
     ContentEntry* lastContentEntry = getLastContentEntry();
     if (lastContentEntry && lastContentEntry->fContent.getOffset() == 0) {
         entry = lastContentEntry;
     } else {
         newEntry.reset(new ContentEntry);
@@ skipping 70 matching lines @@
     identity.reset();
     SkPaint stockPaint;
 
     SkAutoTUnref<SkPDFFormXObject> srcFormXObject;
     if (isContentEmpty()) {
         // If nothing was drawn and there's no shape, then the draw was a
         // no-op, but dst needs to be restored for that to be true.
         // If there is shape, then an empty source with Src, SrcIn, SrcOut,
         // DstIn, DstAtop or Modulate reduces to Clear and DstOut or SrcAtop
         // reduces to Dst.
-        if (shape == NULL || xfermode == SkXfermode::kDstOut_Mode ||
+        if (shape == nullptr || xfermode == SkXfermode::kDstOut_Mode ||
                 xfermode == SkXfermode::kSrcATop_Mode) {
             ScopedContentEntry content(this, &fExistingClipStack,
                                        fExistingClipRegion, identity,
                                        stockPaint);
             SkPDFUtils::DrawFormXObject(this->addXObjectResource(dst),
                                         &content.entry()->fContent);
             return;
         } else {
             xfermode = SkXfermode::kClear_Mode;
         }
     } else {
         SkASSERT(!fContentEntries->fNext.get());
         srcFormXObject.reset(createFormXObjectFromDevice());
     }
 
     // TODO(vandebo) srcFormXObject may contain alpha, but here we want it
     // without alpha.
     if (xfermode == SkXfermode::kSrcATop_Mode) {
         // TODO(vandebo): In order to properly support SrcATop we have to track
         // the shape of what's been drawn at all times. It's the intersection of
         // the non-transparent parts of the device and the outlines (shape) of
         // all images and devices drawn.
         drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()), dst,
                                 &fExistingClipStack, fExistingClipRegion,
                                 SkXfermode::kSrcOver_Mode, true);
     } else {
         SkAutoTUnref<SkPDFFormXObject> dstMaskStorage;
         SkPDFFormXObject* dstMask = srcFormXObject.get();
-        if (shape != NULL) {
+        if (shape != nullptr) {
             // Draw shape into a form-xobject.
             SkDraw d;
             d.fMatrix = &identity;
             d.fClip = &clipRegion;
             d.fClipStack = &clipStack;
             SkPaint filledPaint;
             filledPaint.setColor(SK_ColorBLACK);
             filledPaint.setStyle(SkPaint::kFill_Style);
-            this->drawPath(d, *shape, filledPaint, NULL, true);
+            this->drawPath(d, *shape, filledPaint, nullptr, true);
 
             dstMaskStorage.reset(createFormXObjectFromDevice());
             dstMask = dstMaskStorage.get();
         }
         drawFormXObjectWithMask(addXObjectResource(dst), dstMask,
                                 &fExistingClipStack, fExistingClipRegion,
                                 SkXfermode::kSrcOver_Mode, true);
     }
 
     if (xfermode == SkXfermode::kClear_Mode) {
@@ skipping 58 matching lines @@
     return false;
 }
 
 void SkPDFDevice::populateGraphicStateEntryFromPaint(
         const SkMatrix& matrix,
         const SkClipStack& clipStack,
         const SkRegion& clipRegion,
         const SkPaint& paint,
         bool hasText,
         GraphicStateEntry* entry) {
-    NOT_IMPLEMENTED(paint.getPathEffect() != NULL, false);
-    NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
-    NOT_IMPLEMENTED(paint.getColorFilter() != NULL, false);
+    NOT_IMPLEMENTED(paint.getPathEffect() != nullptr, false);
+    NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
+    NOT_IMPLEMENTED(paint.getColorFilter() != nullptr, false);
 
     entry->fMatrix = matrix;
     entry->fClipStack = clipStack;
     entry->fClipRegion = clipRegion;
     entry->fColor = SkColorSetA(paint.getColor(), 0xFF);
     entry->fShaderIndex = -1;
 
     // PDF treats a shader as a color, so we only set one or the other.
     SkAutoTUnref<SkPDFObject> pdfShader;
     const SkShader* shader = paint.getShader();
@@ skipping 29 matching lines @@
                 fShaderResources.push(pdfShader.get());
                 pdfShader.get()->ref();
             }
             entry->fShaderIndex = resourceIndex;
         } else {
             // A color shader is treated as an invalid shader so we don't have
             // to set a shader just for a color.
             SkShader::GradientInfo gradientInfo;
             SkColor gradientColor;
             gradientInfo.fColors = &gradientColor;
-            gradientInfo.fColorOffsets = NULL;
+            gradientInfo.fColorOffsets = nullptr;
             gradientInfo.fColorCount = 1;
             if (shader->asAGradient(&gradientInfo) ==
                     SkShader::kColor_GradientType) {
                 entry->fColor = SkColorSetA(gradientColor, 0xFF);
                 color = gradientColor;
             }
         }
     }
 
     SkAutoTUnref<SkPDFGraphicState> newGraphicState;
@@ skipping 37 matching lines @@
         result = fXObjectResources.count();
         fXObjectResources.push(xObject);
         xObject->ref();
     }
     return result;
 }
 
 void SkPDFDevice::updateFont(const SkPaint& paint, uint16_t glyphID,
                              ContentEntry* contentEntry) {
     SkTypeface* typeface = paint.getTypeface();
-    if (contentEntry->fState.fFont == NULL ||
+    if (contentEntry->fState.fFont == nullptr ||
             contentEntry->fState.fTextSize != paint.getTextSize() ||
             !contentEntry->fState.fFont->hasGlyph(glyphID)) {
         int fontIndex = getFontResourceIndex(typeface, glyphID);
         contentEntry->fContent.writeText("/");
         contentEntry->fContent.writeText(SkPDFResourceDict::getResourceName(
                 SkPDFResourceDict::kFont_ResourceType,
                 fontIndex).c_str());
         contentEntry->fContent.writeText(" ");
         SkPDFUtils::AppendScalar(paint.getTextSize(), &contentEntry->fContent);
         contentEntry->fContent.writeText(" Tf\n");
@@ skipping 34 matching lines @@
         SkBitmap* subsetBitmap;
         if (srcRect) {
             if (!origBitmap.extractSubset(&tmpSubsetBitmap, *srcRect)) {
                return;
             }
             subsetBitmap = &tmpSubsetBitmap;
         } else {
             subsetBitmap = &tmpSubsetBitmap;
             *subsetBitmap = origBitmap;
         }
-        srcRect = NULL;
+        srcRect = nullptr;
 
         // Transform the bitmap in the new space, without taking into
         // account the initial transform.
         SkPath perspectiveOutline;
         perspectiveOutline.addRect(
                 SkRect::MakeWH(SkIntToScalar(subsetBitmap->width()),
                                SkIntToScalar(subsetBitmap->height())));
         perspectiveOutline.transform(origMatrix);
 
         // TODO(edisonn): perf - use current clip too.
@@ skipping 55 matching lines @@
         // and scaled to reflect DPI.
         matrix.setScale(1 / scaleX, 1 / scaleY);
         matrix.postTranslate(deltaX, deltaY);
 
         perspectiveBounds.setRect(
                 SkIRect::MakeXYWH(SkScalarFloorToInt(bounds.x()),
                                   SkScalarFloorToInt(bounds.y()),
                                   SkScalarCeilToInt(bounds.width()),
                                   SkScalarCeilToInt(bounds.height())));
         clipRegion = &perspectiveBounds;
-        srcRect = NULL;
+        srcRect = nullptr;
         bitmap = &perspectiveBitmap;
     }
 
     SkMatrix scaled;
     // Adjust for origin flip.
     scaled.setScale(SK_Scalar1, -SK_Scalar1);
     scaled.postTranslate(0, SK_Scalar1);
     // Scale the image up from 1x1 to WxH.
     SkIRect subset = bitmap->bounds();
     scaled.postScale(SkIntToScalar(subset.width()),
@@ skipping 20 matching lines @@
         return;
     }
     SkAutoTUnref<SkPDFObject> image(SkPDFBitmap::Create(fCanon, subsetBitmap));
     if (!image) {
         return;
     }
 
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(image.get()),
                                 &content.entry()->fContent);
 }