fix multithread related crashes in skpdiff

tools/skpdiff/SkPMetric.cpp

 #include <cmath>
 
 #include "SkBitmap.h"
 #include "skpdiff_util.h"
 #include "SkPMetric.h"
 #include "SkPMetricUtil_generated.h"
 
 struct RGB {
     float r, g, b;
 };
@@ skipping 247 matching lines @@
         // As we move down, scroll the row pointers down with us
         for (int y = 0; y < matrixCount - 1; y++)
         {
             rowPtrs[y] = rowPtrs[y + 1];
         }
         rowPtrs[matrixCount - 1] += imageL->width;
         writeRow += imageL->width;
     }
 }
 
-static double pmetric(const ImageLAB* baselineLAB, const ImageLAB* testLAB, SkTDArray<SkIPoint>* poi) {
+static double pmetric(const ImageLAB* baselineLAB, const ImageLAB* testLAB, int* poiCount) {
+    SkASSERT(baselineLAB);
+    SkASSERT(testLAB);
+    SkASSERT(poiCount);
+
     int width = baselineLAB->width;
     int height = baselineLAB->height;
     int maxLevels = 0;
 
     // Calculates how many levels to make by how many times the image can be divided in two
     int smallerDimension = width < height ? width : height;
     for ( ; smallerDimension > 1; smallerDimension /= 2) {
         maxLevels++;
     }
 
@@ skipping 43 matching lines @@
         convolve(&scratchImageL, true, testL.getLayer(levelIndex));
     }
 
     // Compute F_freq - The elevation f
     for (int levelIndex = 0; levelIndex < maxLevels - 2; levelIndex++) {
         float cpd = cyclesPerDegree[levelIndex];
         thresholdFactorFrequency[levelIndex] = contrastSensitivityMax /
                                                contrast_sensitivity(cpd, 100.0f);
     }
 
-    int failures = 0;
     // Calculate F
     for (int y = 0; y < height; y++) {
         for (int x = 0; x < width; x++) {
             float lBaseline;
             float lTest;
             baselineL.getLayer(0)->readPixel(x, y, &lBaseline);
             testL.getLayer(0)->readPixel(x, y, &lTest);
 
             float avgLBaseline;
             float avgLTest;
@@ skipping 74 matching lines @@
                 }
                 colorScale *= colorScale;
 
                 if ((contrastA * contrastA + contrastB * contrastB) * colorScale > F)
                 {
                     isFailure = true;
                 }
             }
 
             if (isFailure) {
-                failures++;
-                poi->push()->set(x, y);
+                (*poiCount)++;
             }
         }
     }
 
     SkDELETE_ARRAY(cyclesPerDegree);
     SkDELETE_ARRAY(contrast);
     SkDELETE_ARRAY(thresholdFactorFrequency);
     SkDELETE_ARRAY(contrastSensitivityTable);
-    return 1.0 - (double)failures / (width * height);
+    return 1.0 - (double)(*poiCount) / (width * height);
 }
 
-const char* SkPMetric::getName() {
-    return "perceptual";
-}
-
-int SkPMetric::queueDiff(SkBitmap* baseline, SkBitmap* test) {
+bool SkPMetric::diff(SkBitmap* baseline, SkBitmap* test, bool computeMask, Result* result) const {
     double startTime = get_seconds();
-    int diffID = fQueuedDiffs.count();
-    QueuedDiff& diff = fQueuedDiffs.push_back();
-    diff.result = 0.0;
 
     // Ensure the images are comparable
     if (baseline->width() != test->width() || baseline->height() != test->height() ||
                     baseline->width() <= 0 || baseline->height() <= 0) {
-        diff.finished = true;
-        return diffID;
+        return false;
     }
 
     ImageLAB baselineLAB(baseline->width(), baseline->height());
     ImageLAB testLAB(baseline->width(), baseline->height());
 
     if (!bitmap_to_cielab(baseline, &baselineLAB) || !bitmap_to_cielab(test, &testLAB)) {
-        return diffID;
+        return true;
     }
 
-    diff.result = pmetric(&baselineLAB, &testLAB, &diff.poi);
+    result->poiCount = 0;
+    result->result = pmetric(&baselineLAB, &testLAB, &result->poiCount);
+    result->timeElapsed = get_seconds() - startTime;
 
-    SkDebugf("Time: %f\n", (get_seconds() - startTime));
-
-    return diffID;
+    return true;
 }
-
-
-void SkPMetric::deleteDiff(int id) {
-
-}
-
-bool SkPMetric::isFinished(int id) {
-    return fQueuedDiffs[id].finished;
-}
-
-double SkPMetric::getResult(int id) {
-    return fQueuedDiffs[id].result;
-}
-
-int SkPMetric::getPointsOfInterestCount(int id) {
-    return fQueuedDiffs[id].poi.count();
-}
-
-SkIPoint* SkPMetric::getPointsOfInterest(int id) {
-    return fQueuedDiffs[id].poi.begin();
-}