cleanup: fix gm's use of ErrorBitfield to be consistent (it's a bitfield, not an enum)

gm/gmmain.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.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 62 matching lines @@
     #include "SkXPSDevice.h"
 #endif
 
 #ifdef SK_BUILD_FOR_MAC
     #include "SkCGUtils.h"
     #define CAN_IMAGE_PDF   1
 #else
     #define CAN_IMAGE_PDF   0
 #endif
 
-// TODO(epoger): We created this ErrorBitfield so that we could record
-// multiple error types for the same comparison. But in practice, we
-// process its final value in switch() statements, which inherently
-// assume that only one error type will be set.
-// I think we should probably change this to be an enum, and thus
-// constrain ourselves to a single error type per comparison.
 typedef int ErrorBitfield;
-const static ErrorBitfield ERROR_NONE                    = 0x00;
-const static ErrorBitfield ERROR_NO_GPU_CONTEXT          = 0x01;
-const static ErrorBitfield ERROR_IMAGE_MISMATCH          = 0x02;
-// const static ErrorBitfield ERROR_DIMENSION_MISMATCH      = 0x04; DEPRECATED in https://codereview.appspot.com/7064047
-const static ErrorBitfield ERROR_READING_REFERENCE_IMAGE = 0x08;
-const static ErrorBitfield ERROR_WRITING_REFERENCE_IMAGE = 0x10;
+// an empty bitfield means no errors:
+const static ErrorBitfield kEmptyErrorBitfield                 = 0x00;
+// individual error types:
+const static ErrorBitfield kNoGpuContext_ErrorBitmask          = 0x01;
+const static ErrorBitfield kImageMismatch_ErrorBitmask         = 0x02;
+const static ErrorBitfield kMissingExpectations_ErrorBitmask   = 0x04;
+const static ErrorBitfield kWritingReferenceImage_ErrorBitmask = 0x08;
+// we typically ignore any errors matching this bitmask:
+const static ErrorBitfield kIgnorable_ErrorBitmask = kMissingExpectations_ErrorBitmask;
 
 using namespace skiagm;
 
 struct FailRec {
     SkString    fName;
     bool        fIsPixelError;
 
     FailRec() : fIsPixelError(false) {}
     FailRec(const SkString& name) : fName(name), fIsPixelError(false) {}
 };
@@ skipping 141 matching lines @@
         SkBitmap copy;
         bitmap.copyTo(&copy, SkBitmap::kARGB_8888_Config);
         return SkImageEncoder::EncodeFile(path.c_str(), copy,
                                           SkImageEncoder::kPNG_Type, 100);
     }
 
     // Records an error in fFailedTests, if we want to record errors
     // of this type.
     void RecordError(ErrorBitfield errorType, const SkString& name,
                      const char renderModeDescriptor []) {
-        bool isPixelError;
-        switch (errorType) {
-        case ERROR_NONE:
+        // The common case: no error means nothing to record.
+        if (kEmptyErrorBitfield == errorType) {
             return;
-        case ERROR_READING_REFERENCE_IMAGE:
+        }
+
+        // If only certain error type(s) were reported, we know we can ignore them.
+        if (errorType == (errorType & kIgnorable_ErrorBitmask)) {
             return;
-        case ERROR_IMAGE_MISMATCH:
-            isPixelError = true;
-            break;
-        default:
-            isPixelError = false;
-            break;
         }
 
         FailRec& rec = fFailedTests.push_back(make_name(
             name.c_str(), renderModeDescriptor));
-        rec.fIsPixelError = isPixelError;
+        rec.fIsPixelError = (errorType & kImageMismatch_ErrorBitmask);
     }
 
     // List contents of fFailedTests via SkDebug.
     void ListErrors() {
         for (int i = 0; i < fFailedTests.count(); ++i) {
             if (fFailedTests[i].fIsPixelError) {
                 SkDebugf("\t\t%s pixel_error\n", fFailedTests[i].fName.c_str());
             } else {
                 SkDebugf("\t\t%s\n", fFailedTests[i].fName.c_str());
             }
@@ skipping 119 matching lines @@
                 canvas.reset(new SkDeferredCanvas(device));
             } else {
                 canvas.reset(new SkCanvas(device));
             }
             invokeGM(gm, canvas, false, deferred);
             canvas->flush();
         }
 #if SK_SUPPORT_GPU
         else {  // GPU
             if (NULL == context) {
-                return ERROR_NO_GPU_CONTEXT;
+                return kNoGpuContext_ErrorBitmask;
             }
             SkAutoTUnref<SkDevice> device(new SkGpuDevice(context, rt));
             if (deferred) {
                 canvas.reset(new SkDeferredCanvas(device));
             } else {
                 canvas.reset(new SkCanvas(device));
             }
             invokeGM(gm, canvas, false, deferred);
             // the device is as large as the current rendertarget, so
             // we explicitly only readback the amount we expect (in
             // size) overwrite our previous allocation
             bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,
                               size.fHeight);
             canvas->readPixels(bitmap, 0, 0);
         }
 #endif
         complete_bitmap(bitmap);
-        return ERROR_NONE;
+        return kEmptyErrorBitfield;
     }
 
     static void generate_image_from_picture(GM* gm, const ConfigData& gRec,
                                             SkPicture* pict, SkBitmap* bitmap,
                                             SkScalar scale = SK_Scalar1) {
         SkISize size = gm->getISize();
         setup_bitmap(gRec, size, bitmap);
         SkCanvas canvas(*bitmap);
         installFilter(&canvas);
         canvas.scale(scale, scale);
@@ skipping 73 matching lines @@
             path = make_filename(writePath, renderModeDescriptor, name.c_str(),
                                  "pdf");
             success = write_document(path, *document);
         }
         if (kXPS_Backend == gRec.fBackend) {
             path = make_filename(writePath, renderModeDescriptor, name.c_str(),
                                  "xps");
             success = write_document(path, *document);
         }
         if (success) {
-            return ERROR_NONE;
+            return kEmptyErrorBitfield;
         } else {
             fprintf(stderr, "FAILED to write %s\n", path.c_str());
-            RecordError(ERROR_WRITING_REFERENCE_IMAGE, name,
+            RecordError(kWritingReferenceImage_ErrorBitmask, name,
                         renderModeDescriptor);
-            return ERROR_WRITING_REFERENCE_IMAGE;
+            return kWritingReferenceImage_ErrorBitmask;
         }
     }
 
     /**
      * Log more detail about the mistmatch between expectedBitmap and
      * actualBitmap.
      */
     void report_bitmap_diffs(const SkBitmap& expectedBitmap, const SkBitmap& actualBitmap,
                              const char *testName) {
         const int expectedWidth = expectedBitmap.width();
@@ skipping 39 matching lines @@
                                                  (int)SkGetPackedA32(actualPixel)));
                 }
             }
         }
         SkDebugf("---- %s: %d (of %d) differing pixels, max per-channel mismatch"
                  " R=%d G=%d B=%d A=%d\n",
                  testName, differingPixels, width*height, errR, errG, errB, errA);
     }
 
     /**
-     * Compares actual checksum to expectations.
-     * Returns ERROR_NONE if they match, or some particular error code otherwise
+     * Compares actual checksum to expectations.  Returns
+     * kEmptyErrorBitfield if they match, or some combination of
+     * _ErrorBitmask values otherwise.
      *
      * If fMismatchPath has been set, and there are pixel diffs, then the
      * actual bitmap will be written out to a file within fMismatchPath.
      *
      * @param expectations what expectations to compare actualBitmap against
      * @param actualBitmap the image we actually generated
      * @param baseNameString name of test without renderModeDescriptor added
      * @param renderModeDescriptor e.g., "-rtree", "-deferred"
      * @param addToJsonSummary whether to add these results (both actual and
      *        expected) to the JSON summary
      *
      * TODO: For now, addToJsonSummary is only set to true within
      * compare_test_results_to_stored_expectations(), so results of our
      * in-memory comparisons (Rtree vs regular, etc.) are not written to the
      * JSON summary.  We may wish to change that.
      */
     ErrorBitfield compare_to_expectations(Expectations expectations,
                                           const SkBitmap& actualBitmap,
                                           const SkString& baseNameString,
                                           const char renderModeDescriptor[],
                                           bool addToJsonSummary=false) {
         ErrorBitfield retval;
         Checksum actualChecksum = SkBitmapChecksummer::Compute64(actualBitmap);
         SkString completeNameString = baseNameString;
         completeNameString.append(renderModeDescriptor);
         const char* completeName = completeNameString.c_str();
 
         if (expectations.empty()) {
-            retval = ERROR_READING_REFERENCE_IMAGE;
+            retval = kMissingExpectations_ErrorBitmask;
         } else if (expectations.match(actualChecksum)) {
-            retval = ERROR_NONE;
+            retval = kEmptyErrorBitfield;
         } else {
-            retval = ERROR_IMAGE_MISMATCH;
+            retval = kImageMismatch_ErrorBitmask;
 
             // Write out the "actuals" for any mismatches, if we have
             // been directed to do so.
             if (fMismatchPath) {
                 SkString path =
                     make_filename(fMismatchPath, renderModeDescriptor,
                                   baseNameString.c_str(), "png");
                 write_bitmap(path, actualBitmap);
             }
 
@@ skipping 20 matching lines @@
      * Add this result to the appropriate JSON collection of actual results,
      * depending on status.
      */
     void add_actual_results_to_json_summary(const char testName[],
                                             Checksum actualChecksum,
                                             ErrorBitfield result,
                                             bool ignoreFailure) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_AnyStatus_Checksum] =
             asJsonValue(actualChecksum);
-        if (ERROR_NONE == result) {
+        if (kEmptyErrorBitfield == result) {
             this->fJsonActualResults_Succeeded[testName] = actualResults;
         } else {
             if (ignoreFailure) {
                 // TODO: Once we have added the ability to compare
                 // actual results against expectations in a JSON file
                 // (where we can set ignore-failure to either true or
                 // false), add test cases that exercise ignored
-                // failures (both for ERROR_READING_REFERENCE_IMAGE
-                // and ERROR_IMAGE_MISMATCH).
+                // failures (both for kMissingExpectations_ErrorBitmask
+                // and kImageMismatch_ErrorBitmask).
                 this->fJsonActualResults_FailureIgnored[testName] =
                     actualResults;
             } else {
-                switch(result) {
-                case ERROR_READING_REFERENCE_IMAGE:
+                if (result & kMissingExpectations_ErrorBitmask) {
                     // TODO: What about the case where there IS an
                     // expected image checksum, but that gm test
                     // doesn't actually run?  For now, those cases
                     // will always be ignored, because gm only looks
                     // at expectations that correspond to gm tests
                     // that were actually run.
                     //
                     // Once we have the ability to express
                     // expectations as a JSON file, we should fix this
                     // (and add a test case for which an expectation
                     // is given but the test is never run).
                     this->fJsonActualResults_NoComparison[testName] =
                         actualResults;
-                    break;
-                case ERROR_IMAGE_MISMATCH:
+                }
+                if (result & kImageMismatch_ErrorBitmask) {
                     this->fJsonActualResults_Failed[testName] = actualResults;
-                    break;
-                default:
-                    fprintf(stderr, "encountered unexpected result %d\n",
-                            result);
-                    SkDEBUGFAIL("encountered unexpected result");
-                    break;
                 }
             }
         }
     }
 
     /**
      * Add this test to the JSON collection of expected results.
      */
     void add_expected_results_to_json_summary(const char testName[],
                                               Expectations expectations) {
@@ skipping 16 matching lines @@
      * @param writePath unless this is NULL, write out actual images into this
      *        directory
      * @param actualBitmap bitmap generated by this run
      * @param pdf
      */
     ErrorBitfield compare_test_results_to_stored_expectations(
         GM* gm, const ConfigData& gRec, const char writePath[],
         SkBitmap& actualBitmap, SkDynamicMemoryWStream* pdf) {
 
         SkString name = make_name(gm->shortName(), gRec.fName);
-        ErrorBitfield retval = ERROR_NONE;
+        ErrorBitfield retval = kEmptyErrorBitfield;
 
         ExpectationsSource *expectationsSource =
             this->fExpectationsSource.get();
         if (expectationsSource && (gRec.fFlags & kRead_ConfigFlag)) {
             /*
              * Get the expected results for this test, as one or more allowed
              * checksums. The current implementation of expectationsSource
              * get this by computing the checksum of a single PNG file on disk.
              *
              * TODO(epoger): This relies on the fact that
              * force_all_opaque() was called on the bitmap before it
              * was written to disk as a PNG in the first place. If
              * not, the checksum returned here may not match the
              * checksum of actualBitmap, which *has* been run through
              * force_all_opaque().
              * See comments above complete_bitmap() for more detail.
              */
             Expectations expectations = expectationsSource->get(name.c_str());
             retval |= compare_to_expectations(expectations, actualBitmap,
                                               name, "", true);
         } else {
             // If we are running without expectations, we still want to
             // record the actual results.
             Checksum actualChecksum =
                 SkBitmapChecksummer::Compute64(actualBitmap);
             add_actual_results_to_json_summary(name.c_str(), actualChecksum,
-                                               ERROR_READING_REFERENCE_IMAGE,
+                                               kMissingExpectations_ErrorBitmask,
                                                false);
         }
 
         // TODO: Consider moving this into compare_to_expectations(),
         // similar to fMismatchPath... for now, we don't do that, because
         // we don't want to write out the actual bitmaps for all
         // renderModes of all tests!  That would be a lot of files.
         if (writePath && (gRec.fFlags & kWrite_ConfigFlag)) {
             retval |= write_reference_image(gRec, writePath, "",
                                             name, actualBitmap, pdf);
@@ skipping 79 matching lines @@
                                GrContext* context,
                                GrRenderTarget* rt,
                                SkBitmap* bitmap) {
         SkDynamicMemoryWStream document;
 
         if (gRec.fBackend == kRaster_Backend ||
             gRec.fBackend == kGPU_Backend) {
             // Early exit if we can't generate the image.
             ErrorBitfield errors = generate_image(gm, gRec, context, rt, bitmap,
                                                   false);
-            if (ERROR_NONE != errors) {
+            if (kEmptyErrorBitfield != errors) {
                 // TODO: Add a test to exercise what the stdout and
                 // JSON look like if we get an "early error" while
                 // trying to generate the image.
                 return errors;
             }
         } else if (gRec.fBackend == kPDF_Backend) {
             generate_pdf(gm, document);
 #if CAN_IMAGE_PDF
             SkAutoDataUnref data(document.copyToData());
             SkMemoryStream stream(data->data(), data->size());
@@ skipping 12 matching lines @@
                                         GrContext* context,
                                         GrRenderTarget* rt) {
         SkDynamicMemoryWStream document;
 
         if (gRec.fBackend == kRaster_Backend ||
             gRec.fBackend == kGPU_Backend) {
             SkBitmap bitmap;
             // Early exit if we can't generate the image, but this is
             // expected in some cases, so don't report a test failure.
             if (!generate_image(gm, gRec, context, rt, &bitmap, true)) {
-                return ERROR_NONE;
+                return kEmptyErrorBitfield;
             }
             return compare_test_results_to_reference_bitmap(
                 gm, gRec, "-deferred", bitmap, &referenceBitmap);
         }
-        return ERROR_NONE;
+        return kEmptyErrorBitfield;
     }
 
     ErrorBitfield test_pipe_playback(GM* gm,
                                      const ConfigData& gRec,
                                      const SkBitmap& referenceBitmap) {
-        ErrorBitfield errors = ERROR_NONE;
+        ErrorBitfield errors = kEmptyErrorBitfield;
         for (size_t i = 0; i < SK_ARRAY_COUNT(gPipeWritingFlagCombos); ++i) {
             SkBitmap bitmap;
             SkISize size = gm->getISize();
             setup_bitmap(gRec, size, &bitmap);
             SkCanvas canvas(bitmap);
             PipeController pipeController(&canvas);
             SkGPipeWriter writer;
             SkCanvas* pipeCanvas = writer.startRecording(
               &pipeController, gPipeWritingFlagCombos[i].flags);
             invokeGM(gm, pipeCanvas, false, false);
             complete_bitmap(&bitmap);
             writer.endRecording();
             SkString string("-pipe");
             string.append(gPipeWritingFlagCombos[i].name);
             errors |= compare_test_results_to_reference_bitmap(
                 gm, gRec, string.c_str(), bitmap, &referenceBitmap);
-            if (errors != ERROR_NONE) {
+            if (errors != kEmptyErrorBitfield) {
                 break;
             }
         }
         return errors;
     }
 
     ErrorBitfield test_tiled_pipe_playback(
       GM* gm, const ConfigData& gRec, const SkBitmap& referenceBitmap) {
-        ErrorBitfield errors = ERROR_NONE;
+        ErrorBitfield errors = kEmptyErrorBitfield;
         for (size_t i = 0; i < SK_ARRAY_COUNT(gPipeWritingFlagCombos); ++i) {
             SkBitmap bitmap;
             SkISize size = gm->getISize();
             setup_bitmap(gRec, size, &bitmap);
             SkCanvas canvas(bitmap);
             TiledPipeController pipeController(bitmap);
             SkGPipeWriter writer;
             SkCanvas* pipeCanvas = writer.startRecording(
               &pipeController, gPipeWritingFlagCombos[i].flags);
             invokeGM(gm, pipeCanvas, false, false);
             complete_bitmap(&bitmap);
             writer.endRecording();
             SkString string("-tiled pipe");
             string.append(gPipeWritingFlagCombos[i].name);
             errors |= compare_test_results_to_reference_bitmap(
                 gm, gRec, string.c_str(), bitmap, &referenceBitmap);
-            if (errors != ERROR_NONE) {
+            if (errors != kEmptyErrorBitfield) {
                 break;
             }
         }
         return errors;
     }
 
     //
     // member variables.
     // They are public for now, to allow easier setting by tool_main().
     //
@@ skipping 494 matching lines @@
         const char* shortName = gm->shortName();
         if (skip_name(fMatches, shortName)) {
             SkDELETE(gm);
             continue;
         }
 
         SkISize size = gm->getISize();
         SkDebugf("%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
                  size.width(), size.height());
 
-        ErrorBitfield testErrors = ERROR_NONE;
+        ErrorBitfield testErrors = kEmptyErrorBitfield;
         uint32_t gmFlags = gm->getFlags();
 
         for (int i = 0; i < configs.count(); i++) {
             ConfigData config = gRec[configs[i]];
 
             // Skip any tests that we don't even need to try.
             if ((kPDF_Backend == config.fBackend) &&
                 (!doPDF || (gmFlags & GM::kSkipPDF_Flag)))
                 {
                     continue;
                 }
             if ((gmFlags & GM::kSkip565_Flag) &&
                 (kRaster_Backend == config.fBackend) &&
                 (SkBitmap::kRGB_565_Config == config.fConfig)) {
                 continue;
             }
 
             // Now we know that we want to run this test and record its
             // success or failure.
-            ErrorBitfield renderErrors = ERROR_NONE;
+            ErrorBitfield renderErrors = kEmptyErrorBitfield;
             GrRenderTarget* renderTarget = NULL;
 #if SK_SUPPORT_GPU
             SkAutoTUnref<GrRenderTarget> rt;
             AutoResetGr autogr;
-            if ((ERROR_NONE == renderErrors) &&
+            if ((kEmptyErrorBitfield == renderErrors) &&
                 kGPU_Backend == config.fBackend) {
                 GrContext* gr = grFactory->get(config.fGLContextType);
                 bool grSuccess = false;
                 if (gr) {
                     // create a render target to back the device
                     GrTextureDesc desc;
                     desc.fConfig = kSkia8888_GrPixelConfig;
                     desc.fFlags = kRenderTarget_GrTextureFlagBit;
                     desc.fWidth = gm->getISize().width();
                     desc.fHeight = gm->getISize().height();
                     desc.fSampleCnt = config.fSampleCnt;
                     GrTexture* tex = gr->createUncachedTexture(desc, NULL, 0);
                     if (tex) {
                         rt.reset(tex->asRenderTarget());
                         rt.get()->ref();
                         tex->unref();
                         autogr.set(gr);
                         renderTarget = rt.get();
                         grSuccess = NULL != renderTarget;
                     }
                 }
                 if (!grSuccess) {
-                    renderErrors |= ERROR_NO_GPU_CONTEXT;
+                    renderErrors |= kNoGpuContext_ErrorBitmask;
                 }
             }
 #endif
 
             SkBitmap comparisonBitmap;
 
-            if (ERROR_NONE == renderErrors) {
+            if (kEmptyErrorBitfield == renderErrors) {
                 renderErrors |= gmmain.test_drawing(gm, config, writePath,
                                                     GetGr(),
                                                     renderTarget,
                                                     &comparisonBitmap);
             }
 
             if (doDeferred && !renderErrors &&
                 (kGPU_Backend == config.fBackend ||
                  kRaster_Backend == config.fBackend)) {
                 renderErrors |= gmmain.test_deferred_drawing(gm, config,
                                                              comparisonBitmap,
                                                              GetGr(),
                                                              renderTarget);
             }
 
             testErrors |= renderErrors;
         }
 
         SkBitmap comparisonBitmap;
         const ConfigData compareConfig =
             { SkBitmap::kARGB_8888_Config, kRaster_Backend, kDontCare_GLContextType, 0, kRW_ConfigFlag, "comparison" };
         testErrors |= gmmain.generate_image(gm, compareConfig, NULL, NULL, &comparisonBitmap, false);
 
         // run the picture centric GM steps
         if (!(gmFlags & GM::kSkipPicture_Flag)) {
 
-            ErrorBitfield pictErrors = ERROR_NONE;
+            ErrorBitfield pictErrors = kEmptyErrorBitfield;
 
             //SkAutoTUnref<SkPicture> pict(generate_new_picture(gm));
             SkPicture* pict = gmmain.generate_new_picture(gm, kNone_BbhType, 0);
             SkAutoUnref aur(pict);
 
-            if ((ERROR_NONE == testErrors) && doReplay) {
+            if ((kEmptyErrorBitfield == testErrors) && doReplay) {
                 SkBitmap bitmap;
                 gmmain.generate_image_from_picture(gm, compareConfig, pict,
                                                    &bitmap);
                 pictErrors |= gmmain.compare_test_results_to_reference_bitmap(
                     gm, compareConfig, "-replay", bitmap, &comparisonBitmap);
             }
 
-            if ((ERROR_NONE == testErrors) &&
-                (ERROR_NONE == pictErrors) &&
+            if ((kEmptyErrorBitfield == testErrors) &&
+                (kEmptyErrorBitfield == pictErrors) &&
                 doSerialize) {
                 SkPicture* repict = gmmain.stream_to_new_picture(*pict);
                 SkAutoUnref aurr(repict);
 
                 SkBitmap bitmap;
                 gmmain.generate_image_from_picture(gm, compareConfig, repict,
                                                    &bitmap);
                 pictErrors |= gmmain.compare_test_results_to_reference_bitmap(
                     gm, compareConfig, "-serialize", bitmap, &comparisonBitmap);
             }
@@ skipping 47 matching lines @@
                 }
                 testErrors |= gmmain.compare_test_results_to_reference_bitmap(
                     gm, compareConfig, suffix.c_str(), bitmap,
                     &comparisonBitmap);
             }
         }
 
         // run the pipe centric GM steps
         if (!(gmFlags & GM::kSkipPipe_Flag)) {
 
-            ErrorBitfield pipeErrors = ERROR_NONE;
+            ErrorBitfield pipeErrors = kEmptyErrorBitfield;
 
-            if ((ERROR_NONE == testErrors) && doPipe) {
+            if ((kEmptyErrorBitfield == testErrors) && doPipe) {
                 pipeErrors |= gmmain.test_pipe_playback(gm, compareConfig,
                                                         comparisonBitmap);
             }
 
-            if ((ERROR_NONE == testErrors) &&
-                (ERROR_NONE == pipeErrors) &&
+            if ((kEmptyErrorBitfield == testErrors) &&
+                (kEmptyErrorBitfield == pipeErrors) &&
                 doTiledPipe && !(gmFlags & GM::kSkipTiled_Flag)) {
                 pipeErrors |= gmmain.test_tiled_pipe_playback(gm, compareConfig,
                                                               comparisonBitmap);
             }
 
             testErrors |= pipeErrors;
         }
 
         // Update overall results.
         // We only tabulate the particular error types that we currently
         // care about (e.g., missing reference images). Later on, if we
         // want to also tabulate other error types, we can do so.
         testsRun++;
         if (!gmmain.fExpectationsSource.get() ||
-            (ERROR_READING_REFERENCE_IMAGE & testErrors)) {
+            (kMissingExpectations_ErrorBitmask & testErrors)) {
             testsMissingReferenceImages++;
         }
-        if (ERROR_NONE == testErrors || ERROR_READING_REFERENCE_IMAGE == testErrors) {
+        if (testErrors == (testErrors & kIgnorable_ErrorBitmask)) {
             testsPassed++;
         } else {
             testsFailed++;
         }
 
         SkDELETE(gm);
     }
     SkDebugf("Ran %d tests: %d passed, %d failed, %d missing reference images\n",
              testsRun, testsPassed, testsFailed, testsMissingReferenceImages);
     gmmain.ListErrors();
@@ skipping 36 matching lines @@
     SkGraphics::Term();
 
     return (0 == testsFailed) ? 0 : -1;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif