Add path utils, plus a test for it.

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 "SkBitmapHasher.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
+#include "SkOSPathUtils.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTemplates.h"
 
 DEFINE_string(createExpectationsPath, "", "Path to write JSON expectations.");
 DEFINE_string2(readPath, r, "", "Folder(s) and files to decode images. Required.");
 DEFINE_string(readExpectationsPath, "", "Path to read JSON expectations from.");
 DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 DEFINE_bool(reencode, true, "Reencode the images to test encoding.");
@@ skipping 35 matching lines @@
 
 static SkImageDecoder::Format guess_format_from_suffix(const char suffix[]) {
     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;
 }
 
-/**
- *  Return the name of the file, ignoring the directory structure.
- *  Does not create a new string.
- *  @param fullPath Full path to the file.
- *  @return string The basename of the file - anything beyond the final slash, or the full name
- *      if there is no slash.
- *  TODO: Might this be useful as a utility function in SkOSFile? Would it be more appropriate to
- *  create a new string?
- */
-static const char* SkBasename(const char* fullPath) {
-    const char* filename = strrchr(fullPath, SkPATH_SEPARATOR);
-    if (NULL == filename || *++filename == '\0') {
-        filename = fullPath;
-    }
-    return filename;
-}
-
 static void make_outname(SkString* dst, const char outDir[], const char src[],
                          const char suffix[]) {
     const char* basename = SkBasename(src);
-    dst->set(skiagm::SkPathJoin(outDir, basename));
+    dst->set(SkPathJoin(outDir, basename));
     if (!dst->endsWith(suffix)) {
         const char* cstyleDst = dst->c_str();
         const char* dot = strrchr(cstyleDst, '.');
         if (dot != NULL) {
             int32_t index = SkToS32(dot - cstyleDst);
             dst->remove(index, dst->size() - index);
         }
         dst->append(suffix);
     }
 }
@@ skipping 162 matching lines @@
 static bool write_subset(const char* writePath, const char* filename, const char* subsetDim,
                           SkBitmap* bitmapFromDecodeSubset, SkIRect rect,
                           const SkBitmap& originalBitmap) {
     // All parameters must be valid.
     SkASSERT(writePath != NULL);
     SkASSERT(filename != NULL);
     SkASSERT(subsetDim != NULL);
     SkASSERT(bitmapFromDecodeSubset != NULL);
 
     // Create a subdirectory to hold the results of decodeSubset.
-    // TODO: Move SkPathJoin into SkOSFile.h
-    SkString dir = skiagm::SkPathJoin(writePath, "subsets");
+    SkString dir = SkPathJoin(writePath, "subsets");
     if (!sk_mkdir(dir.c_str())) {
         gFailedSubsetDecodes.push_back().printf("Successfully decoded %s from %s, but failed to "
                                                 "create a directory to write to.", subsetDim,
                                                  filename);
         return false;
     }
 
     // Write the subset to a file whose name includes the dimensions.
     SkString suffix = SkStringPrintf("_%s.png", subsetDim);
     SkString outPath;
     make_outname(&outPath, dir.c_str(), filename, suffix.c_str());
     SkAssertResult(write_bitmap(outPath.c_str(), bitmapFromDecodeSubset));
     gSuccessfulSubsetDecodes.push_back().printf("\twrote %s", outPath.c_str());
 
     // 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 %s from %s, but failed to "
                                                 "extract a similar subset for comparison.",
                                                 subsetDim, filename);
         return false;
     }
 
-    SkString dirExtracted = skiagm::SkPathJoin(writePath, "extracted");
+    SkString dirExtracted = SkPathJoin(writePath, "extracted");
     if (!sk_mkdir(dirExtracted.c_str())) {
         gFailedSubsetDecodes.push_back().printf("Successfully decoded %s from %s, but failed to "
                                                 "create a directory for extractSubset comparison.",
                                                 subsetDim, filename);
         return false;
     }
 
     make_outname(&outPath, dirExtracted.c_str(), filename, suffix.c_str());
     SkAssertResult(write_bitmap(outPath.c_str(), &extractedSubset));
     return true;
@@ skipping 252 matching lines @@
     }
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif