Cleanup: Rename SkOSPath functions.

tools/skpdiff/SkDiffContext.cpp

 /*
  * Copyright 2013 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 "SkImageDecoder.h"
 #include "SkOSFile.h"
@@ skipping 80 matching lines @@
         SkDebugf("Failed to load bitmap \"%s\"\n", testPath);
         return;
     }
 
     // Setup a record for this diff
     fRecordMutex.acquire();
     DiffRecord* newRecord = fRecords.addToHead(DiffRecord());
     fRecordMutex.release();
 
     // compute the common name
-    SkString baseName = SkOSPath::SkBasename(baselinePath);
-    SkString testName = SkOSPath::SkBasename(testPath);
+    SkString baseName = SkOSPath::Basename(baselinePath);
+    SkString testName = SkOSPath::Basename(testPath);
     newRecord->fCommonName = get_common_prefix(baseName, testName);
 
     newRecord->fBaselinePath = baselinePath;
     newRecord->fTestPath = testPath;
     newRecord->fSize = SkISize::Make(baselineBitmap.width(), baselineBitmap.height());
 
     // only generate diff images if we have a place to store them
     SkImageDiffer::BitmapsToCreate bitmapsToCreate;
     bitmapsToCreate.alphaMask = !fAlphaMaskDir.isEmpty();
     bitmapsToCreate.rgbDiff = !fRgbDiffDir.isEmpty();
@@ skipping 14 matching lines @@
             // report more detail when it fails to compare two images')
             diffData.fResult.result = -1;
             continue;
         }
 
         if (bitmapsToCreate.alphaMask
                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
                 && !diffData.fResult.poiAlphaMask.empty()
                 && !newRecord->fCommonName.isEmpty()) {
 
-            newRecord->fAlphaMaskPath = SkOSPath::SkPathJoin(fAlphaMaskDir.c_str(),
-                                                             newRecord->fCommonName.c_str());
+            newRecord->fAlphaMaskPath = SkOSPath::Join(fAlphaMaskDir.c_str(),
+                                                       newRecord->fCommonName.c_str());
 
             // compute the image diff and output it
             SkBitmap copy;
             diffData.fResult.poiAlphaMask.copyTo(&copy, kN32_SkColorType);
             SkImageEncoder::EncodeFile(newRecord->fAlphaMaskPath.c_str(), copy,
                                        SkImageEncoder::kPNG_Type, 100);
 
             // cleanup the existing bitmap to free up resources;
             diffData.fResult.poiAlphaMask.reset();
 
             bitmapsToCreate.alphaMask = false;
         }
 
         if (bitmapsToCreate.rgbDiff
                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
                 && !diffData.fResult.rgbDiffBitmap.empty()
                 && !newRecord->fCommonName.isEmpty()) {
             // TODO(djsollen): Rather than taking the max r/g/b diffs that come back from
             // a particular differ and storing them as toplevel fields within
             // newRecord, we should extend outputRecords() to report optional
             // fields for each differ (not just "result" and "pointsOfInterest").
             // See http://skbug.com/2712 ('allow skpdiff to report different sets
             // of result fields for different comparison algorithms')
             newRecord->fMaxRedDiff = diffData.fResult.maxRedDiff;
             newRecord->fMaxGreenDiff = diffData.fResult.maxGreenDiff;
             newRecord->fMaxBlueDiff = diffData.fResult.maxBlueDiff;
 
-            newRecord->fRgbDiffPath = SkOSPath::SkPathJoin(fRgbDiffDir.c_str(),
-                                                           newRecord->fCommonName.c_str());
+            newRecord->fRgbDiffPath = SkOSPath::Join(fRgbDiffDir.c_str(),
+                                                     newRecord->fCommonName.c_str());
             SkImageEncoder::EncodeFile(newRecord->fRgbDiffPath.c_str(),
                                        diffData.fResult.rgbDiffBitmap,
                                        SkImageEncoder::kPNG_Type, 100);
             diffData.fResult.rgbDiffBitmap.reset();
             bitmapsToCreate.rgbDiff = false;
         }
 
         if (bitmapsToCreate.whiteDiff
                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
                 && !diffData.fResult.whiteDiffBitmap.empty()
                 && !newRecord->fCommonName.isEmpty()) {
-            newRecord->fWhiteDiffPath = SkOSPath::SkPathJoin(fWhiteDiffDir.c_str(),
-                                                             newRecord->fCommonName.c_str());
+            newRecord->fWhiteDiffPath = SkOSPath::Join(fWhiteDiffDir.c_str(),
+                                                       newRecord->fCommonName.c_str());
             SkImageEncoder::EncodeFile(newRecord->fWhiteDiffPath.c_str(),
                                        diffData.fResult.whiteDiffBitmap,
                                        SkImageEncoder::kPNG_Type, 100);
             diffData.fResult.whiteDiffBitmap.reset();
             bitmapsToCreate.whiteDiff = false;
         }
     }
 }
 
 class SkThreadedDiff : public SkRunnable {
@@ skipping 25 matching lines @@
     }
 
     SkThreadPool threadPool(fThreadCount);
     SkTArray<SkThreadedDiff> runnableDiffs;
     runnableDiffs.reset(baselineEntries.count());
 
     for (int x = 0; x < baselineEntries.count(); x++) {
         const char* baseFilename = baselineEntries[x].c_str();
 
         // Find the real location of each file to compare
-        SkString baselineFile = SkOSPath::SkPathJoin(baselinePath, baseFilename);
-        SkString testFile = SkOSPath::SkPathJoin(testPath, baseFilename);
+        SkString baselineFile = SkOSPath::Join(baselinePath, baseFilename);
+        SkString testFile = SkOSPath::Join(testPath, baseFilename);
 
         // Check that the test file exists and is a file
         if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) {
             // Queue up the comparison with the differ
             runnableDiffs[x].setup(this, baselineFile, testFile);
             threadPool.add(&runnableDiffs[x]);
         } else {
             SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str());
         }
     }
@@ skipping 195 matching lines @@
         for (int i = 0; i < cntColumns; i++) {
             SkString str;
             str.printf(", %f", values[i]);
             stream.writeText(str.c_str());
         }
         stream.writeText("\n");
 
         currentRecord = iter2.next();
     }
 }