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

tools/flags/SkCommandLineFlags.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SK_COMMAND_LINE_FLAGS_H
 #define SK_COMMAND_LINE_FLAGS_H
 
@@ skipping 58 matching lines @@
  *
  *  creates an array:
  *
  *  SkCommandLineFlags::StringArray FLAGS_args;
  *
  *  If the default value is the empty string, FLAGS_args will default to a size
  *  of zero. Otherwise it will default to a size of 1 with the default string
  *  as its value. All strings that follow the flag on the command line (until
  *  a string that begins with '-') will be entries in the array.
  *
+ *  DEFINE_extended_string(args, .., .., extendedHelpString);
+ *
+ *  creates a similar string array flag as DEFINE_string. The flag will have extended help text
+ *  (extendedHelpString) that can the user can see with '--help <args>' flag.
+ *
  *  Any flag can be referenced from another file after using the following:
  *
  *  DECLARE_x(name);
  *
  *  (where 'x' is the type specified in the DEFINE).
  *
  *  Inspired by gflags (https://code.google.com/p/gflags/). Is not quite as
  *  robust as gflags, but suits our purposes. For example, allows creating
  *  a flag -h or -help which will never be used, since SkCommandLineFlags handles it.
  *  SkCommandLineFlags will also allow creating --flag and --noflag. Uses the same input
@@ skipping 18 matching lines @@
      *  Must only be called once.
      */
     static void Parse(int argc, char** argv);
 
     /**
      *  Custom class for holding the arguments for a string flag.
      *  Publicly only has accessors so the strings cannot be modified.
      */
     class StringArray {
     public:
+        StringArray() { }
+        explicit StringArray(const SkTArray<SkString>& strings)
+            : fStrings(strings) {
+        }
         const char* operator[](int i) const {
             SkASSERT(i >= 0 && i < fStrings.count());
             return fStrings[i].c_str();
         }
 
         int count() const {
             return fStrings.count();
         }
 
         bool isEmpty() const { return this->count() == 0; }
@@ skipping 70 matching lines @@
                                                                  helpString)
 
 #define DECLARE_bool(name) extern bool FLAGS_##name;
 
 #define DEFINE_string(name, defaultValue, helpString)                       \
 SkCommandLineFlags::StringArray FLAGS_##name;                               \
 SK_UNUSED static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),   \
                                                                    nullptr,              \
                                                                    &FLAGS_##name,     \
                                                                    defaultValue,      \
-                                                                   helpString)
+                                                                   helpString, nullptr)
+#define DEFINE_extended_string(name, defaultValue, helpString, extendedHelpString) \
+SkCommandLineFlags::StringArray FLAGS_##name;                                      \
+SK_UNUSED static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),   \
+                                                                   nullptr, \
+                                                                   &FLAGS_##name, \
+                                                                   defaultValue, \
+                                                                   helpString, \
+                                                                   extendedHelpString)
 
 // string2 allows specifying a short name. There is an assert that shortName
 // is only 1 character.
 #define DEFINE_string2(name, shortName, defaultValue, helpString)               \
 SkCommandLineFlags::StringArray FLAGS_##name;                                   \
 SK_UNUSED static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),       \
                                                                    TO_STRING(shortName),  \
                                                                    &FLAGS_##name,         \
                                                                    defaultValue,          \
-                                                                   helpString)
+                                                                   helpString, nullptr)
 
 #define DECLARE_string(name) extern SkCommandLineFlags::StringArray FLAGS_##name;
 
 
 
 
 #define DEFINE_int32(name, defaultValue, helpString)                        \
 int32_t FLAGS_##name;                                                       \
 SK_UNUSED static bool unused_##name = SkFlagInfo::CreateIntFlag(TO_STRING(name),      \
                                                                 &FLAGS_##name,        \
@@ skipping 38 matching lines @@
      *      be referenced on the command line as "--name" to set the value of this flag.
      *  @param shortName Short version (one character) of the name of the flag. This name can
      *      be referenced on the command line as "-shortName" to set the value of this flag.
      *  @param p<Type> Pointer to a global variable which holds the value set by SkCommandLineFlags.
      *  @param defaultValue The default value of this flag. The variable pointed to by p<Type> will
      *      be set to this value initially. This is also displayed as part of the help output.
      *  @param helpString Explanation of what this flag changes in the program.
      */
     static bool CreateBoolFlag(const char* name, const char* shortName, bool* pBool,
                                bool defaultValue, const char* helpString) {
-        SkFlagInfo* info = new SkFlagInfo(name, shortName, kBool_FlagType, helpString);
+        SkFlagInfo* info = new SkFlagInfo(name, shortName, kBool_FlagType, helpString, nullptr);
         info->fBoolValue = pBool;
         *info->fBoolValue = info->fDefaultBool = defaultValue;
         return true;
     }
 
     /**
      *  See comments for CreateBoolFlag.
      *  @param pStrings Unlike the others, this is a pointer to an array of values.
      *  @param defaultValue Thise default will be parsed so that strings separated by spaces
      *      will be added to pStrings.
      */
     static bool CreateStringFlag(const char* name, const char* shortName,
                                  SkCommandLineFlags::StringArray* pStrings,
-                                 const char* defaultValue, const char* helpString);
+                                 const char* defaultValue, const char* helpString,
+                                 const char* extendedHelpString);
 
     /**
      *  See comments for CreateBoolFlag.
      */
     static bool CreateIntFlag(const char* name, int32_t* pInt,
                               int32_t defaultValue, const char* helpString) {
-        SkFlagInfo* info = new SkFlagInfo(name, nullptr, kInt_FlagType, helpString);
+        SkFlagInfo* info = new SkFlagInfo(name, nullptr, kInt_FlagType, helpString, nullptr);
         info->fIntValue = pInt;
         *info->fIntValue = info->fDefaultInt = defaultValue;
         return true;
     }
 
     static bool CreateIntFlag(const char* name, const char* shortName, int32_t* pInt,
                               int32_t defaultValue, const char* helpString) {
-        SkFlagInfo* info = new SkFlagInfo(name, shortName, kInt_FlagType, helpString);
+        SkFlagInfo* info = new SkFlagInfo(name, shortName, kInt_FlagType, helpString, nullptr);
         info->fIntValue = pInt;
         *info->fIntValue = info->fDefaultInt = defaultValue;
         return true;
     }
 
     /**
      *  See comments for CreateBoolFlag.
      */
     static bool CreateDoubleFlag(const char* name, double* pDouble,
                                  double defaultValue, const char* helpString) {
-        SkFlagInfo* info = new SkFlagInfo(name, nullptr, kDouble_FlagType, helpString);
+        SkFlagInfo* info = new SkFlagInfo(name, nullptr, kDouble_FlagType, helpString, nullptr);
         info->fDoubleValue = pDouble;
         *info->fDoubleValue = info->fDefaultDouble = defaultValue;
         return true;
     }
 
     /**
      *  Returns true if the string matches this flag.
      *  For a boolean flag, also sets the value, since a boolean flag can be set in a number of ways
      *  without looking at the following string:
      *      --name
@@ skipping 49 matching lines @@
         }
     }
 
     SkFlagInfo* next() { return fNext; }
 
     const SkString& name() const { return fName; }
 
     const SkString& shortName() const { return fShortName; }
 
     const SkString& help() const { return fHelpString; }
+    const SkString& extendedHelp() const { return fExtendedHelpString; }
 
     SkString defaultValue() const {
         SkString result;
         switch (fFlagType) {
             case SkFlagInfo::kBool_FlagType:
                 result.printf("%s", fDefaultBool ? "true" : "false");
                 break;
             case SkFlagInfo::kString_FlagType:
                 return fDefaultString;
             case SkFlagInfo::kInt_FlagType:
@@ skipping 18 matching lines @@
                 return SkString("int");
             case SkFlagInfo::kDouble_FlagType:
                 return SkString("double");
             default:
                 SkDEBUGFAIL("Invalid flag type");
                 return SkString();
         }
     }
 
 private:
-    SkFlagInfo(const char* name, const char* shortName, FlagTypes type, const char* helpString)
+    SkFlagInfo(const char* name, const char* shortName, FlagTypes type, const char* helpString,
+               const char* extendedHelpString)
         : fName(name)
         , fShortName(shortName)
         , fFlagType(type)
         , fHelpString(helpString)
+        , fExtendedHelpString(extendedHelpString)
         , fBoolValue(nullptr)
         , fDefaultBool(false)
         , fIntValue(nullptr)
         , fDefaultInt(0)
         , fDoubleValue(nullptr)
         , fDefaultDouble(0)
         , fStrings(nullptr) {
         fNext = SkCommandLineFlags::gHead;
         SkCommandLineFlags::gHead = this;
         SkASSERT(name && strlen(name) > 1);
         SkASSERT(nullptr == shortName || 1 == strlen(shortName));
     }
 
     /**
      *  Set a StringArray to hold the values stored in defaultStrings.
      *  @param array The StringArray to modify.
      *  @param defaultStrings Space separated list of strings that should be inserted into array
      *      individually.
      */
     static void SetDefaultStrings(SkCommandLineFlags::StringArray* array,
                                   const char* defaultStrings);
 
     // Name of the flag, without initial dashes
     SkString             fName;
     SkString             fShortName;
     FlagTypes            fFlagType;
     SkString             fHelpString;
+    SkString             fExtendedHelpString;
     bool*                fBoolValue;
     bool                 fDefaultBool;
     int32_t*             fIntValue;
     int32_t              fDefaultInt;
     double*              fDoubleValue;
     double               fDefaultDouble;
     SkCommandLineFlags::StringArray* fStrings;
     // Both for the help string and in case fStrings is empty.
     SkString             fDefaultString;
 
     // In order to keep a linked list.
     SkFlagInfo*          fNext;
 };
 #endif // SK_COMMAND_LINE_FLAGS_H