Style Change: NULL->nullptr

src/core/SkScalerContext.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkScalerContext.h"
@@ skipping 45 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
     #define DUMP_RECx
 #endif
 
 static SkFlattenable* load_flattenable(const SkDescriptor* desc, uint32_t tag,
                                        SkFlattenable::Type ft) {
-    SkFlattenable*  obj = NULL;
+    SkFlattenable*  obj = nullptr;
     uint32_t        len;
     const void*     data = desc->findEntry(tag, &len);
 
     if (data) {
         SkReadBuffer buffer(data, len);
         obj = buffer.readFlattenable(ft);
         SkASSERT(buffer.offset() == buffer.size());
     }
     return obj;
 }
 
 SkScalerContext::SkScalerContext(SkTypeface* typeface, const SkDescriptor* desc)
-    : fRec(*static_cast<const Rec*>(desc->findEntry(kRec_SkDescriptorTag, NULL)))
+    : fRec(*static_cast<const Rec*>(desc->findEntry(kRec_SkDescriptorTag, nullptr)))
 
     , fTypeface(SkRef(typeface))
     , fPathEffect(static_cast<SkPathEffect*>(load_flattenable(desc, kPathEffect_SkDescriptorTag,
                                              SkFlattenable::kSkPathEffect_Type)))
     , fMaskFilter(static_cast<SkMaskFilter*>(load_flattenable(desc, kMaskFilter_SkDescriptorTag,
                                              SkFlattenable::kSkMaskFilter_Type)))
     , fRasterizer(static_cast<SkRasterizer*>(load_flattenable(desc, kRasterizer_SkDescriptorTag,
                                              SkFlattenable::kSkRasterizer_Type)))
       // Initialize based on our settings. Subclasses can also force this.
-    , fGenerateImageFromPath(fRec.fFrameWidth > 0 || fPathEffect != NULL || fRasterizer != NULL)
+    , fGenerateImageFromPath(fRec.fFrameWidth > 0 || fPathEffect != nullptr || fRasterizer != nullptr)
 
     , fPreBlend(fMaskFilter ? SkMaskGamma::PreBlend() : SkScalerContext::GetMaskPreBlend(fRec))
     , fPreBlendForFilter(fMaskFilter ? SkScalerContext::GetMaskPreBlend(fRec)
                                      : SkMaskGamma::PreBlend())
 {
 #ifdef DUMP_REC
     desc->assertChecksum();
     SkDebugf("SkScalerContext checksum %x count %d length %d\n",
              desc->getChecksum(), desc->getCount(), desc->getLength());
     SkDebugf(" textsize %g prescale %g preskew %g post [%g %g %g %g]\n",
         rec->fTextSize, rec->fPreScaleX, rec->fPreSkewX, rec->fPost2x2[0][0],
         rec->fPost2x2[0][1], rec->fPost2x2[1][0], rec->fPost2x2[1][1]);
     SkDebugf("  frame %g miter %g hints %d framefill %d format %d join %d\n",
         rec->fFrameWidth, rec->fMiterLimit, rec->fHints, rec->fFrameAndFill,
         rec->fMaskFormat, rec->fStrokeJoin);
     SkDebugf("  pathEffect %x maskFilter %x\n",
-             desc->findEntry(kPathEffect_SkDescriptorTag, NULL),
-        desc->findEntry(kMaskFilter_SkDescriptorTag, NULL));
+             desc->findEntry(kPathEffect_SkDescriptorTag, nullptr),
+        desc->findEntry(kMaskFilter_SkDescriptorTag, nullptr));
 #endif
 }
 
 SkScalerContext::~SkScalerContext() {
     SkSafeUnref(fPathEffect);
     SkSafeUnref(fMaskFilter);
     SkSafeUnref(fRasterizer);
 }
 
 void SkScalerContext::getAdvance(SkGlyph* glyph) {
@@ skipping 29 matching lines @@
 
     if (fGenerateImageFromPath) {
         SkPath      devPath, fillPath;
         SkMatrix    fillToDevMatrix;
 
         this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix);
 
         if (fRasterizer) {
             SkMask  mask;
 
-            if (fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
+            if (fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr,
                                        fMaskFilter, &mask,
                                        SkMask::kJustComputeBounds_CreateMode)) {
                 glyph->fLeft    = mask.fBounds.fLeft;
                 glyph->fTop     = mask.fBounds.fTop;
                 glyph->fWidth   = SkToU16(mask.fBounds.width());
                 glyph->fHeight  = SkToU16(mask.fBounds.height());
             } else {
                 goto SK_ERROR;
             }
         } else {
@@ skipping 31 matching lines @@
         glyph->fMaskFormat = SkMask::kA8_Format;
     }
 
     if (fMaskFilter) {
         SkMask      src, dst;
         SkMatrix    matrix;
 
         glyph->toMask(&src);
         fRec.getMatrixFrom2x2(&matrix);
 
-        src.fImage = NULL;  // only want the bounds from the filter
-        if (fMaskFilter->filterMask(&dst, src, matrix, NULL)) {
+        src.fImage = nullptr;  // only want the bounds from the filter
+        if (fMaskFilter->filterMask(&dst, src, matrix, nullptr)) {
             if (dst.fBounds.isEmpty() || !dst.fBounds.is16Bit()) {
                 goto SK_ERROR;
             }
-            SkASSERT(dst.fImage == NULL);
+            SkASSERT(dst.fImage == nullptr);
             glyph->fLeft    = dst.fBounds.fLeft;
             glyph->fTop     = dst.fBounds.fTop;
             glyph->fWidth   = SkToU16(dst.fBounds.width());
             glyph->fHeight  = SkToU16(dst.fBounds.height());
             glyph->fMaskFormat = dst.fFormat;
         }
     }
     return;
 
 SK_ERROR:
@@ skipping 253 matching lines @@
     // the path only makes a mask. This case should have been caught up in
     // generateMetrics().
     SkASSERT(!fGenerateImageFromPath ||
              SkMask::kARGB32_Format != origGlyph.fMaskFormat);
 
     if (fMaskFilter) {   // restore the prefilter bounds
         tmpGlyph.initGlyphIdFrom(origGlyph);
 
         // need the original bounds, sans our maskfilter
         SkMaskFilter* mf = fMaskFilter;
-        fMaskFilter = NULL;             // temp disable
+        fMaskFilter = nullptr;             // temp disable
         this->getMetrics(&tmpGlyph);
         fMaskFilter = mf;               // restore
 
         // we need the prefilter bounds to be <= filter bounds
         SkASSERT(tmpGlyph.fWidth <= origGlyph.fWidth);
         SkASSERT(tmpGlyph.fHeight <= origGlyph.fHeight);
 
         if (tmpGlyph.fMaskFormat == origGlyph.fMaskFormat) {
             tmpGlyph.fImage = origGlyph.fImage;
         } else {
             tmpGlyphImageStorage.reset(tmpGlyph.computeImageSize());
             tmpGlyph.fImage = tmpGlyphImageStorage.get();
         }
         glyph = &tmpGlyph;
     }
 
     if (fGenerateImageFromPath) {
         SkPath      devPath, fillPath;
         SkMatrix    fillToDevMatrix;
         SkMask      mask;
 
         this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix);
         glyph->toMask(&mask);
 
         if (fRasterizer) {
             mask.fFormat = SkMask::kA8_Format;
             sk_bzero(glyph->fImage, mask.computeImageSize());
 
-            if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
+            if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr,
                                         fMaskFilter, &mask,
                                         SkMask::kJustRenderImage_CreateMode)) {
                 return;
             }
             if (fPreBlend.isApplicable()) {
                 applyLUTToA8Mask(mask, fPreBlend.fG);
             }
         } else {
             SkASSERT(SkMask::kARGB32_Format != mask.fFormat);
             generateMask(mask, devPath, fPreBlend);
@@ skipping 18 matching lines @@
             srcM.fRowBytes = SkAlign4(srcM.fBounds.width());
             size_t size = srcM.computeImageSize();
             a8storage.reset(size);
             srcM.fImage = (uint8_t*)a8storage.get();
             extract_alpha(srcM,
                           (const SkPMColor*)glyph->fImage, glyph->rowBytes());
         }
 
         fRec.getMatrixFrom2x2(&matrix);
 
-        if (fMaskFilter->filterMask(&dstM, srcM, matrix, NULL)) {
+        if (fMaskFilter->filterMask(&dstM, srcM, matrix, nullptr)) {
             int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width());
             int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height());
             int dstRB = origGlyph.rowBytes();
             int srcRB = dstM.fRowBytes;
 
             const uint8_t* src = (const uint8_t*)dstM.fImage;
             uint8_t* dst = (uint8_t*)origGlyph.fImage;
 
             if (SkMask::k3D_Format == dstM.fFormat) {
                 // we have to copy 3 times as much
@@ skipping 11 matching lines @@
             SkMask::FreeImage(dstM.fImage);
 
             if (fPreBlendForFilter.isApplicable()) {
                 applyLUTToA8Mask(srcM, fPreBlendForFilter.fG);
             }
         }
     }
 }
 
 void SkScalerContext::getPath(const SkGlyph& glyph, SkPath* path) {
-    this->internalGetPath(glyph, NULL, path, NULL);
+    this->internalGetPath(glyph, nullptr, path, nullptr);
 }
 
 void SkScalerContext::getFontMetrics(SkPaint::FontMetrics* fm) {
     this->generateFontMetrics(fm);
 }
 
 SkUnichar SkScalerContext::generateGlyphToChar(uint16_t glyph) {
     return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkScalerContext::internalGetPath(const SkGlyph& glyph, SkPath* fillPath,
                                   SkPath* devPath, SkMatrix* fillToDevMatrix) {
     SkPath  path;
     generatePath(glyph, &path);
 
     if (fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag) {
         SkFixed dx = glyph.getSubXFixed();
         SkFixed dy = glyph.getSubYFixed();
         if (dx | dy) {
             path.offset(SkFixedToScalar(dx), SkFixedToScalar(dy));
         }
     }
 
-    if (fRec.fFrameWidth > 0 || fPathEffect != NULL) {
+    if (fRec.fFrameWidth > 0 || fPathEffect != nullptr) {
         // need the path in user-space, with only the point-size applied
         // so that our stroking and effects will operate the same way they
         // would if the user had extracted the path themself, and then
         // called drawPath
         SkPath      localPath;
         SkMatrix    matrix, inverse;
 
         fRec.getMatrixFrom2x2(&matrix);
         if (!matrix.invert(&inverse)) {
             // assume fillPath and devPath are already empty.
             return;
         }
         path.transform(inverse, &localPath);
         // now localPath is only affected by the paint settings, and not the canvas matrix
 
         SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
 
         if (fRec.fFrameWidth > 0) {
             rec.setStrokeStyle(fRec.fFrameWidth,
                                SkToBool(fRec.fFlags & kFrameAndFill_Flag));
             // glyphs are always closed contours, so cap type is ignored,
             // so we just pass something.
             rec.setStrokeParams(SkPaint::kButt_Cap,
                                 (SkPaint::Join)fRec.fStrokeJoin,
                                 fRec.fMiterLimit);
         }
 
         if (fPathEffect) {
             SkPath effectPath;
-            if (fPathEffect->filterPath(&effectPath, localPath, &rec, NULL)) {
+            if (fPathEffect->filterPath(&effectPath, localPath, &rec, nullptr)) {
                 localPath.swap(effectPath);
             }
         }
 
         if (rec.needToApply()) {
             SkPath strokePath;
             if (rec.applyToPath(&strokePath, localPath)) {
                 localPath.swap(strokePath);
             }
         }
 
         // now return stuff to the caller
         if (fillToDevMatrix) {
             *fillToDevMatrix = matrix;
         }
         if (devPath) {
             localPath.transform(matrix, devPath);
         }
         if (fillPath) {
             fillPath->swap(localPath);
         }
     } else {   // nothing tricky to do
         if (fillToDevMatrix) {
             fillToDevMatrix->reset();
         }
         if (devPath) {
-            if (fillPath == NULL) {
+            if (fillPath == nullptr) {
                 devPath->swap(path);
             } else {
                 *devPath = path;
             }
         }
 
         if (fillPath) {
             fillPath->swap(path);
         }
     }
@@ skipping 185 matching lines @@
 
 SkScalerContext* SkTypeface::createScalerContext(const SkDescriptor* desc,
                                                  bool allowFailure) const {
     SkScalerContext* c = this->onCreateScalerContext(desc);
 
     if (!c && !allowFailure) {
         c = new SkScalerContext_Empty(const_cast<SkTypeface*>(this), desc);
     }
     return c;
 }