Cleanup: Rename SkOSPath functions.

tools/skimage_main.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 "gm_expectations.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 62 matching lines @@
     for (size_t i = 0; i < SK_ARRAY_COUNT(gFormats); i++) {
         if (strcmp(suffix, gFormats[i].fSuffix) == 0) {
             return gFormats[i].fFormat;
         }
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static void make_outname(SkString* dst, const char outDir[], const char src[],
                          const char suffix[]) {
-    SkString basename = SkOSPath::SkBasename(src);
-    dst->set(SkOSPath::SkPathJoin(outDir, basename.c_str()));
+    SkString basename = SkOSPath::Basename(src);
+    dst->set(SkOSPath::Join(outDir, basename.c_str()));
     dst->append(suffix);
 }
 
 // Store the names of the filenames to report later which ones failed, succeeded, and were
 // invalid.
 // FIXME: Add more arrays, for more specific types of errors, and make the output simpler.
 // If each array holds one type of error, the output can change from:
 //
 // Failures:
 //      <image> failed for such and such reason
@@ skipping 36 matching lines @@
  *  If false, the final image will be written out to:
  *      outDir/src.png
  *  The function returns whether the file was successfully written.
  */
 static bool write_bitmap(const char outDir[], const char src[],
                          const skiagm::BitmapAndDigest& bitmapAndDigest) {
     SkString filename;
     if (FLAGS_writeChecksumBasedFilenames) {
         // First create the directory for the hashtype.
         const SkString hashType = bitmapAndDigest.fDigest.getHashType();
-        const SkString hashDir = SkOSPath::SkPathJoin(outDir, hashType.c_str());
+        const SkString hashDir = SkOSPath::Join(outDir, hashType.c_str());
         if (!sk_mkdir(hashDir.c_str())) {
             return false;
         }
 
         // Now create the name of the folder specific to this image.
-        SkString basename = SkOSPath::SkBasename(src);
-        const SkString imageDir = SkOSPath::SkPathJoin(hashDir.c_str(), basename.c_str());
+        SkString basename = SkOSPath::Basename(src);
+        const SkString imageDir = SkOSPath::Join(hashDir.c_str(), basename.c_str());
         if (!sk_mkdir(imageDir.c_str())) {
             return false;
         }
 
         // Name the file <digest>.png
         SkString checksumBasedName = bitmapAndDigest.fDigest.getDigestValue();
         checksumBasedName.append(".png");
 
-        filename = SkOSPath::SkPathJoin(imageDir.c_str(), checksumBasedName.c_str());
+        filename = SkOSPath::Join(imageDir.c_str(), checksumBasedName.c_str());
     } else {
         make_outname(&filename, outDir, src, ".png");
     }
 
     const SkBitmap& bm = bitmapAndDigest.fBitmap;
     if (SkImageEncoder::EncodeFile(filename.c_str(), bm, SkImageEncoder::kPNG_Type, 100)) {
         return true;
     }
 
     if (bm.colorType() == kN32_SkColorType) {
@@ skipping 183 matching lines @@
                           const skiagm::BitmapAndDigest bitmapAndDigestFromDecodeSubset,
                           SkIRect rect, const SkBitmap& originalBitmap) {
     // All parameters must be valid.
     SkASSERT(writePath != NULL);
 
     SkString subsetPath;
     if (FLAGS_writeChecksumBasedFilenames) {
         subsetPath.set(writePath);
     } else {
         // Create a subdirectory to hold the results of decodeSubset.
-        subsetPath = SkOSPath::SkPathJoin(writePath, "subsets");
+        subsetPath = SkOSPath::Join(writePath, "subsets");
         if (!sk_mkdir(subsetPath.c_str())) {
             gFailedSubsetDecodes.push_back().printf("Successfully decoded subset %s, but "
                                                     "failed to create a directory to write to.",
                                                      subsetName.c_str());
             return false;
         }
     }
     SkAssertResult(write_bitmap(subsetPath.c_str(), subsetName.c_str(),
                                 bitmapAndDigestFromDecodeSubset));
     gSuccessfulSubsetDecodes.push_back().printf("\twrote %s", subsetName.c_str());
 
     if (!FLAGS_writeChecksumBasedFilenames) {
         // FIXME: The goal of extracting the subset is for visual comparison/using skdiff/skpdiff.
         // Currently disabling for writeChecksumBasedFilenames since it will be trickier to
         // determine which files to compare.
 
         // Also use extractSubset from the original for visual comparison.
         // Write the result to a file in a separate subdirectory.
         SkBitmap extractedSubset;
         if (!originalBitmap.extractSubset(&extractedSubset, rect)) {
             gFailedSubsetDecodes.push_back().printf("Successfully decoded subset %s, but failed "
                                                     "to extract a similar subset for comparison.",
                                                     subsetName.c_str());
             return false;
         }
 
-        SkString dirExtracted = SkOSPath::SkPathJoin(writePath, "extracted");
+        SkString dirExtracted = SkOSPath::Join(writePath, "extracted");
         if (!sk_mkdir(dirExtracted.c_str())) {
             gFailedSubsetDecodes.push_back().printf("Successfully decoded subset%s, but failed "
                                                     "to create a directory for extractSubset "
                                                     "comparison.",
                                                     subsetName.c_str());
             return false;
         }
 
         skiagm::BitmapAndDigest bitmapAndDigestFromExtractSubset(extractedSubset);
         SkAssertResult(write_bitmap(dirExtracted.c_str(), subsetName.c_str(),
@@ skipping 96 matching lines @@
         return;
     }
 
     SkAutoTDelete<SkImageDecoder> ad(codec);
 
     codec->setSkipWritingZeroes(FLAGS_skip);
     codec->setSampleSize(FLAGS_sampleSize);
     stream.rewind();
 
     // Create a string representing just the filename itself, for use in json expectations.
-    SkString basename = SkOSPath::SkBasename(srcPath);
+    SkString basename = SkOSPath::Basename(srcPath);
     // Replace '_' with '-', so that the names can fit gm_json.py's IMAGE_FILENAME_PATTERN
     replace_char(&basename, '_', '-');
     // Replace '.' with '-', so the output filename can still retain the original file extension,
     // but still end up with only one '.', which denotes the actual extension of the final file.
     replace_char(&basename, '.', '-');
     const char* filename = basename.c_str();
 
     if (!codec->decode(&stream, &bitmap, gPrefColorType, SkImageDecoder::kDecodePixels_Mode)) {
         if (NULL != gJsonExpectations.get()) {
             const SkString name_config = create_json_key(filename);
@@ skipping 273 matching lines @@
             break;
         }
         if (sk_isdir(readPath)) {
             const char* dir = readPath;
             SkOSFile::Iter iter(dir);
             SkString filename;
             while (iter.next(&filename)) {
                 if (!is_image_file(filename.c_str())) {
                     continue;
                 }
-                SkString fullname = SkOSPath::SkPathJoin(dir, filename.c_str());
+                SkString fullname = SkOSPath::Join(dir, filename.c_str());
                 decodeFileAndWrite(fullname.c_str(), outDirPtr);
             }
         } else if (sk_exists(readPath) && is_image_file(readPath)) {
             decodeFileAndWrite(readPath, outDirPtr);
         }
     }
 
     if (!FLAGS_createExpectationsPath.isEmpty()) {
         // Use an empty value for everything besides expectations, since the reader only cares
         // about the expectations.
@@ skipping 24 matching lines @@
     print_strings("Known failures", gKnownFailures);
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif