Style Change: NULL->nullptr

src/core/SkPictureRecord.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 "SkPictureRecord.h"
 #include "SkDevice.h"
 #include "SkImage_Base.h"
@@ skipping 257 matching lines @@
         default:
             this->recordConcat(matrix);
             break;
     }
     this->INHERITED::didConcat(matrix);
 }
 
 void SkPictureRecord::recordConcat(const SkMatrix& matrix) {
     this->validate(fWriter.bytesWritten(), 0);
     // op + matrix
-    size_t size = kUInt32Size + matrix.writeToMemory(NULL);
+    size_t size = kUInt32Size + matrix.writeToMemory(nullptr);
     size_t initialOffset = this->addDraw(CONCAT, &size);
     this->addMatrix(matrix);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::didSetMatrix(const SkMatrix& matrix) {
     this->validate(fWriter.bytesWritten(), 0);
     // op + matrix
-    size_t size = kUInt32Size + matrix.writeToMemory(NULL);
+    size_t size = kUInt32Size + matrix.writeToMemory(nullptr);
     size_t initialOffset = this->addDraw(SET_MATRIX, &size);
     this->addMatrix(matrix);
     this->validate(initialOffset, size);
     this->INHERITED::didSetMatrix(matrix);
 }
 
 static bool regionOpExpands(SkRegion::Op op) {
     switch (op) {
         case SkRegion::kUnion_Op:
         case SkRegion::kXOR_Op:
@@ skipping 135 matching lines @@
     return offset;
 }
 
 void SkPictureRecord::onClipRegion(const SkRegion& region, SkRegion::Op op) {
     this->recordClipRegion(region, op);
     this->INHERITED::onClipRegion(region, op);
 }
 
 size_t SkPictureRecord::recordClipRegion(const SkRegion& region, SkRegion::Op op) {
     // op + clip params + region
-    size_t size = 2 * kUInt32Size + region.writeToMemory(NULL);
+    size_t size = 2 * kUInt32Size + region.writeToMemory(nullptr);
     // recordRestoreOffsetPlaceholder doesn't always write an offset
     if (!fRestoreOffsetStack.isEmpty()) {
         // + restore offset
         size += kUInt32Size;
     }
     size_t initialOffset = this->addDraw(CLIP_REGION, &size);
     this->addRegion(region);
     this->addInt(ClipParams_pack(op, false));
     size_t offset = this->recordRestoreOffsetPlaceholder(op);
 
@@ skipping 233 matching lines @@
     this->addInt(points);
     this->addScalar(constY);
     fWriter.writeMul4(xpos, points * sizeof(SkScalar));
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                        const SkMatrix* matrix, const SkPaint& paint) {
     // op + paint index + length + 'length' worth of data + path index + matrix
     const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
-    size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(NULL);
+    size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(nullptr);
     size_t initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
     SkASSERT(initialOffset+get_paint_offset(DRAW_TEXT_ON_PATH, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addText(text, byteLength);
     this->addPath(path);
     this->addMatrix(m);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
@@ skipping 11 matching lines @@
 
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                                     const SkPaint* paint) {
     // op + picture index
     size_t size = 2 * kUInt32Size;
     size_t initialOffset;
 
-    if (NULL == matrix && NULL == paint) {
+    if (nullptr == matrix && nullptr == paint) {
         initialOffset = this->addDraw(DRAW_PICTURE, &size);
         this->addPicture(picture);
     } else {
         const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
-        size += m.writeToMemory(NULL) + kUInt32Size;    // matrix + paint
+        size += m.writeToMemory(nullptr) + kUInt32Size;    // matrix + paint
         initialOffset = this->addDraw(DRAW_PICTURE_MATRIX_PAINT, &size);
         SkASSERT(initialOffset + get_paint_offset(DRAW_PICTURE_MATRIX_PAINT, size)
                  == fWriter.bytesWritten());
         this->addPaintPtr(paint);
         this->addMatrix(m);
         this->addPicture(picture);
     }
     this->validate(initialOffset, size);
 }
 
@@ skipping 135 matching lines @@
     }
     if (cull) {
         fWriter.write(cull, sizeof(SkRect));
     }
     this->validate(initialOffset, size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSurface* SkPictureRecord::onNewSurface(const SkImageInfo& info, const SkSurfaceProps&) {
-    return NULL;
+    return nullptr;
 }
 
 // If we already have a stored, can we reuse it instead of also storing b?
 static bool equivalent(const SkBitmap& a, const SkBitmap& b) {
     if (a.info() != b.info() || a.pixelRefOrigin() != b.pixelRefOrigin()) {
         // Requiring a.info() == b.info() may be overkill in some cases (alphatype mismatch),
         // but it sure makes things easier to reason about below.
         return false;
     }
     if (a.pixelRef() == b.pixelRef()) {
@@ skipping 120 matching lines @@
 void SkPictureRecord::addNoOp() {
     size_t size = kUInt32Size; // op
     this->addDraw(NOOP, &size);
 }
 
 void SkPictureRecord::addRect(const SkRect& rect) {
     fWriter.writeRect(rect);
 }
 
 void SkPictureRecord::addRectPtr(const SkRect* rect) {
-    if (fWriter.writeBool(rect != NULL)) {
+    if (fWriter.writeBool(rect != nullptr)) {
         fWriter.writeRect(*rect);
     }
 }
 
 void SkPictureRecord::addIRect(const SkIRect& rect) {
     fWriter.write(&rect, sizeof(rect));
 }
 
 void SkPictureRecord::addIRectPtr(const SkIRect* rect) {
-    if (fWriter.writeBool(rect != NULL)) {
+    if (fWriter.writeBool(rect != nullptr)) {
         *(SkIRect*)fWriter.reserve(sizeof(SkIRect)) = *rect;
     }
 }
 
 void SkPictureRecord::addRRect(const SkRRect& rrect) {
     fWriter.writeRRect(rrect);
 }
 
 void SkPictureRecord::addRegion(const SkRegion& region) {
     fWriter.writeRegion(region);
 }
 
 void SkPictureRecord::addText(const void* text, size_t byteLength) {
     fContentInfo.onDrawText();
     addInt(SkToInt(byteLength));
     fWriter.writePad(text, byteLength);
 }
 
 void SkPictureRecord::addTextBlob(const SkTextBlob *blob) {
     int index = fTextBlobRefs.count();
     *fTextBlobRefs.append() = blob;
     blob->ref();
     // follow the convention of recording a 1-based index
     this->addInt(index + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////