Style Change: NULL->nullptr

samplecode/SampleApp.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 "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 93 matching lines @@
 static void post_event_to_sink(SkEvent* evt, SkEventSink* sink) {
     evt->setTargetID(sink->getSinkID())->post();
 }
 
 static SkAnimTimer gAnimTimer;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* skip_until(const char* str, const char* skip) {
     if (!str) {
-        return NULL;
+        return nullptr;
     }
     return strstr(str, skip);
 }
 
 static const char* skip_past(const char* str, const char* skip) {
     const char* found = skip_until(str, skip);
     if (!found) {
-        return NULL;
+        return nullptr;
     }
     return found + strlen(skip);
 }
 
 static const char* gPrefFileName = "sampleapp_prefs.txt";
 
 static bool readTitleFromPrefs(SkString* title) {
     SkFILEStream stream(gPrefFileName);
     if (!stream.isValid()) {
         return false;
@@ skipping 22 matching lines @@
     stream.write(data.c_str(), data.size());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SampleWindow::DefaultDeviceManager : public SampleWindow::DeviceManager {
 public:
 
     DefaultDeviceManager() {
 #if SK_SUPPORT_GPU
-        fCurContext = NULL;
-        fCurIntf = NULL;
-        fCurRenderTarget = NULL;
+        fCurContext = nullptr;
+        fCurIntf = nullptr;
+        fCurRenderTarget = nullptr;
         fMSAASampleCount = 0;
 #endif
         fBackend = kNone_BackEndType;
     }
 
     virtual ~DefaultDeviceManager() {
 #if SK_SUPPORT_GPU
         SkSafeUnref(fCurContext);
         SkSafeUnref(fCurIntf);
         SkSafeUnref(fCurRenderTarget);
@@ skipping 24 matching lines @@
                 break;
         }
         AttachmentInfo attachmentInfo;
         bool result = win->attach(fBackend, msaaSampleCount, &attachmentInfo);
         if (!result) {
             SkDebugf("Failed to initialize GL");
             return;
         }
         fMSAASampleCount = msaaSampleCount;
 
-        SkASSERT(NULL == fCurIntf);
+        SkASSERT(nullptr == fCurIntf);
         SkAutoTUnref<const GrGLInterface> glInterface;
         switch (win->getDeviceType()) {
             case kRaster_DeviceType:    // fallthrough
             case kPicture_DeviceType:   // fallthrough
             case kGPU_DeviceType:
                 // all these guys use the native interface
                 glInterface.reset(GrGLCreateNativeInterface());
                 break;
 #if SK_ANGLE
             case kANGLE_DeviceType:
                 glInterface.reset(GrGLCreateANGLEInterface());
                 break;
 #endif // SK_ANGLE
             default:
                 SkASSERT(false);
                 break;
         }
 
         // Currently SampleApp does not use NVPR. TODO: Provide an NVPR device type that is skipped
         // when the driver doesn't support NVPR.
         fCurIntf = GrGLInterfaceRemoveNVPR(glInterface.get());
 
-        SkASSERT(NULL == fCurContext);
+        SkASSERT(nullptr == fCurContext);
         fCurContext = GrContext::Create(kOpenGL_GrBackend, (GrBackendContext) fCurIntf);
 
-        if (NULL == fCurContext || NULL == fCurIntf) {
+        if (nullptr == fCurContext || nullptr == fCurIntf) {
             // We need some context and interface to see results
             SkSafeUnref(fCurContext);
             SkSafeUnref(fCurIntf);
-            fCurContext = NULL;
-            fCurIntf = NULL;
+            fCurContext = nullptr;
+            fCurIntf = nullptr;
             SkDebugf("Failed to setup 3D");
 
             win->detach();
         }
 #endif // SK_SUPPORT_GPU
         // call windowSizeChanged to create the render target
         this->windowSizeChanged(win);
     }
 
     void tearDownBackend(SampleWindow *win) override {
 #if SK_SUPPORT_GPU
         if (fCurContext) {
             // in case we have outstanding refs to this guy (lua?)
             fCurContext->abandonContext();
             fCurContext->unref();
-            fCurContext = NULL;
+            fCurContext = nullptr;
         }
 
         SkSafeUnref(fCurIntf);
-        fCurIntf = NULL;
+        fCurIntf = nullptr;
 
         SkSafeUnref(fCurRenderTarget);
-        fCurRenderTarget = NULL;
+        fCurRenderTarget = nullptr;
 #endif
         win->detach();
         fBackend = kNone_BackEndType;
     }
 
     SkSurface* createSurface(SampleWindow::DeviceType dType, SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (IsGpuDeviceType(dType) && fCurContext) {
             SkSurfaceProps props(win->getSurfaceProps());
             return SkSurface::NewRenderTargetDirect(fCurRenderTarget, &props);
         }
 #endif
-        return NULL;
+        return nullptr;
     }
 
     void publishCanvas(SampleWindow::DeviceType dType,
                        SkCanvas* canvas, SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (fCurContext) {
             // in case we have queued drawing calls
             fCurContext->flush();
 
             if (!IsGpuDeviceType(dType)) {
@@ skipping 21 matching lines @@
             SkSafeUnref(fCurRenderTarget);
             fCurRenderTarget = win->renderTarget(attachmentInfo, fCurIntf, fCurContext);
         }
 #endif
     }
 
     GrContext* getGrContext() override {
 #if SK_SUPPORT_GPU
         return fCurContext;
 #else
-        return NULL;
+        return nullptr;
 #endif
     }
 
     GrRenderTarget* getGrRenderTarget() override {
 #if SK_SUPPORT_GPU
         return fCurRenderTarget;
 #else
-        return NULL;
+        return nullptr;
 #endif
     }
 
 private:
 
 #if SK_SUPPORT_GPU
     GrContext*              fCurContext;
     const GrGLInterface*    fCurIntf;
     GrRenderTarget*         fCurRenderTarget;
     int fMSAASampleCount;
@@ skipping 24 matching lines @@
     return (*fCreateFunc)();
 }
 
 #include "GMSampleView.h"
 
 SkGMSampleViewFactory::SkGMSampleViewFactory(GMFactoryFunc func)
     : fFunc(func) {
 }
 
 SkView* SkGMSampleViewFactory::operator() () const {
-    skiagm::GM* gm = fFunc(NULL);
+    skiagm::GM* gm = fFunc(nullptr);
     gm->setMode(skiagm::GM::kSample_Mode);
     return new GMSampleView(gm);
 }
 
 SkViewRegister* SkViewRegister::gHead;
 SkViewRegister::SkViewRegister(SkViewFactory* fact) : fFact(fact) {
     fFact->ref();
     fChain = gHead;
     gHead = this;
 }
@@ skipping 50 matching lines @@
 };
 
 #include "SkDrawFilter.h"
 
 struct HintingState {
     SkPaint::Hinting hinting;
     const char* name;
     const char* label;
 };
 static HintingState gHintingStates[] = {
-    {SkPaint::kNo_Hinting, "Mixed", NULL },
+    {SkPaint::kNo_Hinting, "Mixed", nullptr },
     {SkPaint::kNo_Hinting, "None", "H0 " },
     {SkPaint::kSlight_Hinting, "Slight", "Hs " },
     {SkPaint::kNormal_Hinting, "Normal", "Hn " },
     {SkPaint::kFull_Hinting, "Full", "Hf " },
 };
 
 struct FilterQualityState {
     SkFilterQuality fQuality;
     const char*     fName;
     const char*     fLabel;
 };
 static FilterQualityState gFilterQualityStates[] = {
-    { kNone_SkFilterQuality,   "Mixed",    NULL    },
+    { kNone_SkFilterQuality,   "Mixed",    nullptr    },
     { kNone_SkFilterQuality,   "None",     "F0 "   },
     { kLow_SkFilterQuality,    "Low",      "F1 "   },
     { kMedium_SkFilterQuality, "Medium",   "F2 "   },
     { kHigh_SkFilterQuality,   "High",     "F3 "   },
 };
 
 class FlagsFilterCanvas : public SkPaintFilterCanvas {
 public:
     FlagsFilterCanvas(SkCanvas* canvas, SkOSMenu::TriState lcd, SkOSMenu::TriState aa,
                       SkOSMenu::TriState subpixel, int hinting, int filterQuality)
@@ skipping 167 matching lines @@
 
 void SampleWindow::setZoomCenter(float x, float y) {
     fZoomCenterX = x;
     fZoomCenterY = y;
 }
 
 bool SampleWindow::zoomIn() {
     // Arbitrarily decided
     if (fFatBitsScale == kMaxFatBitsScale) return false;
     fFatBitsScale++;
-    this->inval(NULL);
+    this->inval(nullptr);
     return true;
 }
 
 bool SampleWindow::zoomOut() {
     if (fFatBitsScale == 1) return false;
     fFatBitsScale--;
-    this->inval(NULL);
+    this->inval(nullptr);
     return true;
 }
 
 void SampleWindow::updatePointer(int x, int y) {
     fMouseX = x;
     fMouseY = y;
     if (fShowZoomer) {
-        this->inval(NULL);
+        this->inval(nullptr);
     }
 }
 
 static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) {
     static const SampleWindow::DeviceType gCT[] = {
         SampleWindow::kPicture_DeviceType,
 #if SK_SUPPORT_GPU
         SampleWindow::kGPU_DeviceType,
 #if SK_ANGLE
         SampleWindow::kANGLE_DeviceType,
@@ skipping 25 matching lines @@
 DEFINE_bool(list, false, "List samples?");
 DEFINE_string(key, "", "");  // dummy to enable gm tests that have platform-specific names
 #ifdef SAMPLE_PDF_FILE_VIEWER
 DEFINE_string(pdfPath, "", "Path to direcotry of pdf files.");
 #endif
 
 #include "SkTaskGroup.h"
 
 SampleWindow::SampleWindow(void* hwnd, int argc, char** argv, DeviceManager* devManager)
     : INHERITED(hwnd)
-    , fDevManager(NULL) {
+    , fDevManager(nullptr) {
 
     SkCommandLineFlags::Parse(argc, argv);
 
     fCurrIndex = -1;
 
     if (!FLAGS_pictureDir.isEmpty()) {
         SkOSFile::Iter iter(FLAGS_pictureDir[0], "skp");
         SkString filename;
         while (iter.next(&filename)) {
             *fSamples.append() = new PictFileFactory(
@@ skipping 20 matching lines @@
         const SkViewRegister* reg = SkViewRegister::Head();
         while (reg) {
             *fSamples.append() = reg->factory();
             reg = reg->next();
         }
     }
 
     if (FLAGS_sort) {
         // Sort samples, so foo.skp and foo.pdf are consecutive and we can quickly spot where
         // skp -> pdf -> png fails.
-        SkTQSort(fSamples.begin(), fSamples.end() ? fSamples.end() - 1 : NULL, compareSampleTitle);
+        SkTQSort(fSamples.begin(), fSamples.end() ? fSamples.end() - 1 : nullptr, compareSampleTitle);
     }
 
     if (!FLAGS_slide.isEmpty()) {
         fCurrIndex = findByTitle(FLAGS_slide[0]);
         if (fCurrIndex < 0) {
             fprintf(stderr, "Unknown sample \"%s\"\n", FLAGS_slide[0]);
             listTitles();
         }
     }
 
@@ skipping 43 matching lines @@
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
     fSubpixelState = SkOSMenu::kMixedState;
     fHintingState = 0;
     fFilterQualityIndex = 0;
     fFlipAxis = 0;
     fScrollTestX = fScrollTestY = 0;
 
     fMouseX = fMouseY = 0;
     fFatBitsScale = 8;
-    fTypeface = SkTypeface::CreateFromTypeface(NULL, SkTypeface::kBold);
+    fTypeface = SkTypeface::CreateFromTypeface(nullptr, SkTypeface::kBold);
     fShowZoomer = false;
 
     fZoomLevel = 0;
     fZoomScale = SK_Scalar1;
 
     fMagnify = false;
 
     fSaveToPdf = false;
     fSaveToSKP = false;
 
     int sinkID = this->getSinkID();
     fAppMenu = new SkOSMenu;
     fAppMenu->setTitle("Global Settings");
     int itemID;
 
     itemID =fAppMenu->appendList("Device Type", "Device Type", sinkID, 0,
                                 "Raster", "Picture", "OpenGL",
 #if SK_ANGLE
                                 "ANGLE",
 #endif
-                                NULL);
+                                nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'd');
     itemID = fAppMenu->appendTriState("AA", "AA", sinkID, fAAState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'b');
     itemID = fAppMenu->appendTriState("LCD", "LCD", sinkID, fLCDState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'l');
     itemID = fAppMenu->appendList("FilterQuality", "FilterQuality", sinkID, fFilterQualityIndex,
                                   gFilterQualityStates[0].fName,
                                   gFilterQualityStates[1].fName,
                                   gFilterQualityStates[2].fName,
                                   gFilterQualityStates[3].fName,
                                   gFilterQualityStates[4].fName,
-                                  NULL);
+                                  nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'n');
     itemID = fAppMenu->appendTriState("Subpixel", "Subpixel", sinkID, fSubpixelState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 's');
     itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState,
                                   gHintingStates[0].name,
                                   gHintingStates[1].name,
                                   gHintingStates[2].name,
                                   gHintingStates[3].name,
                                   gHintingStates[4].name,
-                                  NULL);
+                                  nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
 
     fUsePipeMenuItemID = fAppMenu->appendTriState("Pipe", "Pipe" , sinkID,
                                                   fPipeState);
     fAppMenu->assignKeyEquivalentToItem(fUsePipeMenuItemID, 'P');
 
     itemID =fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode,
                                  gTilingInfo[kNo_Tiling].label,
                                  gTilingInfo[kAbs_128x128_Tiling].label,
                                  gTilingInfo[kAbs_256x256_Tiling].label,
                                  gTilingInfo[kRel_4x4_Tiling].label,
                                  gTilingInfo[kRel_1x16_Tiling].label,
                                  gTilingInfo[kRel_16x1_Tiling].label,
-                                 NULL);
+                                 nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 't');
 
     itemID = fAppMenu->appendSwitch("Slide Show", "Slide Show" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'a');
     itemID = fAppMenu->appendSwitch("Clip", "Clip" , sinkID, fUseClip);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'c');
     itemID = fAppMenu->appendSwitch("Flip X", "Flip X" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'x');
     itemID = fAppMenu->appendSwitch("Flip Y", "Flip Y" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'y');
     itemID = fAppMenu->appendSwitch("Zoomer", "Zoomer" , sinkID, fShowZoomer);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'z');
     itemID = fAppMenu->appendSwitch("Magnify", "Magnify" , sinkID, fMagnify);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'm');
 
     itemID = fAppMenu->appendAction("Save to PDF", sinkID);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'e');
 
     this->addMenu(fAppMenu);
     fSlideMenu = new SkOSMenu;
     this->addMenu(fSlideMenu);
 
     this->setVisibleP(true);
     this->setClipToBounds(false);
 
     this->loadView((*fSamples[fCurrIndex])());
 
-    if (NULL == devManager) {
+    if (nullptr == devManager) {
         fDevManager = new DefaultDeviceManager();
     } else {
         devManager->ref();
         fDevManager = devManager;
     }
     fDevManager->setUpBackend(this, fMSAASampleCount);
 
     // If another constructor set our dimensions, ensure that our
     // onSizeChange gets called.
     if (this->height() && this->width()) {
@@ skipping 84 matching lines @@
         SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
         SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
         SkCanvas* tileCanvas = surface->getCanvas();
 
         for (SkScalar y = 0; y < height(); y += tile.height()) {
             for (SkScalar x = 0; x < width(); x += tile.width()) {
                 SkAutoCanvasRestore acr(tileCanvas, true);
                 tileCanvas->translate(-x, -y);
                 tileCanvas->clear(0);
                 this->INHERITED::draw(tileCanvas);
-                surface->draw(canvas, x, y, NULL);
+                surface->draw(canvas, x, y, nullptr);
             }
         }
 
         // for drawing the borders between tiles
         SkPaint paint;
         paint.setColor(0x60FF00FF);
         paint.setStyle(SkPaint::kStroke_Style);
 
         for (SkScalar y = 0; y < height(); y += tile.height()) {
             for (SkScalar x = 0; x < width(); x += tile.width()) {
                 canvas->drawRect(SkRect::MakeXYWH(x, y, tile.width(), tile.height()), paint);
             }
         }
     }
 
     if (fShowZoomer && !fSaveToPdf) {
         showZoomer(canvas);
     }
     if (fMagnify && !fSaveToPdf) {
         magnify(canvas);
     }
 
     if (fMeasureFPS && fMeasureFPS_Time) {
         this->updateTitle();
         this->postInvalDelay();
     }
 
     if (this->sendAnimatePulse()) {
-        this->inval(NULL);
+        this->inval(nullptr);
     }
 
     // do this last
     fDevManager->publishCanvas(fDeviceType, canvas, this);
 }
 
 static float clipW = 200;
 static float clipH = 200;
 void SampleWindow::magnify(SkCanvas* canvas) {
     SkRect r;
@@ skipping 123 matching lines @@
     paint.setColor(SK_ColorWHITE);
     canvas->drawRect(dest, paint);
     switch (fFatBitsScale) {
         case kMaxFatBitsScale:
             show_lcd_grid(canvas, bitmap, src, dest, show_lcd_box);
             break;
         case kMaxFatBitsScale - 1:
             show_lcd_grid(canvas, bitmap, src, dest, show_lcd_circle);
             break;
         default:
-            canvas->drawBitmapRect(bitmap, src, dest, NULL);
+            canvas->drawBitmapRect(bitmap, src, dest, nullptr);
             break;
     }
 
     paint.setColor(SK_ColorBLACK);
     paint.setStyle(SkPaint::kStroke_Style);
     // Draw a border around the pixel in the middle
     SkRect originalPixel;
     originalPixel.set(SkIntToScalar(fMouseX), SkIntToScalar(fMouseY), SkIntToScalar(fMouseX + 1), SkIntToScalar(fMouseY + 1));
     SkMatrix matrix;
     SkRect scalarSrc;
     scalarSrc.set(src);
     SkColor color = bitmap.getColor(fMouseX, fMouseY);
     if (matrix.setRectToRect(scalarSrc, dest, SkMatrix::kFill_ScaleToFit)) {
         SkRect pixel;
         matrix.mapRect(&pixel, originalPixel);
         // TODO Perhaps measure the values and make the outline white if it's "dark"
         if (color == SK_ColorBLACK) {
             paint.setColor(SK_ColorWHITE);
         }
         canvas->drawRect(pixel, paint);
     }
     paint.setColor(SK_ColorBLACK);
     // Draw a border around the destination rectangle
     canvas->drawRect(dest, paint);
     paint.setStyle(SkPaint::kStrokeAndFill_Style);
     // Identify the pixel and its color on screen
     paint.setTypeface(fTypeface);
     paint.setAntiAlias(true);
-    SkScalar lineHeight = paint.getFontMetrics(NULL);
+    SkScalar lineHeight = paint.getFontMetrics(nullptr);
     SkString string;
     string.appendf("(%i, %i)", fMouseX, fMouseY);
     SkScalar left = dest.fLeft + SkIntToScalar(3);
     SkScalar i = SK_Scalar1;
     drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
     // Alpha
     i += SK_Scalar1;
     string.reset();
     string.appendf("A: %X", SkColorGetA(color));
     drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
@@ skipping 20 matching lines @@
 
 void SampleWindow::onDraw(SkCanvas* canvas) {
 }
 
 #include "SkColorPriv.h"
 
 void SampleWindow::saveToPdf()
 {
 #if SK_SUPPORT_PDF
     fSaveToPdf = true;
-    this->inval(NULL);
+    this->inval(nullptr);
 #endif  // SK_SUPPORT_PDF
 }
 
 SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
     if (fSaveToPdf) {
         SkString name;
         if (!this->getRawTitle(&name)) {
             name.set("unknown_sample");
         }
         name.append(".pdf");
 #ifdef SK_BUILD_FOR_ANDROID
         name.prepend("/sdcard/");
 #endif
         fPDFDocument.reset(SkDocument::CreatePDF(name.c_str()));
         canvas = fPDFDocument->beginPage(this->width(), this->height());
     } else if (kPicture_DeviceType == fDeviceType) {
-        canvas = fRecorder.beginRecording(9999, 9999, NULL, 0);
+        canvas = fRecorder.beginRecording(9999, 9999, nullptr, 0);
     } else {
         canvas = this->INHERITED::beforeChildren(canvas);
     }
 
     if (fUseClip) {
         canvas->drawColor(0xFFFF88FF);
         canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true);
     }
 
     // Install a flags filter proxy canvas if needed
     if (fLCDState != SkOSMenu::kMixedState ||
         fAAState != SkOSMenu::kMixedState ||
         fSubpixelState != SkOSMenu::kMixedState ||
         fHintingState > 0 ||
         fFilterQualityIndex > 0) {
         canvas = new FlagsFilterCanvas(canvas, fLCDState, fAAState, fSubpixelState, fHintingState,
                                        fFilterQualityIndex);
         fFlagsFilterCanvas.reset(canvas);
     }
 
     return canvas;
 }
 #include "SkMultiPictureDraw.h"
 void SampleWindow::afterChildren(SkCanvas* orig) {
-    fFlagsFilterCanvas.reset(NULL);
+    fFlagsFilterCanvas.reset(nullptr);
 
     if (fSaveToPdf) {
         fSaveToPdf = false;
         fPDFDocument->endPage();
-        fPDFDocument.reset(NULL);
+        fPDFDocument.reset(nullptr);
         // We took over the draw calls in order to create the PDF, so we need
         // to redraw.
-        this->inval(NULL);
+        this->inval(nullptr);
         return;
     }
 
     if (fRequestGrabImage) {
         fRequestGrabImage = false;
 
         SkBitmap bmp = capture_bitmap(orig);
         if (!bmp.isNull()) {
             static int gSampleGrabCounter;
             SkString name;
@@ skipping 27 matching lines @@
                     for (int y = 0; y < 2; ++y) {
                         for (int x = 0; x < 2; ++x) {
                             char* p = (char*)addr;
                             p += y * n.height() * rowBytes;
                             p += x * n.width() * sizeof(SkPMColor);
                             surfs[index] = SkSurface::NewRasterDirect(n, p, rowBytes);
                             SkCanvas* c = surfs[index]->getCanvas();
                             c->translate(SkIntToScalar(-x * n.width()),
                                          SkIntToScalar(-y * n.height()));
                             c->concat(orig->getTotalMatrix());
-                            md.add(c, picture, NULL, NULL);
+                            md.add(c, picture, nullptr, nullptr);
                             index++;
                         }
                     }
                     md.draw();
                     for (int i = 0; i < 4; ++i) {
                         surfs[i]->unref();
                     }
                 }
             } else {
                 orig->drawPicture(picture);
             }
         } else if (true) {
             SkDynamicMemoryWStream ostream;
             picture->serialize(&ostream);
 
             SkAutoDataUnref data(ostream.copyToData());
             SkMemoryStream istream(data->data(), data->size());
             SkAutoTUnref<SkPicture> pict(SkPicture::CreateFromStream(&istream));
-            if (pict.get() != NULL) {
+            if (pict.get() != nullptr) {
                 orig->drawPicture(pict.get());
             }
         } else {
             picture->playback(orig);
         }
     }
 
     // Do this after presentGL and other finishing, rather than in afterChild
     if (fMeasureFPS) {
         fTimer.end();
@@ skipping 33 matching lines @@
         canvas->concat(m);
     }
 
     if (fMeasureFPS) {
         (void)SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT);
         fTimer.start();
     } else {
         (void)SampleView::SetRepeatDraw(child, 1);
     }
     if (fPerspAnim || fRotate) {
-        this->inval(NULL);
+        this->inval(nullptr);
     }
 }
 
 void SampleWindow::changeZoomLevel(float delta) {
     fZoomLevel += delta;
     if (fZoomLevel > 0) {
         fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL);
         fZoomScale = fZoomLevel + SK_Scalar1;
     } else if (fZoomLevel < 0) {
         fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL);
@@ skipping 30 matching lines @@
         m.preTranslate(-fZoomCenterX, -fZoomCenterY);
         //canvas->concat(m);
     }
     // Apply any gesture matrix
     m.preConcat(fGesture.localM());
     m.preConcat(fGesture.globalM());
 
     this->setLocalMatrix(m);
 
     this->updateTitle();
-    this->inval(NULL);
+    this->inval(nullptr);
 }
 bool SampleWindow::previousSample() {
     fCurrIndex = (fCurrIndex - 1 + fSamples.count()) % fSamples.count();
     this->loadView((*fSamples[fCurrIndex])());
     return true;
 }
 
 #include "SkResourceCache.h"
 #include "SkGlyphCache.h"
 bool SampleWindow::nextSample() {
@@ skipping 43 matching lines @@
             this->nextSample();
             this->postAnimatingEvent();
         }
         return true;
     }
     if (evt.isType("set-curr-index")) {
         this->goToSample(evt.getFast32());
         return true;
     }
     if (isInvalEvent(evt)) {
-        this->inval(NULL);
+        this->inval(nullptr);
         return true;
     }
     int selected = -1;
     if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) {
         this->setDeviceType((DeviceType)selected);
         return true;
     }
     if (SkOSMenu::FindTriState(evt, "Pipe", &fPipeState)) {
 #ifdef PIPE_NET
         if (!fPipeState != SkOSMenu::kOnState)
             gServer.disconnectAll();
 #endif
         (void)SampleView::SetUsePipe(curr_view(this), fPipeState);
         this->updateTitle();
-        this->inval(NULL);
+        this->inval(nullptr);
         return true;
     }
-    if (SkOSMenu::FindSwitchState(evt, "Slide Show", NULL)) {
+    if (SkOSMenu::FindSwitchState(evt, "Slide Show", nullptr)) {
         this->toggleSlideshow();
         return true;
     }
     if (SkOSMenu::FindTriState(evt, "AA", &fAAState) ||
         SkOSMenu::FindTriState(evt, "LCD", &fLCDState) ||
         SkOSMenu::FindListIndex(evt, "FilterQuality", &fFilterQualityIndex) ||
         SkOSMenu::FindTriState(evt, "Subpixel", &fSubpixelState) ||
         SkOSMenu::FindListIndex(evt, "Hinting", &fHintingState) ||
         SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) ||
         SkOSMenu::FindSwitchState(evt, "Zoomer", &fShowZoomer) ||
         SkOSMenu::FindSwitchState(evt, "Magnify", &fMagnify))
     {
-        this->inval(NULL);
+        this->inval(nullptr);
         this->updateTitle();
         return true;
     }
     if (SkOSMenu::FindListIndex(evt, "Tiling", &fTilingMode)) {
         if (SampleView::IsSampleView(curr_view(this))) {
             ((SampleView*)curr_view(this))->onTileSizeChanged(this->tileSize());
         }
-        this->inval(NULL);
+        this->inval(nullptr);
         this->updateTitle();
         return true;
     }
-    if (SkOSMenu::FindSwitchState(evt, "Flip X", NULL)) {
+    if (SkOSMenu::FindSwitchState(evt, "Flip X", nullptr)) {
         fFlipAxis ^= kFlipAxis_X;
         this->updateMatrix();
         return true;
     }
-    if (SkOSMenu::FindSwitchState(evt, "Flip Y", NULL)) {
+    if (SkOSMenu::FindSwitchState(evt, "Flip Y", nullptr)) {
         fFlipAxis ^= kFlipAxis_Y;
         this->updateMatrix();
         return true;
     }
     if (SkOSMenu::FindAction(evt,"Save to PDF")) {
         this->saveToPdf();
         return true;
     }
     return this->INHERITED::onEvent(evt);
 }
@@ skipping 10 matching lines @@
             query->setString("title", evt.findString(gTitleEvtName));
         }
         SkSafeUnref(view);
         return true;
     }
     if (query->isType("use-fast-text")) {
         SkEvent evt(gFastTextEvtName);
         return curr_view(this)->doQuery(&evt);
     }
     if (query->isType("ignore-window-bitmap")) {
-        query->setFast32(this->getGrContext() != NULL);
+        query->setFast32(this->getGrContext() != nullptr);
         return true;
     }
     return this->INHERITED::onQuery(query);
 }
 
 DECLARE_bool(portableFonts);
 
 bool SampleWindow::onHandleChar(SkUnichar uni) {
     {
         SkView* view = curr_view(this);
@@ skipping 24 matching lines @@
             break;
     }
 
     if (0xFF != dx && 0xFF != dy) {
         if ((dx | dy) == 0) {
             fScrollTestX = fScrollTestY = 0;
         } else {
             fScrollTestX += dx;
             fScrollTestY += dy;
         }
-        this->inval(NULL);
+        this->inval(nullptr);
         return true;
     }
 
     switch (uni) {
         case 27:    // ESC
             gAnimTimer.stop();
             if (this->sendAnimatePulse()) {
-                this->inval(NULL);
+                this->inval(nullptr);
             }
             break;
         case ' ':
             gAnimTimer.togglePauseResume();
             if (this->sendAnimatePulse()) {
-                this->inval(NULL);
+                this->inval(nullptr);
             }
             break;
         case 'B':
             post_event_to_sink(new SkEvent("PictFileView::toggleBBox"), curr_view(this));
             // Cannot call updateTitle() synchronously, because the toggleBBox event is still in
             // the queue.
             post_event_to_sink(new SkEvent(gUpdateWindowTitleEvtName), this);
-            this->inval(NULL);
+            this->inval(nullptr);
             break;
         case 'D':
             toggleDistanceFieldFonts();
             break;
         case 'f':
             // only
             toggleFPS();
             break;
         case 'F':
             FLAGS_portableFonts ^= true;
-            this->inval(NULL);
+            this->inval(nullptr);
             break;
         case 'g':
             fRequestGrabImage = true;
-            this->inval(NULL);
+            this->inval(nullptr);
             break;
         case 'G':
             gShowGMBounds = !gShowGMBounds;
             post_event_to_sink(GMSampleView::NewShowSizeEvt(gShowGMBounds),
                             curr_view(this));
-            this->inval(NULL);
+            this->inval(nullptr);
             break;
         case 'i':
             this->zoomIn();
             break;
         case 'o':
             this->zoomOut();
             break;
         case 'r':
             fRotate = !fRotate;
-            this->inval(NULL);
+            this->inval(nullptr);
             this->updateTitle();
             return true;
         case 'k':
             fPerspAnim = !fPerspAnim;
-            this->inval(NULL);
+            this->inval(nullptr);
             this->updateTitle();
             return true;
         case 'K':
             fSaveToSKP = true;
-            this->inval(NULL);
+            this->inval(nullptr);
             return true;
 #if SK_SUPPORT_GPU
         case 'p':
             {
                 GrContext* grContext = this->getGrContext();
                 if (grContext) {
                     size_t cacheBytes;
-                    grContext->getResourceCacheUsage(NULL, &cacheBytes);
+                    grContext->getResourceCacheUsage(nullptr, &cacheBytes);
                     grContext->freeGpuResources();
                     SkDebugf("Purged %d bytes from the GPU resource cache.\n", cacheBytes);
                 }
             }
             return true;
 #endif
         default:
             break;
     }
 
     if (fAppMenu->handleKeyEquivalent(uni)|| fSlideMenu->handleKeyEquivalent(uni)) {
         this->onUpdateMenu(fAppMenu);
         this->onUpdateMenu(fSlideMenu);
         return true;
     }
     return this->INHERITED::onHandleChar(uni);
 }
 
 void SampleWindow::setDeviceType(DeviceType type) {
     if (type == fDeviceType)
         return;
 
     fDevManager->tearDownBackend(this);
 
     fDeviceType = type;
 
     fDevManager->setUpBackend(this, fMSAASampleCount);
 
     this->updateTitle();
-    this->inval(NULL);
+    this->inval(nullptr);
 }
 
 void SampleWindow::toggleSlideshow() {
     fAnimating = !fAnimating;
     this->postAnimatingEvent();
     this->updateTitle();
 }
 
 void SampleWindow::toggleRendering() {
     this->setDeviceType(cycle_devicetype(fDeviceType));
     this->updateTitle();
-    this->inval(NULL);
+    this->inval(nullptr);
 }
 
 void SampleWindow::toggleFPS() {
     fMeasureFPS = !fMeasureFPS;
     this->updateTitle();
-    this->inval(NULL);
+    this->inval(nullptr);
 }
 
 void SampleWindow::toggleDistanceFieldFonts() {
     SkSurfaceProps props = this->getSurfaceProps();
     uint32_t flags = props.flags() ^ SkSurfaceProps::kUseDistanceFieldFonts_Flag;
     this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry()));
 
     this->updateTitle();
-    this->inval(NULL);
+    this->inval(nullptr);
 }
 
 #include "SkDumpCanvas.h"
 
 bool SampleWindow::onHandleKey(SkKey key) {
     {
         SkView* view = curr_view(this);
         if (view) {
             SkEvent evt(gKeyEvtName);
             evt.setFast32(key);
@@ skipping 46 matching lines @@
     }
     int w = SkScalarRoundToInt(this->width());
     int h = SkScalarRoundToInt(this->height());
 
     // check for the resize-box
     if (w - x < 16 && h - y < 16) {
         return false;   // let the OS handle the click
     }
     else if (fMagnify) {
         //it's only necessary to update the drawing if there's a click
-        this->inval(NULL);
+        this->inval(nullptr);
         return false; //prevent dragging while magnify is enabled
     } else {
         // capture control+option, and trigger debugger
         if ((modi & kControl_SkModifierKey) && (modi & kOption_SkModifierKey)) {
             if (Click::kDown_State == state) {
                 SkEvent evt("debug-hit-test");
                 evt.setS32("debug-hit-test-x", x);
                 evt.setS32("debug-hit-test-y", y);
                 curr_view(this)->doEvent(evt);
             }
@@ skipping 83 matching lines @@
 static_assert(SK_ARRAY_COUNT(gDeviceTypePrefix) == SampleWindow::kDeviceTypeCnt,
               "array_size_mismatch");
 
 static const char* trystate_str(SkOSMenu::TriState state,
                                 const char trueStr[], const char falseStr[]) {
     if (SkOSMenu::kOnState == state) {
         return trueStr;
     } else if (SkOSMenu::kOffState == state) {
         return falseStr;
     }
-    return NULL;
+    return nullptr;
 }
 
 bool SampleWindow::getRawTitle(SkString* title) {
     return curr_title(this, title);
 }
 
 void SampleWindow::updateTitle() {
     SkString title;
     if (!this->getRawTitle(&title)) {
         title.set("<unknown>");
@@ skipping 17 matching lines @@
         title.prepend("<K> ");
     }
     if (this->getSurfaceProps().flags() & SkSurfaceProps::kUseDistanceFieldFonts_Flag) {
         title.prepend("<DFF> ");
     }
 
     title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
     title.prepend(trystate_str(fAAState, "AA ", "aa "));
     title.prepend(gFilterQualityStates[fFilterQualityIndex].fLabel);
     title.prepend(trystate_str(fSubpixelState, "S ", "s "));
-    title.prepend(fFlipAxis & kFlipAxis_X ? "X " : NULL);
-    title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : NULL);
+    title.prepend(fFlipAxis & kFlipAxis_X ? "X " : nullptr);
+    title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : nullptr);
     title.prepend(gHintingStates[fHintingState].label);
 
     if (fZoomLevel) {
         title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
     }
 
     if (fMeasureFPS) {
         title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
     }
 
@@ skipping 130 matching lines @@
     void*           fBlock;
     size_t          fBlockSize;
     size_t          fBytesWritten;
     int             fAtomsWritten;
     SkGPipeReader::Status   fStatus;
 
     size_t        fTotalWritten;
 };
 
 SimplePC::SimplePC(SkCanvas* target) : fReader(target) {
-    fBlock = NULL;
+    fBlock = nullptr;
     fBlockSize = fBytesWritten = 0;
     fStatus = SkGPipeReader::kDone_Status;
     fTotalWritten = 0;
     fAtomsWritten = 0;
     fReader.setBitmapDecoder(&SkImageDecoder::DecodeMemory);
 }
 
 SimplePC::~SimplePC() {
 //    SkASSERT(SkGPipeReader::kDone_Status == fStatus);
     if (fTotalWritten) {
         SkDebugf("--- %d bytes %d atoms, status %d\n", fTotalWritten,
                  fAtomsWritten, fStatus);
 #ifdef  PIPE_FILE
         //File is open in append mode
         FILE* f = fopen(FILE_PATH, "ab");
-        SkASSERT(f != NULL);
+        SkASSERT(f != nullptr);
         fwrite((const char*)fBlock + fBytesWritten, 1, bytes, f);
         fclose(f);
 #endif
 #ifdef PIPE_NET
         if (fAtomsWritten > 1 && fTotalWritten > 4) { //ignore done
             gServer.acceptConnections();
             gServer.writePacket(fBlock, fTotalWritten);
         }
 #endif
     }
@@ skipping 163 matching lines @@
         test_rects(rect, N);
     }
 }
 
 // FIXME: this should be in a header
 SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv);
 SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
     if (false) { // avoid bit rot, suppress warning
         test();
     }
-    return new SampleWindow(hwnd, argc, argv, NULL);
+    return new SampleWindow(hwnd, argc, argv, nullptr);
 }
 
 // FIXME: this should be in a header
 void get_preferred_size(int* x, int* y, int* width, int* height);
 void get_preferred_size(int* x, int* y, int* width, int* height) {
     *x = 10;
     *y = 50;
     *width = 640;
     *height = 480;
 }
@@ skipping 12 matching lines @@
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }