Style Change: NULL->nullptr

src/core/SkScan_Antihair.cpp

 
 /*
  * Copyright 2011 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 "SkScan.h"
 #include "SkBlitter.h"
 #include "SkColorPriv.h"
 #include "SkLineClipper.h"
 #include "SkRasterClip.h"
 #include "SkFDot6.h"
 
 /*  Our attempt to compute the worst case "bounds" for the horizontal and
     vertical cases has some numerical bug in it, and we sometimes undervalue
     our extends. The bug is that when this happens, we will set the clip to
-    NULL (for speed), and thus draw outside of the clip by a pixel, which might
+    nullptr (for speed), and thus draw outside of the clip by a pixel, which might
     only look bad, but it might also access memory outside of the valid range
     allcoated for the device bitmap.
 
     This define enables our fix to outset our "bounds" by 1, thus avoiding the
     chance of the bug, but at the cost of sometimes taking the rectblitter
-    case (i.e. not setting the clip to NULL) when we might not actually need
+    case (i.e. not setting the clip to nullptr) when we might not actually need
     to. If we can improve/fix the actual calculations, then we can remove this
     step.
  */
 #define OUTSET_BEFORE_CLIP_TEST     true
 
 #define HLINE_STACK_BUFFER      100
 
 static inline int SmallDot6Scale(int value, int dot6) {
     SkASSERT((int16_t)value == value);
     SkASSERT((unsigned)dot6 <= 64);
@@ skipping 44 matching lines @@
         runs[0] = SkToS16(n);
         runs[n] = 0;
         blitter->blitAntiH(x, y, aa, runs);
         x += n;
         count -= n;
     } while (count > 0);
 }
 
 class SkAntiHairBlitter {
 public:
-    SkAntiHairBlitter() : fBlitter(NULL) {}
+    SkAntiHairBlitter() : fBlitter(nullptr) {}
     virtual ~SkAntiHairBlitter() {}
 
     SkBlitter* getBlitter() const { return fBlitter; }
 
     void setup(SkBlitter* blitter) {
         fBlitter = blitter;
     }
 
     virtual SkFixed drawCap(int x, SkFixed fy, SkFixed slope, int mod64) = 0;
     virtual SkFixed drawLine(int x, int stopx, SkFixed fy, SkFixed slope) = 0;
@@ skipping 231 matching lines @@
     }
 
     int         scaleStart, scaleStop;
     int         istart, istop;
     SkFixed     fstart, slope;
 
     HLine_SkAntiHairBlitter     hline_blitter;
     Horish_SkAntiHairBlitter    horish_blitter;
     VLine_SkAntiHairBlitter     vline_blitter;
     Vertish_SkAntiHairBlitter   vertish_blitter;
-    SkAntiHairBlitter*          hairBlitter = NULL;
+    SkAntiHairBlitter*          hairBlitter = nullptr;
 
     if (SkAbs32(x1 - x0) > SkAbs32(y1 - y0)) {   // mostly horizontal
         if (x0 > x1) {    // we want to go left-to-right
             SkTSwap<SkFDot6>(x0, x1);
             SkTSwap<SkFDot6>(y0, y1);
         }
 
         istart = SkFDot6Floor(x0);
         istop = SkFDot6Ceil(x1);
         fstart = SkFDot6ToFixed(y0);
@@ skipping 51 matching lines @@
                 top = SkFixedFloorToInt(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
             }
 #ifdef OUTSET_BEFORE_CLIP_TEST
             top -= 1;
             bottom += 1;
 #endif
             if (top >= clip->fBottom || bottom <= clip->fTop) {
                 return;
             }
             if (clip->fTop <= top && clip->fBottom >= bottom) {
-                clip = NULL;
+                clip = nullptr;
             }
         }
     } else {   // mostly vertical
         if (y0 > y1) {  // we want to go top-to-bottom
             SkTSwap<SkFDot6>(x0, x1);
             SkTSwap<SkFDot6>(y0, y1);
         }
 
         istart = SkFDot6Floor(y0);
         istop = SkFDot6Ceil(y1);
@@ skipping 55 matching lines @@
                 left = SkFixedFloorToInt(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
             }
 #ifdef OUTSET_BEFORE_CLIP_TEST
             left -= 1;
             right += 1;
 #endif
             if (left >= clip->fRight || right <= clip->fLeft) {
                 return;
             }
             if (clip->fLeft <= left && clip->fRight >= right) {
-                clip = NULL;
+                clip = nullptr;
             }
         }
     }
 
     SkRectClipBlitter   rectClipper;
     if (clip) {
         rectClipper.init(blitter, *clip);
         blitter = &rectClipper;
     }
 
@@ skipping 17 matching lines @@
         hairBlitter->drawCap(istop - 1, fstart, slope, scaleStop);
     }
 }
 
 void SkScan::AntiHairLineRgn(const SkPoint array[], int arrayCount, const SkRegion* clip,
                              SkBlitter* blitter) {
     if (clip && clip->isEmpty()) {
         return;
     }
 
-    SkASSERT(clip == NULL || !clip->getBounds().isEmpty());
+    SkASSERT(clip == nullptr || !clip->getBounds().isEmpty());
 
 #ifdef TEST_GAMMA
     build_gamma_table();
 #endif
 
     const SkScalar max = SkIntToScalar(32767);
     const SkRect fixedBounds = SkRect::MakeLTRB(-max, -max, max, max);
 
     SkRect clipBounds;
     if (clip) {
@@ skipping 48 matching lines @@
                 const SkIRect*       r = &iter.rect();
 
                 while (!iter.done()) {
                     do_anti_hairline(x0, y0, x1, y1, r, blitter);
                     iter.next();
                 }
                 continue;
             }
             // fall through to no-clip case
         }
-        do_anti_hairline(x0, y0, x1, y1, NULL, blitter);
+        do_anti_hairline(x0, y0, x1, y1, nullptr, blitter);
     }
 }
 
 void SkScan::AntiHairRect(const SkRect& rect, const SkRasterClip& clip,
                           SkBlitter* blitter) {
     SkPoint pts[5];
 
     pts[0].set(rect.fLeft, rect.fTop);
     pts[1].set(rect.fRight, rect.fTop);
     pts[2].set(rect.fRight, rect.fBottom);
@@ skipping 83 matching lines @@
 static void antifillrect(const SkXRect& xr, SkBlitter* blitter) {
     antifilldot8(SkFixedToFDot8(xr.fLeft), SkFixedToFDot8(xr.fTop),
                  SkFixedToFDot8(xr.fRight), SkFixedToFDot8(xr.fBottom),
                  blitter, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkScan::AntiFillXRect(const SkXRect& xr, const SkRegion* clip,
                           SkBlitter* blitter) {
-    if (NULL == clip) {
+    if (nullptr == clip) {
         antifillrect(xr, blitter);
     } else {
         SkIRect outerBounds;
         XRect_roundOut(xr, &outerBounds);
 
         if (clip->isRect()) {
             const SkIRect& clipBounds = clip->getBounds();
 
             if (clipBounds.contains(outerBounds)) {
                 antifillrect(xr, blitter);
@@ skipping 25 matching lines @@
 
 void SkScan::AntiFillXRect(const SkXRect& xr, const SkRasterClip& clip,
                            SkBlitter* blitter) {
     if (clip.isBW()) {
         AntiFillXRect(xr, &clip.bwRgn(), blitter);
     } else {
         SkIRect outerBounds;
         XRect_roundOut(xr, &outerBounds);
 
         if (clip.quickContains(outerBounds)) {
-            AntiFillXRect(xr, NULL, blitter);
+            AntiFillXRect(xr, nullptr, blitter);
         } else {
             SkAAClipBlitterWrapper wrapper(clip, blitter);
             blitter = wrapper.getBlitter();
 
             AntiFillXRect(xr, &wrapper.getRgn(), wrapper.getBlitter());
         }
     }
 }
 
 /*  This guy takes a float-rect, but with the key improvement that it has
@@ skipping 235 matching lines @@
 
 void SkScan::AntiFrameRect(const SkRect& r, const SkPoint& strokeSize,
                            const SkRasterClip& clip, SkBlitter* blitter) {
     if (clip.isBW()) {
         AntiFrameRect(r, strokeSize, &clip.bwRgn(), blitter);
     } else {
         SkAAClipBlitterWrapper wrap(clip, blitter);
         AntiFrameRect(r, strokeSize, &wrap.getRgn(), wrap.getBlitter());
     }
 }