Style Change: NULL->nullptr

src/pipe/SkGPipeWrite.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 "SkAnnotation.h"
 #include "SkBitmapHeap.h"
@@ skipping 35 matching lines @@
         case kColorFilter_PaintFlat:    return paint.getColorFilter();
         case kDrawLooper_PaintFlat:     return paint.getLooper();
         case kMaskFilter_PaintFlat:     return paint.getMaskFilter();
         case kPathEffect_PaintFlat:     return paint.getPathEffect();
         case kRasterizer_PaintFlat:     return paint.getRasterizer();
         case kShader_PaintFlat:         return paint.getShader();
         case kImageFilter_PaintFlat:    return paint.getImageFilter();
         case kXfermode_PaintFlat:       return paint.getXfermode();
     }
     SkDEBUGFAIL("never gets here");
-    return NULL;
+    return nullptr;
 }
 
 static size_t writeTypeface(SkWriter32* writer, SkTypeface* typeface) {
     SkASSERT(typeface);
     SkDynamicMemoryWStream stream;
     typeface->serialize(&stream);
     size_t size = stream.getOffset();
     if (writer) {
         writer->write32(SkToU32(size));
         SkAutoDataUnref data(stream.copyToData());
         writer->writePad(data->data(), size);
     }
     return 4 + SkAlign4(size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class FlattenableHeap : public SkFlatController {
 public:
     FlattenableHeap(int numFlatsToKeep, SkNamedFactorySet* fset, bool isCrossProcess)
     : INHERITED(isCrossProcess ? SkWriteBuffer::kCrossProcess_Flag : 0)
     , fNumFlatsToKeep(numFlatsToKeep) {
-        SkASSERT((isCrossProcess && fset != NULL) || (!isCrossProcess && NULL == fset));
+        SkASSERT((isCrossProcess && fset != nullptr) || (!isCrossProcess && nullptr == fset));
         if (isCrossProcess) {
             this->setNamedFactorySet(fset);
         }
     }
 
     ~FlattenableHeap() {
         fPointers.freeAll();
     }
 
     void* allocThrow(size_t bytes) override;
@@ skipping 53 matching lines @@
                 if (potential->index() == fFlatsThatMustBeKept[j]) {
                     mustKeep = true;
                     break;
                 }
             }
             if (!mustKeep) {
                 return potential;
             }
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct SkFlattenableTraits {
     static void Flatten(SkWriteBuffer& buffer, const SkFlattenable& flattenable) {
         buffer.writeFlattenable(&flattenable);
     }
     // No need to define unflatten if we never call it.
 };
@@ skipping 58 matching lines @@
             fBitmapShuttle->removeCanvas();
         }
         fDone = true;
     }
 
     void flushRecording(bool detachCurrentBlock);
     size_t freeMemoryIfPossible(size_t bytesToFree);
 
     size_t storageAllocatedForRecording() {
         size_t bytesAllocated = 0;
-        if (NULL != fBitmapHeap) {
+        if (nullptr != fBitmapHeap) {
             bytesAllocated += fBitmapHeap->bytesAllocated();
         }
-        if (NULL != fImageHeap) {
+        if (nullptr != fImageHeap) {
             bytesAllocated += fImageHeap->bytesInCache();
         }
         return bytesAllocated;
     }
 
     /**
      * Flatten an SkBitmap to send to the reader, where it will be referenced
      * according to slot.
      */
     bool shuttleBitmap(const SkBitmap&, int32_t slot);
@@ skipping 122 matching lines @@
     private:
         SkGPipeCanvas* fCanvas;
     };
     friend class AutoPipeNotify;
 
     typedef SkCanvas INHERITED;
 };
 
 void SkGPipeCanvas::flattenFactoryNames() {
     const char* name;
-    while ((name = fFactorySet->getNextAddedFactoryName()) != NULL) {
+    while ((name = fFactorySet->getNextAddedFactoryName()) != nullptr) {
         size_t len = strlen(name);
         if (this->needOpBytes(SkWriter32::WriteStringSize(name, len))) {
             this->writeOp(kDef_Factory_DrawOp);
             fWriter.writeString(name, len);
         }
     }
 }
 
 bool SkGPipeCanvas::shuttleBitmap(const SkBitmap& bm, int32_t slot) {
     SkASSERT(shouldFlattenBitmaps(fFlags));
     SkWriteBuffer buffer;
     buffer.setNamedFactoryRecorder(fFactorySet);
     buffer.writeBitmap(bm);
     this->flattenFactoryNames();
     size_t size = buffer.bytesWritten();
     if (this->needOpBytes(size)) {
         this->writeOp(kDef_Bitmap_DrawOp, 0, slot);
         void* dst = static_cast<void*>(fWriter.reserve(size));
         buffer.writeToMemory(dst);
         return true;
     }
     return false;
 }
 
-// return 0 for NULL (or unflattenable obj), or index-base-1
+// return 0 for nullptr (or unflattenable obj), or index-base-1
 // return ~(index-base-1) if an old flattenable was replaced
 int SkGPipeCanvas::flattenToIndex(SkFlattenable* obj, PaintFlats paintflat) {
-    SkASSERT(!fDone && fBitmapHeap != NULL);
-    if (NULL == obj) {
+    SkASSERT(!fDone && fBitmapHeap != nullptr);
+    if (nullptr == obj) {
         return 0;
     }
 
     fBitmapHeap->deferAddingOwners();
     bool added, replaced;
     const SkFlatData* flat = fFlatDictionary.findAndReplace(*obj, fFlattenableHeap.flatToReplace(),
                                                             &added, &replaced);
     fBitmapHeap->endAddingOwnersDeferral(added);
     int index = flat->index();
     if (added) {
@@ skipping 17 matching lines @@
 #define MIN_BLOCK_SIZE  (16 * 1024)
 #define BITMAPS_TO_KEEP 5
 #define FLATTENABLES_TO_KEEP 10
 
 SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
                              SkWriter32* writer,
                              uint32_t flags,
                              uint32_t width,
                              uint32_t height)
     : SkCanvas(width, height)
-    , fFactorySet(is_cross_process(flags) ? new SkNamedFactorySet : NULL)
+    , fFactorySet(is_cross_process(flags) ? new SkNamedFactorySet : nullptr)
     , fWriter(*writer)
     , fFlags(flags)
     , fFlattenableHeap(FLATTENABLES_TO_KEEP, fFactorySet, is_cross_process(flags))
     , fFlatDictionary(&fFlattenableHeap) {
     fController = controller;
     fDone = false;
     fBlockSize = 0; // need first block from controller
     fBytesNotified = 0;
     sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
 
@@ skipping 38 matching lines @@
     needed += 4;  // size of DrawOp atom
     needed = SkAlign4(needed);
     if (fWriter.bytesWritten() + needed > fBlockSize) {
         // Before we wipe out any data that has already been written, read it out.
         this->doNotify();
 
         // If we're going to allocate a new block, allocate enough to make it worthwhile.
         needed = SkTMax<size_t>(MIN_BLOCK_SIZE, needed);
 
         void* block = fController->requestBlock(needed, &fBlockSize);
-        if (NULL == block) {
+        if (nullptr == block) {
             // Do not notify the readers, which would call this function again.
             this->finish(false);
             return false;
         }
         SkASSERT(SkIsAlign4(fBlockSize));
         fWriter.reset(block, fBlockSize);
         fBytesNotified = 0;
     }
     return true;
 }
 
 uint32_t SkGPipeCanvas::getTypefaceID(SkTypeface* face) {
     uint32_t id = 0; // 0 means default/null typeface
     if (face) {
         id = fTypefaceSet.find(face);
         if (0 == id) {
             id = fTypefaceSet.add(face);
-            size_t size = writeTypeface(NULL, face);
+            size_t size = writeTypeface(nullptr, face);
             if (this->needOpBytes(size)) {
                 this->writeOp(kDef_Typeface_DrawOp);
                 writeTypeface(&fWriter, face);
             }
         }
     }
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 56 matching lines @@
 
 void SkGPipeCanvas::recordScale(const SkMatrix& m) {
     if (this->needOpBytes(2 * sizeof(SkScalar))) {
         this->writeOp(kScale_DrawOp);
         fWriter.writeScalar(m.getScaleX());
         fWriter.writeScalar(m.getScaleY());
     }
 }
 
 void SkGPipeCanvas::recordConcat(const SkMatrix& m) {
-    if (this->needOpBytes(m.writeToMemory(NULL))) {
+    if (this->needOpBytes(m.writeToMemory(nullptr))) {
         this->writeOp(kConcat_DrawOp);
         fWriter.writeMatrix(m);
     }
 }
 
 void SkGPipeCanvas::didConcat(const SkMatrix& matrix) {
     if (!matrix.isIdentity()) {
         NOTIFY_SETUP(this);
         switch (matrix.getType()) {
             case SkMatrix::kTranslate_Mask:
                 this->recordTranslate(matrix);
                 break;
             case SkMatrix::kScale_Mask:
                 this->recordScale(matrix);
                 break;
             default:
                 this->recordConcat(matrix);
                 break;
         }
     }
 
     this->INHERITED::didConcat(matrix);
 }
 
 void SkGPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
     NOTIFY_SETUP(this);
-    if (this->needOpBytes(matrix.writeToMemory(NULL))) {
+    if (this->needOpBytes(matrix.writeToMemory(nullptr))) {
         this->writeOp(kSetMatrix_DrawOp);
         fWriter.writeMatrix(matrix);
     }
     this->INHERITED::didSetMatrix(matrix);
 }
 
 void SkGPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op rgnOp,
                                ClipEdgeStyle edgeStyle) {
     NOTIFY_SETUP(this);
     if (this->needOpBytes(sizeof(SkRect))) {
@@ skipping 17 matching lines @@
         }
         this->writeOp(kClipRRect_DrawOp, flags, rgnOp);
         fWriter.writeRRect(rrect);
     }
     this->INHERITED::onClipRRect(rrect, rgnOp, edgeStyle);
 }
 
 void SkGPipeCanvas::onClipPath(const SkPath& path, SkRegion::Op rgnOp,
                                ClipEdgeStyle edgeStyle) {
     NOTIFY_SETUP(this);
-    if (this->needOpBytes(path.writeToMemory(NULL))) {
+    if (this->needOpBytes(path.writeToMemory(nullptr))) {
         unsigned flags = 0;
         if (kSoft_ClipEdgeStyle == edgeStyle) {
             flags = kClip_HasAntiAlias_DrawOpFlag;
         }
         this->writeOp(kClipPath_DrawOp, flags, rgnOp);
         fWriter.writePath(path);
     }
     // we just pass on the bounds of the path
     this->INHERITED::onClipRect(path.getBounds(), rgnOp, edgeStyle);
 }
 
 void SkGPipeCanvas::onClipRegion(const SkRegion& region, SkRegion::Op rgnOp) {
     NOTIFY_SETUP(this);
-    if (this->needOpBytes(region.writeToMemory(NULL))) {
+    if (this->needOpBytes(region.writeToMemory(nullptr))) {
         this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
         fWriter.writeRegion(region);
     }
     this->INHERITED::onClipRegion(region, rgnOp);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGPipeCanvas::onDrawPaint(const SkPaint& paint) {
     NOTIFY_SETUP(this);
@@ skipping 50 matching lines @@
     if (this->needOpBytes(kSizeOfFlatRRect * 2)) {
         this->writeOp(kDrawDRRect_DrawOp);
         fWriter.writeRRect(outer);
         fWriter.writeRRect(inner);
     }
 }
 
 void SkGPipeCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
-    if (this->needOpBytes(path.writeToMemory(NULL))) {
+    if (this->needOpBytes(path.writeToMemory(nullptr))) {
         this->writeOp(kDrawPath_DrawOp);
         fWriter.writePath(path);
     }
 }
 
 bool SkGPipeCanvas::commonDrawBitmap(const SkBitmap& bm, DrawOps op,
                                      unsigned flags,
                                      size_t opBytesNeeded,
                                      const SkPaint* paint) {
     if (fDone) {
         return false;
     }
 
-    if (paint != NULL) {
+    if (paint != nullptr) {
         flags |= kDrawBitmap_HasPaint_DrawOpFlag;
         this->writePaint(*paint);
     }
     // This needs to run first so its calls to needOpBytes() and its writes
     // don't interlace with the needOpBytes() and write below.
-    SkASSERT(fBitmapHeap != NULL);
+    SkASSERT(fBitmapHeap != nullptr);
     int32_t bitmapIndex = fBitmapHeap->insert(bm);
     if (SkBitmapHeap::INVALID_SLOT == bitmapIndex) {
         return false;
     }
 
     if (this->needOpBytes(opBytesNeeded)) {
         this->writeOp(op, flags, bitmapIndex);
         return true;
     }
     return false;
 }
 
 void SkGPipeCanvas::onDrawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
                                  const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkScalar) * 2;
 
     if (this->commonDrawBitmap(bm, kDrawBitmap_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.writeScalar(left);
         fWriter.writeScalar(top);
     }
 }
 
 void SkGPipeCanvas::onDrawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
                                      const SkPaint* paint, SrcRectConstraint constraint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkRect);
-    bool hasSrc = src != NULL;
+    bool hasSrc = src != nullptr;
     unsigned flags;
     if (hasSrc) {
         flags = kDrawBitmap_HasSrcRect_DrawOpFlag;
         opBytesNeeded += sizeof(int32_t) * 4;
     } else {
         flags = 0;
     }
     if (kFast_SrcRectConstraint == constraint) {
         flags |= kDrawBitmap_Bleed_DrawOpFlag;
     }
@@ skipping 29 matching lines @@
         fWriter.write32(top);
     }
 }
 
 bool SkGPipeCanvas::commonDrawImage(const SkImage* image, DrawOps op, unsigned flags,
                                     size_t opBytesNeeded, const SkPaint* paint) {
     if (fDone) {
         return false;
     }
     
-    if (paint != NULL) {
+    if (paint != nullptr) {
         flags |= kDrawBitmap_HasPaint_DrawOpFlag;
         this->writePaint(*paint);
     }
     // This needs to run first so its calls to needOpBytes() and its writes
     // don't interlace with the needOpBytes() and write below.
     int32_t slot = fImageHeap->insert(image);
     SkASSERT(slot != 0);
     if (this->needOpBytes(opBytesNeeded)) {
         this->writeOp(op, flags, slot);
         return true;
@@ skipping 51 matching lines @@
             fWriter.writeScalar(y);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                   const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
-        int count = paint.textToGlyphs(text, byteLength, NULL);
+        int count = paint.textToGlyphs(text, byteLength, nullptr);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
             this->writeOp(kDrawPosText_DrawOp);
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(pos, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                    SkScalar constY, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
-        int count = paint.textToGlyphs(text, byteLength, NULL);
+        int count = paint.textToGlyphs(text, byteLength, nullptr);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
             this->writeOp(kDrawPosTextH_DrawOp);
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(xpos, count * sizeof(SkScalar));
             fWriter.writeScalar(constY);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                      const SkMatrix* matrix, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         unsigned flags = 0;
-        size_t size = 4 + SkAlign4(byteLength) + path.writeToMemory(NULL);
+        size_t size = 4 + SkAlign4(byteLength) + path.writeToMemory(nullptr);
         if (matrix) {
             flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
-            size += matrix->writeToMemory(NULL);
+            size += matrix->writeToMemory(nullptr);
         }
         this->writePaint(paint);
         if (this->needOpBytes(size)) {
             this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
 
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
 
             fWriter.writePath(path);
             if (matrix) {
@@ skipping 241 matching lines @@
     }
 }
 
 void SkGPipeCanvas::resetImageHeap() {
     if (fImageHeap) {
         fImageHeap->reset();
     }
 }
 
 size_t SkGPipeCanvas::freeMemoryIfPossible(size_t bytesToFree) {
-    return (NULL == fBitmapHeap) ? 0 : fBitmapHeap->freeMemoryIfPossible(bytesToFree);
+    return (nullptr == fBitmapHeap) ? 0 : fBitmapHeap->freeMemoryIfPossible(bytesToFree);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T> uint32_t castToU32(T value) {
     union {
         T           fSrc;
         uint32_t    fDst;
     } data;
     data.fSrc = value;
@@ skipping 112 matching lines @@
         fWriter.write(storage, size);
         for (size_t i = 0; i < size/4; i++) {
 //            SkDebugf("[%d] %08X\n", i, storage[i]);
         }
     }
 
     //
     //  Do these after we've written kPaintOp_DrawOp
 
     if (base.getAnnotation() != paint.getAnnotation()) {
-        if (NULL == paint.getAnnotation()) {
+        if (nullptr == paint.getAnnotation()) {
             if (this->needOpBytes()) {
                 this->writeOp(kSetAnnotation_DrawOp, 0, 0);
             }
         } else {
             SkWriteBuffer buffer;
             paint.getAnnotation()->writeToBuffer(buffer);
             const size_t size = buffer.bytesWritten();
             if (this->needOpBytes(size)) {
                 this->writeOp(kSetAnnotation_DrawOp, 0, SkToU32(size));
                 buffer.writeToMemory(fWriter.reserve(size));
@@ skipping 20 matching lines @@
     fCanvas->resetImageHeap();
     // Other caches are self-purging with a small MRU pool
     // We could purge them as well, but it is not clear whether
     // that would be a win.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGPipeWriter::SkGPipeWriter()
 : fWriter(0) {
-    fCanvas = NULL;
+    fCanvas = nullptr;
 }
 
 SkGPipeWriter::~SkGPipeWriter() {
     this->endRecording();
 }
 
 SkCanvas* SkGPipeWriter::startRecording(SkGPipeController* controller, uint32_t flags,
                                         uint32_t width, uint32_t height) {
-    if (NULL == fCanvas) {
-        fWriter.reset(NULL, 0);
+    if (nullptr == fCanvas) {
+        fWriter.reset(nullptr, 0);
         fCanvas = new SkGPipeCanvas(controller, &fWriter, flags, width, height);
     }
     controller->setCanvas(fCanvas);
     return fCanvas;
 }
 
 void SkGPipeWriter::endRecording() {
     if (fCanvas) {
         fCanvas->finish(true);
         fCanvas->unref();
-        fCanvas = NULL;
+        fCanvas = nullptr;
     }
 }
 
 void SkGPipeWriter::flushRecording(bool detachCurrentBlock) {
     if (fCanvas) {
         fCanvas->flushRecording(detachCurrentBlock);
     }
 }
 
 size_t SkGPipeWriter::freeMemoryIfPossible(size_t bytesToFree) {
     if (fCanvas) {
         return fCanvas->freeMemoryIfPossible(bytesToFree);
     }
     return 0;
 }
 
 size_t SkGPipeWriter::storageAllocatedForRecording() const {
-    return NULL == fCanvas ? 0 : fCanvas->storageAllocatedForRecording();
+    return nullptr == fCanvas ? 0 : fCanvas->storageAllocatedForRecording();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 BitmapShuttle::BitmapShuttle(SkGPipeCanvas* canvas) {
-    SkASSERT(canvas != NULL);
+    SkASSERT(canvas != nullptr);
     fCanvas = canvas;
     fCanvas->ref();
 }
 
 BitmapShuttle::~BitmapShuttle() {
     this->removeCanvas();
 }
 
 bool BitmapShuttle::insert(const SkBitmap& bitmap, int32_t slot) {
-    SkASSERT(fCanvas != NULL);
+    SkASSERT(fCanvas != nullptr);
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
-    if (NULL == fCanvas) {
+    if (nullptr == fCanvas) {
         return;
     }
     fCanvas->unref();
-    fCanvas = NULL;
+    fCanvas = nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkImageHeap::SkImageHeap() : fBytesInCache (0) {}
 
 SkImageHeap::~SkImageHeap() {
     fArray.unrefAll();
 }
 
@@ skipping 20 matching lines @@
     int32_t slot = this->find(img);
     if (slot) {
         return slot;
     }
     // TODO: SkImage does not expose bytes per pixel, 4 is just a best guess.
     fBytesInCache += img->width() * img->height() * 4;
     *fArray.append() = SkRef(img);
     return fArray.count();  // slot is always index+1
 }