Add config options to run different GPU APIs to dm and nanobench

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"
 
 #include <stdlib.h>
 
 #if defined(GOOGLE3) && (defined(SK_BUILD_FOR_ANDROID) || defined(SK_BUILD_FOR_IOS))
     // I don't know why, but this is defined by //base only for non-Linux.
     DECLARE_bool(undefok)
 #else
     DEFINE_bool(undefok, false, "Silently ignore unknown flags instead of crashing.");
 #endif
 
 template <typename T> static void ignore_result(const T&) {}
 
 bool SkFlagInfo::CreateStringFlag(const char* name, const char* shortName,
                                   SkCommandLineFlags::StringArray* pStrings,
-                                  const char* defaultValue, const char* helpString) {
-    SkFlagInfo* info = new SkFlagInfo(name, shortName, kString_FlagType, helpString);
+                                  const char* defaultValue, const char* helpString,
+                                  const char* extendedHelpString) {
+    SkFlagInfo* info = new SkFlagInfo(name, shortName, kString_FlagType, helpString,
+                                      extendedHelpString);
     info->fDefaultString.set(defaultValue);
 
     info->fStrings = pStrings;
     SetDefaultStrings(pStrings, defaultValue);
     return true;
 }
 
 void SkFlagInfo::SetDefaultStrings(SkCommandLineFlags::StringArray* pStrings,
                                    const char* defaultValue) {
     pStrings->reset();
@@ skipping 107 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 72
 
-static void print_help_for_flag(const SkFlagInfo* flag) {
-    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();
+static void print_indented(const SkString& text) {
+    size_t length = text.size();
+    const char* currLine = text.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("        %s\n", currLine);
-            break;
+        int lineBreak = SkStrFind(currLine, "\n");
+        if (lineBreak < 0) {
+            lineBreak = strlen(currLine);
         }
-        int lineBreak = SkStrFind(currLine, "\n");
-        if (lineBreak < 0 || lineBreak > LINE_LENGTH) {
+        if (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("        %.*s\n", spaceIndex, currLine);
             currLine += spaceIndex + gap;
         } else {
             // the line break is within the limit. Break there.
             lineBreak++;
             SkDebugf("        %.*s", lineBreak, currLine);
             currLine += lineBreak;
         }
     }
+}
+
+static void print_help_for_flag(const SkFlagInfo* flag) {
+    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();
+    print_indented(help);
+    SkDebugf("\n");
+}
+static void print_extended_help_for_flag(const SkFlagInfo* flag) {
+    print_help_for_flag(flag);
+    print_indented(flag->extendedHelp());
     SkDebugf("\n");
 }
 
 namespace {
 struct CompareFlagsByName {
     bool operator()(SkFlagInfo* a, SkFlagInfo* b) const {
         return strcmp(a->name().c_str(), b->name().c_str()) < 0;
     }
 };
 }  // namespace
@@ skipping 30 matching lines @@
                 // If no flags followed --help, print them all
                 SkTDArray<SkFlagInfo*> allFlags;
                 for (SkFlagInfo* flag = SkCommandLineFlags::gHead; flag;
                      flag = flag->next()) {
                     allFlags.push(flag);
                 }
                 SkTQSort(&allFlags[0], &allFlags[allFlags.count() - 1],
                          CompareFlagsByName());
                 for (int i = 0; i < allFlags.count(); ++i) {
                     print_help_for_flag(allFlags[i]);
+                    if (allFlags[i]->extendedHelp().size() > 0) {
+                        SkDebugf("        Use '--help %s' for more information.\n",
+                                 allFlags[i]->name().c_str());
+                    }
                 }
             } else {
                 for (SkFlagInfo* flag = SkCommandLineFlags::gHead; flag;
                      flag = flag->next()) {
                     for (int k = 0; k < helpFlags.count(); k++) {
                         if (flag->name().equals(helpFlags[k]) ||
                             flag->shortName().equals(helpFlags[k])) {
-                            print_help_for_flag(flag);
+                            print_extended_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("    --%s\n", helpFlags[k]);
@@ skipping 113 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);
 }