Style Change: NULL->nullptr

tools/image_expectations.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapHasher.h"
 #include "SkData.h"
@@ skipping 104 matching lines @@
 
     bool Expectation::empty() const { return this->fIsEmpty; }
 
     bool Expectation::matches(ImageDigest &imageDigest) {
         return !(this->fIsEmpty) && (this->fImageDigest.equals(imageDigest));
     }
 
     // ImageResultsAndExpectations class...
 
     bool ImageResultsAndExpectations::readExpectationsFile(const char *jsonPath) {
-        if (NULL == jsonPath) {
+        if (nullptr == jsonPath) {
             SkDebugf("JSON expectations filename not specified\n");
             return false;
         }
         SkFILE* filePtr = sk_fopen(jsonPath, kRead_SkFILE_Flag);
-        if (NULL == filePtr) {
+        if (nullptr == filePtr) {
             SkDebugf("JSON expectations file '%s' does not exist\n", jsonPath);
             return false;
         }
         size_t size = sk_fgetsize(filePtr);
         if (0 == size) {
             SkDebugf("JSON expectations file '%s' is empty, so no expectations\n", jsonPath);
             sk_fclose(filePtr);
             fExpectedResults.clear();
             return true;
         }
@@ skipping 40 matching lines @@
         } else if (expectation.matches(digest)) {
             comparisonResult = kJsonValue_Image_ComparisonResult_Succeeded;
         } else if (expectation.ignoreFailure()) {
             comparisonResult = kJsonValue_Image_ComparisonResult_FailureIgnored;
         } else {
             comparisonResult = kJsonValue_Image_ComparisonResult_Failed;
         }
         actualImage[kJsonKey_Image_ComparisonResult] = comparisonResult;
 
         // Add this actual result to our collection.
-        if (NULL == tileNumber) {
+        if (nullptr == tileNumber) {
             fActualResults[sourceName][kJsonKey_Source_WholeImage] = actualImage;
         } else {
             fActualResults[sourceName][kJsonKey_Source_TiledImages][*tileNumber] = actualImage;
         }
     }
 
     void ImageResultsAndExpectations::addDescription(const char *key, const char *value) {
         fDescriptions[key] = value;
     }
 
     void ImageResultsAndExpectations::setImageBaseGSUrl(const char *imageBaseGSUrl) {
         fImageBaseGSUrl = imageBaseGSUrl;
     }
 
     Expectation ImageResultsAndExpectations::getExpectation(const char *sourceName,
                                                             const int *tileNumber) {
         if (fExpectedResults.isNull()) {
             return Expectation();
         }
 
         Json::Value expectedImage;
-        if (NULL == tileNumber) {
+        if (nullptr == tileNumber) {
             expectedImage = fExpectedResults[sourceName][kJsonKey_Source_WholeImage];
         } else {
             expectedImage = fExpectedResults[sourceName][kJsonKey_Source_TiledImages][*tileNumber];
         }
         if (expectedImage.isNull()) {
             return Expectation();
         }
 
         bool ignoreFailure = (expectedImage[kJsonKey_Image_IgnoreFailure] == true);
         return Expectation(SkString(expectedImage[kJsonKey_Image_ChecksumAlgorithm].asCString()),
@@ skipping 11 matching lines @@
         root[kJsonKey_Header] = header;
         root[kJsonKey_ImageBaseGSUrl] = fImageBaseGSUrl;
         std::string jsonStdString = root.toStyledString();
         SkFILEWStream stream(filename);
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
 
     /*static*/ bool ImageResultsAndExpectations::Parse(SkFILE *filePtr,
                                                        Json::Value *jsonRoot) {
         SkAutoDataUnref dataRef(SkData::NewFromFILE(filePtr));
-        if (NULL == dataRef.get()) {
+        if (nullptr == dataRef.get()) {
             return false;
         }
 
         const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data());
         size_t size = dataRef.get()->size();
         Json::Reader reader;
         if (!reader.parse(bytes, bytes+size, *jsonRoot)) {
             return false;
         }
 
         return true;
     }
 
 } // namespace sk_tools