Style Change: NULL->nullptr

src/core/SkXfermode.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 "SkXfermode.h"
 #include "SkXfermode_proccoeff.h"
@@ skipping 648 matching lines @@
 
 bool SkXfermode::asXPFactory(GrXPFactory**) const {
     return false;
 }
 
 
 #if SK_SUPPORT_GPU
 #include "effects/GrPorterDuffXferProcessor.h"
 
 bool SkXfermode::AsXPFactory(SkXfermode* xfermode, GrXPFactory** xpf) {
-    if (NULL == xfermode) {
+    if (nullptr == xfermode) {
         if (xpf) {
             *xpf = GrPorterDuffXPFactory::Create(kSrcOver_Mode);
         }
         return true;
     } else {
         return xfermode->asXPFactory(xpf);
     }
 }
 #else
 bool SkXfermode::AsXPFactory(SkXfermode* xfermode, GrXPFactory** xpf) {
     return false;
 }
 #endif
 
 SkPMColor SkXfermode::xferColor(SkPMColor src, SkPMColor dst) const{
     // no-op. subclasses should override this
     return dst;
 }
 
 void SkXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                         const SkPMColor* SK_RESTRICT src, int count,
                         const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
-    if (NULL == aa) {
+    if (nullptr == aa) {
         for (int i = count - 1; i >= 0; --i) {
             dst[i] = this->xferColor(src[i], dst[i]);
         }
     } else {
         for (int i = count - 1; i >= 0; --i) {
             unsigned a = aa[i];
             if (0 != a) {
                 SkPMColor dstC = dst[i];
                 SkPMColor C = this->xferColor(src[i], dstC);
                 if (0xFF != a) {
                     C = SkFourByteInterp(C, dstC, a);
                 }
                 dst[i] = C;
             }
         }
     }
 }
 
 void SkXfermode::xfer16(uint16_t* dst,
                         const SkPMColor* SK_RESTRICT src, int count,
                         const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
-    if (NULL == aa) {
+    if (nullptr == aa) {
         for (int i = count - 1; i >= 0; --i) {
             SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
             dst[i] = SkPixel32ToPixel16_ToU16(this->xferColor(src[i], dstC));
         }
     } else {
         for (int i = count - 1; i >= 0; --i) {
             unsigned a = aa[i];
             if (0 != a) {
                 SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
                 SkPMColor C = this->xferColor(src[i], dstC);
                 if (0xFF != a) {
                     C = SkFourByteInterp(C, dstC, a);
                 }
                 dst[i] = SkPixel32ToPixel16_ToU16(C);
             }
         }
     }
 }
 
 void SkXfermode::xferA8(SkAlpha* SK_RESTRICT dst,
                         const SkPMColor src[], int count,
                         const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
-    if (NULL == aa) {
+    if (nullptr == aa) {
         for (int i = count - 1; i >= 0; --i) {
             SkPMColor res = this->xferColor(src[i], (dst[i] << SK_A32_SHIFT));
             dst[i] = SkToU8(SkGetPackedA32(res));
         }
     } else {
         for (int i = count - 1; i >= 0; --i) {
             unsigned a = aa[i];
             if (0 != a) {
                 SkAlpha dstA = dst[i];
                 unsigned A = SkGetPackedA32(this->xferColor(src[i],
@@ skipping 14 matching lines @@
 bool SkXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const {
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFlattenable* SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
     uint32_t mode32 = buffer.read32();
     if (!buffer.validate(mode32 < SK_ARRAY_COUNT(gProcCoeffs))) {
-        return NULL;
+        return nullptr;
     }
     return SkXfermode::Create((SkXfermode::Mode)mode32);
 }
 
 void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
     buffer.write32(fMode);
 }
 
 bool SkProcCoeffXfermode::asMode(Mode* mode) const {
     if (mode) {
@@ skipping 44 matching lines @@
 }
 
 void SkProcCoeffXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                                  const SkPMColor* SK_RESTRICT src, int count,
                                  const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
     SkXfermodeProc proc = fProc;
 
     if (proc) {
-        if (NULL == aa) {
+        if (nullptr == aa) {
             for (int i = count - 1; i >= 0; --i) {
                 dst[i] = proc(src[i], dst[i]);
             }
         } else {
             for (int i = count - 1; i >= 0; --i) {
                 unsigned a = aa[i];
                 if (0 != a) {
                     SkPMColor dstC = dst[i];
                     SkPMColor C = proc(src[i], dstC);
                     if (a != 0xFF) {
                         C = SkFourByteInterp(C, dstC, a);
                     }
                     dst[i] = C;
                 }
             }
         }
     }
 }
 
 void SkProcCoeffXfermode::xfer16(uint16_t* SK_RESTRICT dst,
                                  const SkPMColor* SK_RESTRICT src, int count,
                                  const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
     SkXfermodeProc proc = fProc;
 
     if (proc) {
-        if (NULL == aa) {
+        if (nullptr == aa) {
             for (int i = count - 1; i >= 0; --i) {
                 SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
                 dst[i] = SkPixel32ToPixel16_ToU16(proc(src[i], dstC));
             }
         } else {
             for (int i = count - 1; i >= 0; --i) {
                 unsigned a = aa[i];
                 if (0 != a) {
                     SkPMColor dstC = SkPixel16ToPixel32(dst[i]);
                     SkPMColor C = proc(src[i], dstC);
                     if (0xFF != a) {
                         C = SkFourByteInterp(C, dstC, a);
                     }
                     dst[i] = SkPixel32ToPixel16_ToU16(C);
                 }
             }
         }
     }
 }
 
 void SkProcCoeffXfermode::xferA8(SkAlpha* SK_RESTRICT dst,
                                  const SkPMColor* SK_RESTRICT src, int count,
                                  const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
     SkXfermodeProc proc = fProc;
 
     if (proc) {
-        if (NULL == aa) {
+        if (nullptr == aa) {
             for (int i = count - 1; i >= 0; --i) {
                 SkPMColor res = proc(src[i], dst[i] << SK_A32_SHIFT);
                 dst[i] = SkToU8(SkGetPackedA32(res));
             }
         } else {
             for (int i = count - 1; i >= 0; --i) {
                 unsigned a = aa[i];
                 if (0 != a) {
                     SkAlpha dstA = dst[i];
                     SkPMColor res = proc(src[i], dstA << SK_A32_SHIFT);
@@ skipping 99 matching lines @@
 }
 }  // namespace
 
 SK_DECLARE_STATIC_LAZY_PTR_ARRAY(SkXfermode, cached, SkXfermode::kLastMode + 1, create_mode);
 
 SkXfermode* SkXfermode::Create(Mode mode) {
     SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
 
     if ((unsigned)mode >= kModeCount) {
         // report error
-        return NULL;
+        return nullptr;
     }
 
-    // Skia's "default" mode is srcover. NULL in SkPaint is interpreted as srcover
-    // so we can just return NULL from the factory.
+    // Skia's "default" mode is srcover. nullptr in SkPaint is interpreted as srcover
+    // so we can just return nullptr from the factory.
     if (kSrcOver_Mode == mode) {
-        return NULL;
+        return nullptr;
     }
 
     return SkSafeRef(cached[mode]);
 }
 
 SkXfermodeProc SkXfermode::GetProc(Mode mode) {
-    SkXfermodeProc  proc = NULL;
+    SkXfermodeProc  proc = nullptr;
     if ((unsigned)mode < kModeCount) {
         proc = gProcCoeffs[mode].fProc;
     }
     return proc;
 }
 
 bool SkXfermode::ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst) {
     SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
 
     if ((unsigned)mode >= (unsigned)kModeCount) {
@@ skipping 11 matching lines @@
     if (src) {
         *src = rec.fSC;
     }
     if (dst) {
         *dst = rec.fDC;
     }
     return true;
 }
 
 bool SkXfermode::AsMode(const SkXfermode* xfer, Mode* mode) {
-    if (NULL == xfer) {
+    if (nullptr == xfer) {
         if (mode) {
             *mode = kSrcOver_Mode;
         }
         return true;
     }
     return xfer->asMode(mode);
 }
 
 bool SkXfermode::IsMode(const SkXfermode* xfer, Mode mode) {
     // if xfer==null then the mode is srcover
     Mode m = kSrcOver_Mode;
     if (xfer && !xfer->asMode(&m)) {
         return false;
     }
     return mode == m;
 }
 
 bool SkXfermode::SupportsCoverageAsAlpha(const SkXfermode* xfer) {
-    // if xfer is NULL we treat it as srcOver which always supports coverageAsAlpha
+    // if xfer is nullptr we treat it as srcOver which always supports coverageAsAlpha
     if (!xfer) {
         return true;
     }
 
     return xfer->supportsCoverageAsAlpha();
 }
 
 bool SkXfermode::IsOpaque(const SkXfermode* xfer, SrcColorOpacity opacityType) {
-    // if xfer is NULL we treat it as srcOver which is opaque if our src is opaque
+    // if xfer is nullptr we treat it as srcOver which is opaque if our src is opaque
     if (!xfer) {
         return SkXfermode::kOpaque_SrcColorOpacity == opacityType;
     }
 
     return xfer->isOpaque(opacityType);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END