Style Change: NULL->nullptr

src/pdf/SkPDFFont.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 <ctype.h>
 
 #include "SkData.h"
@@ skipping 59 matching lines @@
 }
 
 bool parsePFB(const uint8_t* src, size_t size, size_t* headerLen,
               size_t* dataLen, size_t* trailerLen) {
     const uint8_t* srcPtr = src;
     size_t remaining = size;
 
     return parsePFBSection(&srcPtr, &remaining, 1, headerLen) &&
            parsePFBSection(&srcPtr, &remaining, 2, dataLen) &&
            parsePFBSection(&srcPtr, &remaining, 1, trailerLen) &&
-           parsePFBSection(&srcPtr, &remaining, 3, NULL);
+           parsePFBSection(&srcPtr, &remaining, 3, nullptr);
 }
 
 /* The sections of a PFA file are implicitly defined.  The body starts
  * after the line containing "eexec," and the trailer starts with 512
  * literal 0's followed by "cleartomark" (plus arbitrary white space).
  *
  * This function assumes that src is NUL terminated, but the NUL
  * termination is not included in size.
  *
  */
@@ skipping 64 matching lines @@
 
 static SkData* handle_type1_stream(SkStream* srcStream, size_t* headerLen,
                                    size_t* dataLen, size_t* trailerLen) {
     // srcStream may be backed by a file or a unseekable fd, so we may not be
     // able to use skip(), rewind(), or getMemoryBase().  read()ing through
     // the input only once is doable, but very ugly. Furthermore, it'd be nice
     // if the data was NUL terminated so that we can use strstr() to search it.
     // Make as few copies as possible given these constraints.
     SkDynamicMemoryWStream dynamicStream;
     SkAutoTDelete<SkMemoryStream> staticStream;
-    SkData* data = NULL;
+    SkData* data = nullptr;
     const uint8_t* src;
     size_t srcLen;
     if ((srcLen = srcStream->getLength()) > 0) {
         staticStream.reset(new SkMemoryStream(srcLen + 1));
         src = (const uint8_t*)staticStream->getMemoryBase();
-        if (srcStream->getMemoryBase() != NULL) {
+        if (srcStream->getMemoryBase() != nullptr) {
             memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
         } else {
             size_t read = 0;
             while (read < srcLen) {
                 size_t got = srcStream->read((void *)staticStream->getAtPos(),
                                              srcLen - read);
                 if (got == 0) {
-                    return NULL;
+                    return nullptr;
                 }
                 read += got;
                 staticStream->seek(read);
             }
         }
         ((uint8_t *)src)[srcLen] = 0;
     } else {
         static const size_t kBufSize = 4096;
         uint8_t buf[kBufSize];
         size_t amount;
         while ((amount = srcStream->read(buf, kBufSize)) > 0) {
             dynamicStream.write(buf, amount);
         }
         amount = 0;
-        dynamicStream.write(&amount, 1);  // NULL terminator.
+        dynamicStream.write(&amount, 1);  // nullptr terminator.
         data = dynamicStream.copyToData();
         src = data->bytes();
         srcLen = data->size() - 1;
     }
 
     // this handles releasing the data we may have gotten from dynamicStream.
     // if data is null, it is a no-op
     SkAutoDataUnref aud(data);
 
     if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
@@ skipping 56 matching lines @@
         if (!highNibble) {
             resultData[outputOffset++] = dataByte;
         }
         SkASSERT(outputOffset == *dataLen);
 
         uint8_t* const resultTrailer = &(buffer[SkToInt(*headerLen + outputOffset)]);
         memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
 
         return SkData::NewFromMalloc(buffer.detach(), length);
     }
-    return NULL;
+    return nullptr;
 }
 
 // scale from em-units to base-1000, returning as a SkScalar
 SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
     SkScalar scaled = SkIntToScalar(val);
     if (emSize == 1000) {
         return scaled;
     } else {
         return SkScalarMulDiv(scaled, 1000, emSize);
     }
@@ skipping 40 matching lines @@
 }
 
 template <typename Data>
 SkPDFArray* composeAdvanceData(
         SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* advanceInfo,
         uint16_t emSize,
         SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize,
                                      SkPDFArray* array),
         Data* defaultAdvance) {
     SkPDFArray* result = new SkPDFArray();
-    for (; advanceInfo != NULL; advanceInfo = advanceInfo->fNext.get()) {
+    for (; advanceInfo != nullptr; advanceInfo = advanceInfo->fNext.get()) {
         switch (advanceInfo->fType) {
             case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
                 SkASSERT(advanceInfo->fAdvance.count() == 1);
                 *defaultAdvance = advanceInfo->fAdvance[0];
                 break;
             }
             case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
                 SkAutoTUnref<SkPDFArray> advanceArray(new SkPDFArray());
                 for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
                     appendAdvance(advanceInfo->fAdvance[j], emSize,
@@ skipping 170 matching lines @@
     SkTDArray<BFChar> bfcharEntries;
     SkTDArray<BFRange> bfrangeEntries;
 
     BFRange currentRangeEntry = {0, 0, 0};
     bool rangeEmpty = true;
     const int limit =
             SkMin32(lastGlyphID + 1, glyphToUnicode.count()) - glyphOffset;
 
     for (int i = firstGlyphID - glyphOffset; i < limit + 1; ++i) {
         bool inSubset = i < limit &&
-                        (subset == NULL || subset->has(i + glyphOffset));
+                        (subset == nullptr || subset->has(i + glyphOffset));
         if (!rangeEmpty) {
             // PDF spec requires bfrange not changing the higher byte,
             // e.g. <1035> <10FF> <2222> is ok, but
             //      <1035> <1100> <2222> is no good
             bool inRange =
                 i == currentRangeEntry.fEnd + 1 &&
                 i >> 8 == currentRangeEntry.fStart >> 8 &&
                 i < limit &&
                 glyphToUnicode[i + glyphOffset] ==
                     currentRangeEntry.fUnicode + i - currentRangeEntry.fStart;
@@ skipping 55 matching lines @@
                                      const SkTypeface* typeface,
                                      const SkTDArray<uint32_t>& subset,
                                      SkPDFStream** fontStream) {
     int ttcIndex;
     SkAutoTDelete<SkStream> fontData(typeface->openStream(&ttcIndex));
     SkASSERT(fontData.get());
 
     size_t fontSize = fontData->getLength();
 
     // Read font into buffer.
-    SkPDFStream* subsetFontStream = NULL;
+    SkPDFStream* subsetFontStream = nullptr;
     SkTDArray<unsigned char> originalFont;
     originalFont.setCount(SkToInt(fontSize));
     if (fontData->read(originalFont.begin(), fontSize) == fontSize) {
-        unsigned char* subsetFont = NULL;
+        unsigned char* subsetFont = nullptr;
         // sfntly requires unsigned int* to be passed in, as far as we know,
         // unsigned int is equivalent to uint32_t on all platforms.
         static_assert(sizeof(unsigned int) == sizeof(uint32_t), "unsigned_int_not_32_bits");
         int subsetFontSize = SfntlyWrapper::SubsetFont(fontName,
                                                        originalFont.begin(),
                                                        fontSize,
                                                        subset.begin(),
                                                        subset.count(),
                                                        &subsetFont);
-        if (subsetFontSize > 0 && subsetFont != NULL) {
+        if (subsetFontSize > 0 && subsetFont != nullptr) {
             SkAutoDataUnref data(SkData::NewWithProc(subsetFont,
                                                      subsetFontSize,
                                                      sk_delete_array,
-                                                     NULL));
+                                                     nullptr));
             subsetFontStream = new SkPDFStream(data.get());
             fontSize = subsetFontSize;
         }
     }
     if (subsetFontStream) {
         *fontStream = subsetFontStream;
         return fontSize;
     }
     fontData->rewind();
 
@@ skipping 36 matching lines @@
         : fFont(font),
           fGlyphSet(glyphSet) {
 }
 
 SkPDFGlyphSetMap::F2BIter::F2BIter(const SkPDFGlyphSetMap& map) {
     reset(map);
 }
 
 const SkPDFGlyphSetMap::FontGlyphSetPair* SkPDFGlyphSetMap::F2BIter::next() const {
     if (fIndex >= fMap->count()) {
-        return NULL;
+        return nullptr;
     }
     return &((*fMap)[fIndex++]);
 }
 
 void SkPDFGlyphSetMap::F2BIter::reset(const SkPDFGlyphSetMap& map) {
     fMap = &(map.fMap);
     fIndex = 0;
 }
 
 SkPDFGlyphSetMap::SkPDFGlyphSetMap() {
 }
 
 SkPDFGlyphSetMap::~SkPDFGlyphSetMap() {
     reset();
 }
 
 void SkPDFGlyphSetMap::merge(const SkPDFGlyphSetMap& usage) {
     for (int i = 0; i < usage.fMap.count(); ++i) {
         SkPDFGlyphSet* myUsage = getGlyphSetForFont(usage.fMap[i].fFont);
         myUsage->merge(*(usage.fMap[i].fGlyphSet));
     }
 }
 
 void SkPDFGlyphSetMap::reset() {
     for (int i = 0; i < fMap.count(); ++i) {
-        delete fMap[i].fGlyphSet;  // Should not be NULL.
+        delete fMap[i].fGlyphSet;  // Should not be nullptr.
     }
     fMap.reset();
 }
 
 void SkPDFGlyphSetMap::noteGlyphUsage(SkPDFFont* font, const uint16_t* glyphIDs,
                                       int numGlyphs) {
     SkPDFGlyphSet* subset = getGlyphSetForFont(font);
     if (subset) {
         subset->set(glyphIDs, numGlyphs);
     }
@@ skipping 88 matching lines @@
     SkAutoResolveDefaultTypeface autoResolve(typeface);
     typeface = autoResolve.get();
     const uint32_t fontID = typeface->uniqueID();
 
     SkPDFFont* relatedFont;
     if (SkPDFFont* pdfFont = canon->findFont(fontID, glyphID, &relatedFont)) {
         return SkRef(pdfFont);
     }
 
     SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics;
-    SkPDFDict* relatedFontDescriptor = NULL;
+    SkPDFDict* relatedFontDescriptor = nullptr;
     if (relatedFont) {
         fontMetrics.reset(SkSafeRef(relatedFont->fontInfo()));
         relatedFontDescriptor = relatedFont->getFontDescriptor();
 
         // This only is to catch callers who pass invalid glyph ids.
         // If glyph id is invalid, then we will create duplicate entries
         // for TrueType fonts.
         SkAdvancedTypefaceMetrics::FontType fontType =
             fontMetrics.get() ? fontMetrics.get()->fType :
                                 SkAdvancedTypefaceMetrics::kOther_Font;
 
         if (fontType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
             fontType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
             return SkRef(relatedFont);
         }
     } else {
         SkTypeface::PerGlyphInfo info;
         info = SkTypeface::kGlyphNames_PerGlyphInfo;
         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
                   info, SkTypeface::kToUnicode_PerGlyphInfo);
 #if !defined (SK_SFNTLY_SUBSETTER)
         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
                   info, SkTypeface::kHAdvance_PerGlyphInfo);
 #endif
         fontMetrics.reset(
-            typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
+            typeface->getAdvancedTypefaceMetrics(info, nullptr, 0));
 #if defined (SK_SFNTLY_SUBSETTER)
         if (fontMetrics.get() &&
             fontMetrics->fType != SkAdvancedTypefaceMetrics::kTrueType_Font) {
             // Font does not support subsetting, get new info with advance.
             info = SkTBitOr<SkTypeface::PerGlyphInfo>(
                       info, SkTypeface::kHAdvance_PerGlyphInfo);
             fontMetrics.reset(
-                typeface->getAdvancedTypefaceMetrics(info, NULL, 0));
+                typeface->getAdvancedTypefaceMetrics(info, nullptr, 0));
         }
 #endif
     }
 
     SkPDFFont* font = SkPDFFont::Create(canon, fontMetrics.get(), typeface,
                                         glyphID, relatedFontDescriptor);
     canon->addFont(font, fontID, font->fFirstGlyphID);
     return font;
 }
 
 SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
-    return NULL;  // Default: no support.
+    return nullptr;  // Default: no support.
 }
 
 SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
                      SkTypeface* typeface,
                      SkPDFDict* relatedFontDescriptor)
     : SkPDFDict("Font")
     , fTypeface(ref_or_default(typeface))
     , fFirstGlyphID(1)
     , fLastGlyphID(info ? info->fLastGlyphID : 0)
     , fFontInfo(SkSafeRef(info))
     , fDescriptor(SkSafeRef(relatedFontDescriptor)) {
-    if (info == NULL ||
+    if (info == nullptr ||
             info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) {
         fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
     } else {
         fFontType = info->fType;
     }
 }
 
 // static
 SkPDFFont* SkPDFFont::Create(SkPDFCanon* canon,
                              const SkAdvancedTypefaceMetrics* info,
                              SkTypeface* typeface,
                              uint16_t glyphID,
                              SkPDFDict* relatedFontDescriptor) {
     SkAdvancedTypefaceMetrics::FontType type =
         info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font;
 
     if (info && (info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
         return new SkPDFType3Font(info, typeface, glyphID);
     }
     if (type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
         type == SkAdvancedTypefaceMetrics::kTrueType_Font) {
-        SkASSERT(relatedFontDescriptor == NULL);
+        SkASSERT(relatedFontDescriptor == nullptr);
         return new SkPDFType0Font(info, typeface);
     }
     if (type == SkAdvancedTypefaceMetrics::kType1_Font) {
         return new SkPDFType1Font(info, typeface, glyphID, relatedFontDescriptor);
     }
 
     SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
              type == SkAdvancedTypefaceMetrics::kOther_Font);
 
     return new SkPDFType3Font(info, typeface, glyphID);
 }
 
 const SkAdvancedTypefaceMetrics* SkPDFFont::fontInfo() {
     return fFontInfo.get();
 }
 
 void SkPDFFont::setFontInfo(const SkAdvancedTypefaceMetrics* info) {
-    if (info == NULL || info == fFontInfo.get()) {
+    if (info == nullptr || info == fFontInfo.get()) {
         return;
     }
     fFontInfo.reset(info);
     SkSafeRef(info);
 }
 
 uint16_t SkPDFFont::firstGlyphID() const {
     return fFirstGlyphID;
 }
 
 uint16_t SkPDFFont::lastGlyphID() const {
     return fLastGlyphID;
 }
 
 void SkPDFFont::setLastGlyphID(uint16_t glyphID) {
     fLastGlyphID = glyphID;
 }
 
 SkPDFDict* SkPDFFont::getFontDescriptor() {
     return fDescriptor.get();
 }
 
 void SkPDFFont::setFontDescriptor(SkPDFDict* descriptor) {
     fDescriptor.reset(descriptor);
     SkSafeRef(descriptor);
 }
 
 bool SkPDFFont::addCommonFontDescriptorEntries(int16_t defaultWidth) {
-    if (fDescriptor.get() == NULL) {
+    if (fDescriptor.get() == nullptr) {
         return false;
     }
 
     const uint16_t emSize = fFontInfo->fEmSize;
 
     fDescriptor->insertName("FontName", fFontInfo->fFontName);
     fDescriptor->insertInt("Flags", fFontInfo->fStyle | kPdfSymbolic);
     fDescriptor->insertScalar("Ascent",
             scaleFromFontUnits(fFontInfo->fAscent, emSize));
     fDescriptor->insertScalar("Descent",
@@ skipping 16 matching lines @@
 
 void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(uint16_t glyphID) {
     // Single byte glyph encoding supports a max of 255 glyphs.
     fFirstGlyphID = glyphID - (glyphID - 1) % 255;
     if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
         fLastGlyphID = fFirstGlyphID + 255 - 1;
     }
 }
 
 void SkPDFFont::populateToUnicodeTable(const SkPDFGlyphSet* subset) {
-    if (fFontInfo == NULL || fFontInfo->fGlyphToUnicode.begin() == NULL) {
+    if (fFontInfo == nullptr || fFontInfo->fGlyphToUnicode.begin() == nullptr) {
         return;
     }
     this->insertObjRef("ToUnicode",
                        generate_tounicode_cmap(fFontInfo->fGlyphToUnicode,
                                                subset,
                                                multiByteGlyphs(),
                                                firstGlyphID(),
                                                lastGlyphID()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info, SkTypeface* typeface)
-    : SkPDFFont(info, typeface, NULL) {
+    : SkPDFFont(info, typeface, nullptr) {
     SkDEBUGCODE(fPopulated = false);
     if (!canSubset()) {
-        this->populate(NULL);
+        this->populate(nullptr);
     }
 }
 
 SkPDFType0Font::~SkPDFType0Font() {}
 
 SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
     if (!canSubset()) {
-        return NULL;
+        return nullptr;
     }
     SkPDFType0Font* newSubset = new SkPDFType0Font(fontInfo(), typeface());
     newSubset->populate(subset);
     return newSubset;
 }
 
 #ifdef SK_DEBUG
 void SkPDFType0Font::emitObject(SkWStream* stream,
                                 const SkPDFObjNumMap& objNumMap,
                                 const SkPDFSubstituteMap& substitutes) const {
@@ skipping 19 matching lines @@
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFCIDFont
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                            SkTypeface* typeface,
                            const SkPDFGlyphSet* subset)
-    : SkPDFFont(info, typeface, NULL) {
+    : SkPDFFont(info, typeface, nullptr) {
     this->populate(subset);
 }
 
 SkPDFCIDFont::~SkPDFCIDFont() {}
 
 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
                                      const SkTDArray<uint32_t>* subset) {
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
     if (!addCommonFontDescriptorEntries(defaultWidth)) {
         this->insertObjRef("FontDescriptor", descriptor.detach());
         return false;
     }
     if (!canEmbed()) {
         this->insertObjRef("FontDescriptor", descriptor.detach());
         return true;
     }
 
     switch (getType()) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
             size_t fontSize = 0;
 #if defined(SK_SFNTLY_SUBSETTER)
             if (this->canSubset()) {
                 SkAutoTUnref<SkPDFStream> fontStream;
-                SkPDFStream* rawStream = NULL;
+                SkPDFStream* rawStream = nullptr;
                 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
                                                   typeface(),
                                                   *subset,
                                                   &rawStream);
                 if (rawStream) {
                     fontStream.reset(rawStream);
                     fontStream->insertInt("Length1", fontSize);
                     descriptor->insertObjRef("FontFile2", fontStream.detach());
                     break;
                 }
             }
 #endif
             SkAutoTUnref<SkPDFSharedStream> fontStream;
             SkAutoTDelete<SkStreamAsset> fontData(
-                    this->typeface()->openStream(NULL));
+                    this->typeface()->openStream(nullptr));
             SkASSERT(fontData);
             fontSize = fontData->getLength();
             SkASSERT(fontSize > 0);
             fontStream.reset(new SkPDFSharedStream(fontData.detach()));
             fontStream->dict()->insertInt("Length1", fontSize);
             descriptor->insertObjRef("FontFile2", fontStream.detach());
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
             SkAutoTUnref<SkPDFSharedStream> fontStream(
-                    new SkPDFSharedStream(this->typeface()->openStream(NULL)));
+                    new SkPDFSharedStream(this->typeface()->openStream(nullptr)));
 
             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
                 fontStream->dict()->insertName("Subtype", "Type1C");
             } else {
                 fontStream->dict()->insertName("Subtype", "CIDFontType0c");
             }
             descriptor->insertObjRef("FontFile3", fontStream.detach());
             break;
         }
         default:
@@ skipping 13 matching lines @@
             if (!subset->has(0)) {
                 glyphIDs.push(0);
             }
             subset->exportTo(&glyphIDs);
         }
 
         SkTypeface::PerGlyphInfo info;
         info = SkTypeface::kGlyphNames_PerGlyphInfo;
         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
                   info, SkTypeface::kHAdvance_PerGlyphInfo);
-        uint32_t* glyphs = (glyphIDs.count() == 0) ? NULL : glyphIDs.begin();
+        uint32_t* glyphs = (glyphIDs.count() == 0) ? nullptr : glyphIDs.begin();
         uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
         SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics(
             typeface()->getAdvancedTypefaceMetrics(info, glyphs, glyphsCount));
         setFontInfo(fontMetrics.get());
         addFontDescriptor(0, &glyphIDs);
     } else {
         // Other CID fonts
-        addFontDescriptor(0, NULL);
+        addFontDescriptor(0, nullptr);
     }
 
     insertName("BaseFont", fontInfo()->fFontName);
 
     if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
         insertName("Subtype", "CIDFontType0");
     } else if (getType() == SkAdvancedTypefaceMetrics::kTrueType_Font) {
         insertName("Subtype", "CIDFontType2");
         insertName("CIDToGIDMap", "Identity");
     } else {
@@ skipping 67 matching lines @@
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
 
     int ttcIndex;
     size_t header SK_INIT_TO_AVOID_WARNING;
     size_t data SK_INIT_TO_AVOID_WARNING;
     size_t trailer SK_INIT_TO_AVOID_WARNING;
     SkAutoTDelete<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
     SkAutoTUnref<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
                                                       &data, &trailer));
-    if (fontData.get() == NULL) {
+    if (fontData.get() == nullptr) {
         return false;
     }
     if (canEmbed()) {
         SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
         fontStream->insertInt("Length1", header);
         fontStream->insertInt("Length2", data);
         fontStream->insertInt("Length3", trailer);
         descriptor->insertObjRef("FontFile", fontStream.detach());
     }
 
     this->insertObjRef("FontDescriptor", descriptor.detach());
 
     return addCommonFontDescriptorEntries(defaultWidth);
 }
 
 bool SkPDFType1Font::populate(int16_t glyphID) {
     SkASSERT(!fontInfo()->fVerticalMetrics.get());
     SkASSERT(fontInfo()->fGlyphWidths.get());
 
     adjustGlyphRangeForSingleByteEncoding(glyphID);
 
     int16_t defaultWidth = 0;
-    const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = NULL;
+    const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = nullptr;
     const SkAdvancedTypefaceMetrics::WidthRange* widthEntry;
     for (widthEntry = fontInfo()->fGlyphWidths.get();
-            widthEntry != NULL;
+            widthEntry != nullptr;
             widthEntry = widthEntry->fNext.get()) {
         switch (widthEntry->fType) {
             case SkAdvancedTypefaceMetrics::WidthRange::kDefault:
                 defaultWidth = widthEntry->fAdvance[0];
                 break;
             case SkAdvancedTypefaceMetrics::WidthRange::kRun:
                 SkASSERT(false);
                 break;
             case SkAdvancedTypefaceMetrics::WidthRange::kRange:
-                SkASSERT(widthRangeEntry == NULL);
+                SkASSERT(widthRangeEntry == nullptr);
                 widthRangeEntry = widthEntry;
                 break;
         }
     }
 
     if (!addFontDescriptor(defaultWidth)) {
         return false;
     }
 
     insertName("Subtype", "Type1");
@@ skipping 44 matching lines @@
     this->insertObject("Widths", widthArray.detach());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType3Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID)
-    : SkPDFFont(info, typeface, NULL) {
+    : SkPDFFont(info, typeface, nullptr) {
     this->populate(glyphID);
 }
 
 SkPDFType3Font::~SkPDFType3Font() {}
 
 bool SkPDFType3Font::populate(uint16_t glyphID) {
     SkPaint paint;
     paint.setTypeface(typeface());
     paint.setTextSize(1000);
     const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-    SkAutoGlyphCache autoCache(paint, &props, NULL);
+    SkAutoGlyphCache autoCache(paint, &props, nullptr);
     SkGlyphCache* cache = autoCache.getCache();
     // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
     if (lastGlyphID() == 0) {
         setLastGlyphID(cache->getGlyphCount() - 1);
     }
 
     adjustGlyphRangeForSingleByteEncoding(glyphID);
 
     insertName("Subtype", "Type3");
     // Flip about the x-axis and scale by 1/1000.
@@ skipping 42 matching lines @@
 
     this->insertObject("CharProcs", charProcs.detach());
     this->insertObject("Encoding", encoding.detach());
 
     this->insertObject("FontBBox", makeFontBBox(bbox, 1000));
     this->insertInt("FirstChar", 1);
     this->insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
     this->insertObject("Widths", widthArray.detach());
     this->insertName("CIDToGIDMap", "Identity");
 
-    this->populateToUnicodeTable(NULL);
+    this->populateToUnicodeTable(nullptr);
     return true;
 }
 
 SkPDFFont::Match SkPDFFont::IsMatch(SkPDFFont* existingFont,
                                     uint32_t existingFontID,
                                     uint16_t existingGlyphID,
                                     uint32_t searchFontID,
                                     uint16_t searchGlyphID) {
     if (existingFontID != searchFontID) {
         return SkPDFFont::kNot_Match;
     }
     if (existingGlyphID == 0 || searchGlyphID == 0) {
         return SkPDFFont::kExact_Match;
     }
-    if (existingFont != NULL) {
+    if (existingFont != nullptr) {
         return (existingFont->fFirstGlyphID <= searchGlyphID &&
                 searchGlyphID <= existingFont->fLastGlyphID)
                        ? SkPDFFont::kExact_Match
                        : SkPDFFont::kRelated_Match;
     }
     return (existingGlyphID == searchGlyphID) ? SkPDFFont::kExact_Match
                                               : SkPDFFont::kRelated_Match;
 }