Skip the TIMESTAMP file.

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 471 matching lines @@
  *  If directory is non null and does not end with a path separator, append one.
  *  @param directory SkString representing the path to a directory. If the last character is not a
  *      path separator (specific to the current OS), append one.
  */
 static void append_path_separator_if_necessary(SkString* directory) {
     if (directory != NULL && directory->c_str()[directory->size() - 1] != SkPATH_SEPARATOR) {
         directory->appendf("%c", SkPATH_SEPARATOR);
     }
 }
 
+/**
+ *  Return true if the filename represents an image.
+ *  Note: This only returns false if the filename begins with 'TIMESTAMP',
+ *  which is the file we are trying to avoid. A better implementation might
+ *  be to return true if it matches one of the many image file extensions.
+ *  Even that is not a perfect solution though, since a file could have the
+ *  wrong extension.
+ */
+static bool is_image_file(const char* filename) {
+    SkString basename = SkOSPath::SkBasename(filename);
+    return !basename.startsWith("TIMESTAMP");

[borenet, 2013/06/28 19:50:38]

How much better is this than just looking for file extensions we expect to be
able to decode?  For the record, I think the timestamp file is going away with
checksums, but it might be replaced with a JSON file containing checksums.

[scroggo, 2013/06/28 20:00:10]

It is shorter and faster.

Changed in the latest patch to compare to known image extensions.

+}
+
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
     SkCommandLineFlags::SetUsage("Decode files, and optionally write the results to files.");
     SkCommandLineFlags::Parse(argc, argv);
 
     if (FLAGS_readPath.count() < 1) {
         SkDebugf("Folder(s) or image(s) to decode are required.\n");
         return -1;
     }
 
@@ skipping 19 matching lines @@
     for (int i = 0; i < FLAGS_readPath.count(); i++) {
         const char* readPath = FLAGS_readPath[i];
         if (strlen(readPath) < 1) {
             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());
                 decodeFileAndWrite(fullname.c_str(), outDirPtr);
             }
-        } else if (sk_exists(readPath)) {
+        } 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.
         Json::Value nullValue;
         Json::Value root = skiagm::CreateJsonTree(gExpectationsToWrite, nullValue, nullValue,
                                                   nullValue, nullValue);
@@ skipping 16 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