Style Change: NULL->nullptr

src/pipe/SkGPipeRead.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 "SkBitmapHeap.h"
@@ skipping 100 matching lines @@
     void setReader(SkReadBuffer* reader) {
         fReader = reader;
         this->updateReader();
     }
 
     const SkPaint& paint() const { return fPaint; }
     SkPaint* editPaint() { return &fPaint; }
 
     SkFlattenable* getFlat(unsigned index) const {
         if (0 == index) {
-            return NULL;
+            return nullptr;
         }
         return fFlatArray[index - 1];
     }
 
     void defFlattenable(PaintFlats pf, int index) {
         index--;
         SkFlattenable* obj = fReader->readFlattenable(paintflat_to_flattype(pf));
         if (fFlatArray.count() == index) {
             *fFlatArray.append() = obj;
         } else {
@@ skipping 35 matching lines @@
         SkASSERT(shouldFlattenBitmaps(fFlags));
         return fBitmaps[index];
     }
 
     /**
      * Needed to be a non-abstract subclass of SkBitmapHeapReader.
      */
     void releaseRef(int32_t) override {}
 
     void setSharedHeap(SkBitmapHeap* heap) {
-        SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
+        SkASSERT(!shouldFlattenBitmaps(fFlags) || nullptr == heap);
         SkRefCnt_SafeAssign(fSharedHeap, heap);
         this->updateReader();
     }
 
     void setImageHeap(SkImageHeap* heap) {
         fImageHeap.reset(SkRef(heap));
     }
 
     /**
      * Access the shared heap. Only used in the case when bitmaps are not
      * flattened.
      */
     SkBitmapHeap* getSharedHeap() const {
         SkASSERT(!shouldFlattenBitmaps(fFlags));
         return fSharedHeap;
     }
 
     void addTypeface() {
         size_t size = fReader->read32();
         const void* data = fReader->skip(SkAlign4(size));
         SkMemoryStream stream(data, size, false);
         *fTypefaces.append() = SkTypeface::Deserialize(&stream);
     }
 
     SkTypeface* getTypeface(unsigned id) const {
-        return id ? fTypefaces[id - 1] : NULL;
+        return id ? fTypefaces[id - 1] : nullptr;
     }
 
     const SkImage* getImage(int32_t slot) const {
         return fImageHeap->get(slot);
     }
 
 private:
     void updateReader() {
-        if (NULL == fReader) {
+        if (nullptr == fReader) {
             return;
         }
         bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag);
         fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess,
                                          SkReadBuffer::kCrossProcess_Flag));
         if (crossProcess) {
             fReader->setFactoryArray(&fFactoryArray);
         } else {
-            fReader->setFactoryArray(NULL);
+            fReader->setFactoryArray(nullptr);
         }
 
         if (shouldFlattenBitmaps(fFlags)) {
             fReader->setBitmapStorage(this);
         } else {
             fReader->setBitmapStorage(fSharedHeap);
         }
     }
     SkReadBuffer*             fReader;
     SkPaint                   fPaint;
@@ skipping 98 matching lines @@
 static void save_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                     SkGPipeState* state) {
     canvas->save();
 }
 
 static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                          SkGPipeState* state) {
     unsigned flags = DrawOp_unpackFlags(op32);
     SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags)DrawOp_unpackData(op32);
 
-    const SkRect* bounds = NULL;
+    const SkRect* bounds = nullptr;
     if (flags & kSaveLayer_HasBounds_DrawOpFlag) {
         bounds = skip<SkRect>(reader);
     }
-    const SkPaint* paint = NULL;
+    const SkPaint* paint = nullptr;
     if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
         paint = &state->paint();
     }
     canvas->saveLayer(bounds, paint, saveFlags);
 }
 
 static void restore_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                        SkGPipeState* state) {
     canvas->restore();
 }
@@ skipping 52 matching lines @@
     }
 }
 
 static void drawPatch_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                          SkGPipeState* state) {
     
     unsigned flags = DrawOp_unpackFlags(op32);
     
     const SkPoint* cubics = skip<SkPoint>(reader, SkPatchUtils::kNumCtrlPts);
     
-    const SkColor* colors = NULL;
+    const SkColor* colors = nullptr;
     if (flags & kDrawVertices_HasColors_DrawOpFlag) {
         colors = skip<SkColor>(reader, SkPatchUtils::kNumCorners);
     }
-    const SkPoint* texCoords = NULL;
+    const SkPoint* texCoords = nullptr;
     if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
         texCoords = skip<SkPoint>(reader, SkPatchUtils::kNumCorners);
     }
     SkAutoTUnref<SkXfermode> xfer;
     if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
         int mode = reader->readInt();
         if (mode < 0 || mode > SkXfermode::kLastMode) {
             mode = SkXfermode::kModulate_Mode;
         }
         xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode));
@@ skipping 13 matching lines @@
 }
 
 static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                             SkGPipeState* state) {
     unsigned flags = DrawOp_unpackFlags(op32);
 
     SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readU32();
     int vertexCount = reader->readU32();
     const SkPoint* verts = skip<SkPoint>(reader, vertexCount);
 
-    const SkPoint* texs = NULL;
+    const SkPoint* texs = nullptr;
     if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
         texs = skip<SkPoint>(reader, vertexCount);
     }
 
-    const SkColor* colors = NULL;
+    const SkColor* colors = nullptr;
     if (flags & kDrawVertices_HasColors_DrawOpFlag) {
         colors = skip<SkColor>(reader, vertexCount);
     }
 
     SkAutoTUnref<SkXfermode> xfer;
     if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
         SkXfermode::Mode mode = (SkXfermode::Mode)reader->readU32();
         xfer.reset(SkXfermode::Create(mode));
     }
 
     int indexCount = 0;
-    const uint16_t* indices = NULL;
+    const uint16_t* indices = nullptr;
     if (flags & kDrawVertices_HasIndices_DrawOpFlag) {
         indexCount = reader->readU32();
         indices = skipAlign<uint16_t>(reader, indexCount);
     }
     if (state->shouldDraw()) {
         canvas->drawVertices(vmode, vertexCount, verts, texs, colors, xfer,
                              indices, indexCount, state->paint());
     }
 }
 
 static void drawAtlas_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, SkGPipeState* state) {
     unsigned flags = DrawOp_unpackFlags(op32);
 
-    const SkPaint* paint = NULL;
+    const SkPaint* paint = nullptr;
     if (flags & kDrawAtlas_HasPaint_DrawOpFlag) {
         paint = &state->paint();
     }
     const int slot = reader->readU32();
     const SkImage* atlas = state->getImage(slot);
     const int count = reader->readU32();
     SkXfermode::Mode mode = (SkXfermode::Mode)reader->readU32();
     const SkRSXform* xform = skip<SkRSXform>(reader, count);
     const SkRect* tex = skip<SkRect>(reader, count);
-    const SkColor* colors = NULL;
+    const SkColor* colors = nullptr;
     if (flags & kDrawAtlas_HasColors_DrawOpFlag) {
         colors = skip<SkColor>(reader, count);
     }
-    const SkRect* cull = NULL;
+    const SkRect* cull = nullptr;
     if (flags & kDrawAtlas_HasCull_DrawOpFlag) {
         cull = skip<SkRect>(reader, 1);
     }
 
     if (state->shouldDraw()) {
         canvas->drawAtlas(atlas, xform, tex, colors, count, mode, cull, paint);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 33 matching lines @@
 
 static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                               SkGPipeState* state) {
     size_t len = reader->readU32();
     const void* text = reader->skip(SkAlign4(len));
 
     SkPath path;
     reader->readPath(&path);
 
     SkMatrix matrixStorage;
-    const SkMatrix* matrix = NULL;
+    const SkMatrix* matrix = nullptr;
     if (DrawOp_unpackFlags(op32) & kDrawTextOnPath_HasMatrix_DrawOpFlag) {
         reader->readMatrix(&matrixStorage);
         matrix = &matrixStorage;
     }
     if (state->shouldDraw()) {
         canvas->drawTextOnPath(text, len, path, matrix, state->paint());
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class BitmapHolder : SkNoncopyable {
 public:
     BitmapHolder(SkReader32* reader, uint32_t op32, SkGPipeState* state);
     ~BitmapHolder() {
-        if (fHeapEntry != NULL) {
+        if (fHeapEntry != nullptr) {
             fHeapEntry->releaseRef();
         }
     }
     const SkBitmap* getBitmap() {
         return fBitmap;
     }
 private:
     SkBitmapHeapEntry* fHeapEntry;
     const SkBitmap*    fBitmap;
     SkBitmap           fBitmapStorage;
 };
 
 BitmapHolder::BitmapHolder(SkReader32* reader, uint32_t op32,
                            SkGPipeState* state) {
     const unsigned flags = state->getFlags();
     const unsigned index = DrawOp_unpackData(op32);
     if (shouldFlattenBitmaps(flags)) {
-        fHeapEntry = NULL;
+        fHeapEntry = nullptr;
         fBitmap = state->getBitmap(index);
     } else {
         SkBitmapHeapEntry* entry = state->getSharedHeap()->getEntry(index);
         if (SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag)) {
             // Make a shallow copy for thread safety. Each thread will point to the same SkPixelRef,
             // which is thread safe.
             fBitmapStorage = *entry->getBitmap();
             fBitmap = &fBitmapStorage;
             // Release the ref on the bitmap now, since we made our own copy.
             entry->releaseRef();
-            fHeapEntry = NULL;
+            fHeapEntry = nullptr;
         } else {
             SkASSERT(!shouldFlattenBitmaps(flags));
             SkASSERT(!SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag));
             fHeapEntry = entry;
             fBitmap = fHeapEntry->getBitmap();
         }
     }
 }
 
 static void drawBitmap_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                           SkGPipeState* state) {
     BitmapHolder holder(reader, op32, state);
     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
     SkScalar left = reader->readScalar();
     SkScalar top = reader->readScalar();
     const SkBitmap* bitmap = holder.getBitmap();
     if (state->shouldDraw()) {
-        canvas->drawBitmap(*bitmap, left, top, hasPaint ? &state->paint() : NULL);
+        canvas->drawBitmap(*bitmap, left, top, hasPaint ? &state->paint() : nullptr);
     }
 }
 
 static void drawBitmapNine_rp(SkCanvas* canvas, SkReader32* reader,
                               uint32_t op32, SkGPipeState* state) {
     BitmapHolder holder(reader, op32, state);
     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
     const SkIRect* center = skip<SkIRect>(reader);
     const SkRect* dst = skip<SkRect>(reader);
     const SkBitmap* bitmap = holder.getBitmap();
     if (state->shouldDraw()) {
         canvas->drawBitmapNine(*bitmap, *center, *dst,
-                               hasPaint ? &state->paint() : NULL);
+                               hasPaint ? &state->paint() : nullptr);
     }
 }
 
 static void drawBitmapRect_rp(SkCanvas* canvas, SkReader32* reader,
                               uint32_t op32, SkGPipeState* state) {
     BitmapHolder holder(reader, op32, state);
     unsigned flags = DrawOp_unpackFlags(op32);
     bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
     bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag);
     const SkRect* src;
     if (hasSrc) {
         src = skip<SkRect>(reader);
     } else {
-        src = NULL;
+        src = nullptr;
     }
     SkCanvas::SrcRectConstraint constraint = SkCanvas::kStrict_SrcRectConstraint;
     if (flags & kDrawBitmap_Bleed_DrawOpFlag) {
         constraint = SkCanvas::kFast_SrcRectConstraint;
     }
     const SkRect* dst = skip<SkRect>(reader);
     const SkBitmap* bitmap = holder.getBitmap();
     if (state->shouldDraw()) {
-        canvas->legacy_drawBitmapRect(*bitmap, src, *dst, hasPaint ? &state->paint() : NULL, constraint);
+        canvas->legacy_drawBitmapRect(*bitmap, src, *dst, hasPaint ? &state->paint() : nullptr, constraint);
     }
 }
 
 static void drawSprite_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                           SkGPipeState* state) {
     BitmapHolder holder(reader, op32, state);
     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
     const SkIPoint* point = skip<SkIPoint>(reader);
     const SkBitmap* bitmap = holder.getBitmap();
     if (state->shouldDraw()) {
-        canvas->drawSprite(*bitmap, point->fX, point->fY, hasPaint ? &state->paint() : NULL);
+        canvas->drawSprite(*bitmap, point->fX, point->fY, hasPaint ? &state->paint() : nullptr);
     }
 }
 
 static void drawImage_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, SkGPipeState* state) {
     unsigned slot = DrawOp_unpackData(op32);
     unsigned flags = DrawOp_unpackFlags(op32);
     bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
     SkScalar x = reader->readScalar();
     SkScalar y = reader->readScalar();
     const SkImage* image = state->getImage(slot);
     if (state->shouldDraw()) {
-        canvas->drawImage(image, x, y, hasPaint ? &state->paint() : NULL);
+        canvas->drawImage(image, x, y, hasPaint ? &state->paint() : nullptr);
     }
 }
 
 static void drawImageRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                              SkGPipeState* state) {
     unsigned slot = DrawOp_unpackData(op32);
     unsigned flags = DrawOp_unpackFlags(op32);
     bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
     bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag);
-    const SkRect* src = NULL;
+    const SkRect* src = nullptr;
     if (hasSrc) {
         src = skip<SkRect>(reader);
     }
     const SkRect* dst = skip<SkRect>(reader);
     SkCanvas::SrcRectConstraint constraint = (SkCanvas::SrcRectConstraint)reader->readInt();
 
     const SkImage* image = state->getImage(slot);
     if (state->shouldDraw()) {
-        canvas->legacy_drawImageRect(image, src, *dst, hasPaint ? &state->paint() : NULL, constraint);
+        canvas->legacy_drawImageRect(image, src, *dst, hasPaint ? &state->paint() : nullptr, constraint);
     }
 }
 
 static void drawImageNine_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                              SkGPipeState* state) {
     unsigned slot = DrawOp_unpackData(op32);
     unsigned flags = DrawOp_unpackFlags(op32);
     bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
     const SkIRect* center = skip<SkIRect>(reader);
     const SkRect* dst = skip<SkRect>(reader);
     const SkImage* image = state->getImage(slot);
     if (state->shouldDraw()) {
-        canvas->drawImageNine(image, *center, *dst, hasPaint ? &state->paint() : NULL);
+        canvas->drawImageNine(image, *center, *dst, hasPaint ? &state->paint() : nullptr);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void drawPicture_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                            SkGPipeState* state) {
     UNIMPLEMENTED
 }
 
@@ skipping 86 matching lines @@
 static void annotation_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
                           SkGPipeState* state) {
     SkPaint* p = state->editPaint();
 
     const size_t size = DrawOp_unpackData(op32);
     if (size > 0) {
         SkReadBuffer buffer(reader->skip(size), size);
         p->setAnnotation(SkAnnotation::Create(buffer))->unref();
         SkASSERT(buffer.offset() == size);
     } else {
-        p->setAnnotation(NULL);
+        p->setAnnotation(nullptr);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void def_Typeface_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState* state) {
     state->addTypeface();
 }
 
 static void def_PaintFlat_rp(SkCanvas*, SkReader32*, uint32_t op32,
@@ skipping 92 matching lines @@
     shareBitmapHeap_rp,
     shareImageHeap_rp,
     done_rp
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGPipeState::SkGPipeState()
     : fReader(0)
     , fSilent(false)
-    , fSharedHeap(NULL)
+    , fSharedHeap(nullptr)
     , fFlags(0) {
 
 }
 
 SkGPipeState::~SkGPipeState() {
     fTypefaces.safeUnrefAll();
     fFlatArray.safeUnrefAll();
     fBitmaps.deleteAll();
     SkSafeUnref(fSharedHeap);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGPipe.h"
 
 SkGPipeReader::SkGPipeReader() {
-    fCanvas = NULL;
-    fState = NULL;
-    fProc = NULL;
+    fCanvas = nullptr;
+    fState = nullptr;
+    fProc = nullptr;
 }
 
 SkGPipeReader::SkGPipeReader(SkCanvas* target) {
-    fCanvas = NULL;
+    fCanvas = nullptr;
     this->setCanvas(target);
-    fState = NULL;
-    fProc = NULL;
+    fState = nullptr;
+    fProc = nullptr;
 }
 
 void SkGPipeReader::setCanvas(SkCanvas *target) {
     SkRefCnt_SafeAssign(fCanvas, target);
 }
 
 SkGPipeReader::~SkGPipeReader() {
     SkSafeUnref(fCanvas);
     delete fState;
 }
 
 SkGPipeReader::Status SkGPipeReader::playback(const void* data, size_t length,
                                               uint32_t playbackFlags, size_t* bytesRead) {
-    if (NULL == fCanvas) {
+    if (nullptr == fCanvas) {
         return kError_Status;
     }
 
-    if (NULL == fState) {
+    if (nullptr == fState) {
         fState = new SkGPipeState;
     }
 
     fState->setSilent(playbackFlags & kSilent_PlaybackFlag);
 
     SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1));
 
     const ReadProc* table = gReadTable;
     SkReadBuffer reader(data, length);
     reader.setBitmapDecoder(fProc);
@@ skipping 25 matching lines @@
                 status = kReadAtom_Status;
                 break;
             }
     }
 
     if (bytesRead) {
         *bytesRead = reader.offset();
     }
     return status;
 }