SkFlags now follows proper dashing convention.

tools/render_pictures_main.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CopyTilesRenderer.h"
 #include "SkBitmap.h"
 #include "SkDevice.h"
 #include "SkCommandLineFlags.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkMath.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "PictureRenderer.h"
 #include "PictureRenderingFlags.h"
 #include "picture_utils.h"
 
 // Flags used by this file, alphabetically:
 DEFINE_int32(clone, 0, "Clone the picture n times before rendering.");
 DECLARE_bool(deferImageDecoding);
 DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
              "by more than this amount are considered errors, though all diffs are reported. "
              "Requires --validate.");
-DECLARE_string(r);
-DEFINE_string(w, "", "Directory to write the rendered images.");
+DECLARE_string(readPath);
+DEFINE_string2(writePath, w, "", "Directory to write the rendered images.");
 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
             "file, instead of an image for each tile.");
 DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
             "the picture rendered in simple mode. When used in conjunction with --bbh, results "
             "are validated against the picture rendered in the same mode, but without the bbh.");
 
 static void make_output_filepath(SkString* path, const SkString& dir,
                                  const SkString& name) {
     sk_tools::make_filepath(path, dir, name);
     // Remove ".skp"
@@ skipping 228 matching lines @@
         SkDebugf(warning.c_str());
     }
     return failures;
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
     SkCommandLineFlags::SetUsage("Render .skp files.");
     SkCommandLineFlags::Parse(argc, argv);
 
-    if (FLAGS_r.isEmpty()) {
+    if (FLAGS_readPath.isEmpty()) {
         SkDebugf(".skp files or directories are required.\n");
         exit(-1);
     }
 
     if (FLAGS_maxComponentDiff < 0 || FLAGS_maxComponentDiff > 256) {
         SkDebugf("--maxComponentDiff must be between 0 and 256\n");
         exit(-1);
     }
 
     if (FLAGS_maxComponentDiff != 256 && !FLAGS_validate) {
@@ skipping 13 matching lines @@
         SkDebugf("%s\n", errorString.c_str());
     }
 
     if (renderer.get() == NULL) {
         exit(-1);
     }
 
     SkAutoGraphics ag;
 
     SkString outputDir;
-    if (FLAGS_w.count() == 1) {
-        outputDir.set(FLAGS_w[0]);
+    if (FLAGS_writePath.count() == 1) {
+        outputDir.set(FLAGS_writePath[0]);
     }
 
     int failures = 0;
-    for (int i = 0; i < FLAGS_r.count(); i ++) {
-        failures += process_input(FLAGS_r[i], &outputDir, *renderer.get());
+    for (int i = 0; i < FLAGS_readPath.count(); i ++) {
+        failures += process_input(FLAGS_readPath[i], &outputDir, *renderer.get());
     }
     if (failures != 0) {
         SkDebugf("Failed to render %i pictures.\n", failures);
         return 1;
     }
 #if SK_SUPPORT_GPU
 #if GR_CACHE_STATS
     if (renderer->isUsingGpuDevice()) {
         GrContext* ctx = renderer->getGrContext();
 
         ctx->printCacheStats();
     }
 #endif
 #endif
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif