dm||nanobench --help looks nice when $COLUMNS == 80.

tools/flags/SkCommandLineFlags.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCommandLineFlags.h"
 #include "SkTDArray.h"
 #include "SkTSort.h"
@@ skipping 122 matching lines @@
 }
 
 SkFlagInfo* SkCommandLineFlags::gHead;
 SkString SkCommandLineFlags::gUsage;
 
 void SkCommandLineFlags::SetUsage(const char* usage) {
     gUsage.set(usage);
 }
 
 // Maximum line length for the help message.
-#define LINE_LENGTH 80
+#define LINE_LENGTH 72
 
 static void print_help_for_flag(const SkFlagInfo* flag) {
-    SkDebugf("\t--%s", flag->name().c_str());
+    SkDebugf("    --%s", flag->name().c_str());
     const SkString& shortName = flag->shortName();
     if (shortName.size() > 0) {
         SkDebugf(" or -%s", shortName.c_str());
     }
     SkDebugf(":\ttype: %s", flag->typeAsString().c_str());
     if (flag->defaultValue().size() > 0) {
         SkDebugf("\tdefault: %s", flag->defaultValue().c_str());
     }
     SkDebugf("\n");
     const SkString& help = flag->help();
     size_t length = help.size();
     const char* currLine = help.c_str();
     const char* stop = currLine + length;
     while (currLine < stop) {
         if (strlen(currLine) < LINE_LENGTH) {
             // Only one line length's worth of text left.
-            SkDebugf("\t\t%s\n", currLine);
+            SkDebugf("        %s\n", currLine);
             break;
         }
         int lineBreak = SkStrFind(currLine, "\n");
         if (lineBreak < 0 || lineBreak > LINE_LENGTH) {
             // No line break within line length. Will need to insert one.
             // Find a space before the line break.
             int spaceIndex = LINE_LENGTH - 1;
             while (spaceIndex > 0 && currLine[spaceIndex] != ' ') {
                 spaceIndex--;
             }
             int gap;
             if (0 == spaceIndex) {
                 // No spaces on the entire line. Go ahead and break mid word.
                 spaceIndex = LINE_LENGTH;
                 gap = 0;
             } else {
                 // Skip the space on the next line
                 gap = 1;
             }
-            SkDebugf("\t\t%.*s\n", spaceIndex, currLine);
+            SkDebugf("        %.*s\n", spaceIndex, currLine);
             currLine += spaceIndex + gap;
         } else {
             // the line break is within the limit. Break there.
             lineBreak++;
-            SkDebugf("\t\t%.*s", lineBreak, currLine);
+            SkDebugf("        %.*s", lineBreak, currLine);
             currLine += lineBreak;
         }
     }
     SkDebugf("\n");
 }
 
 namespace {
 struct CompareFlagsByName {
     bool operator()(SkFlagInfo* a, SkFlagInfo* b) const {
         return strcmp(a->name().c_str(), b->name().c_str()) < 0;
@@ skipping 50 matching lines @@
                             print_help_for_flag(flag);
                             helpFlags.remove(k);
                             break;
                         }
                     }
                 }
             }
             if (helpFlags.count() > 0) {
                 SkDebugf("Requested help for unrecognized flags:\n");
                 for (int k = 0; k < helpFlags.count(); k++) {
-                    SkDebugf("\t--%s\n", helpFlags[k]);
+                    SkDebugf("    --%s\n", helpFlags[k]);
                 }
             }
             helpPrinted = true;
         }
         if (!helpPrinted) {
             bool flagMatched = false;
             SkFlagInfo* flag = gHead;
             while (flag != NULL) {
                 if (flag->match(argv[i])) {
                     flagMatched = true;
@@ skipping 101 matching lines @@
 }
 
 }  // namespace
 
 bool SkCommandLineFlags::ShouldSkip(const SkTDArray<const char*>& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }
 bool SkCommandLineFlags::ShouldSkip(const StringArray& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }