Revert "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 "SkColorPriv.h"
@@ skipping 51 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[]) {
-    SkString basename = SkOSPath::SkBasename(src);
-    dst->set(SkOSPath::SkPathJoin(outDir, basename.c_str()));
+    const char* basename = SkBasename(src);
+    dst->set(skiagm::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.
-    SkString dir = SkOSPath::SkPathJoin(writePath, "subsets");
+    // TODO: Move SkPathJoin into SkOSFile.h
+    SkString dir = skiagm::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 = SkOSPath::SkPathJoin(writePath, "extracted");
+    SkString dirExtracted = skiagm::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 16 matching lines @@
     SkAutoTDelete<SkImageDecoder> ad(codec);
 
     stream.rewind();
     if (!codec->decode(&stream, &bitmap, SkBitmap::kARGB_8888_Config,
                        SkImageDecoder::kDecodePixels_Mode)) {
         gDecodeFailures.push_back().set(srcPath);
         return;
     }
 
     // Create a string representing just the filename itself, for use in json expectations.
-    SkString basename = SkOSPath::SkBasename(srcPath);
-    const char* filename = basename.c_str();
+    const char* filename = SkBasename(srcPath);
 
     if (compare_to_expectations_if_necessary(bitmap, filename, &gDecodeFailures)) {
         gSuccessfulDecodes.push_back().printf("%s [%d %d]", srcPath, bitmap.width(),
                                               bitmap.height());
     }
 
     write_expectations(bitmap, filename);
 
     if (FLAGS_testSubsetDecoding) {
         SkDEBUGCODE(bool couldRewind =) stream.rewind();
@@ skipping 215 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