Revert "Make gm use SkFlags."

tools/SkFlags.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_FLAGS_H
 #define SK_FLAGS_H
 
@@ skipping 101 matching lines @@
     // For access to gHead.
     friend class SkFlagInfo;
 };
 
 #define TO_STRING2(s) #s
 #define TO_STRING(s) TO_STRING2(s)
 
 #define DEFINE_bool(name, defaultValue, helpString)                         \
 bool FLAGS_##name;                                                          \
 static bool unused_##name = SkFlagInfo::CreateBoolFlag(TO_STRING(name),     \
-                                                       NULL,                \
                                                        &FLAGS_##name,       \
                                                        defaultValue,        \
                                                        helpString)
-
-// bool 2 allows specifying a short name. No check is done to ensure that shortName
-// is actually shorter than name.
-#define DEFINE_bool2(name, shortName, defaultValue, helpString)             \
-bool FLAGS_##name;                                                          \
-static bool unused_##name = SkFlagInfo::CreateBoolFlag(TO_STRING(name),     \
-                                                       TO_STRING(shortName),\
-                                                       &FLAGS_##name,       \
-                                                       defaultValue,        \
-                                                       helpString)
 
 #define DECLARE_bool(name) extern bool FLAGS_##name;
 
 #define DEFINE_string(name, defaultValue, helpString)                       \
 SkTDArray<const char*> FLAGS_##name;                                        \
 static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),   \
-                                                         NULL,              \
                                                          &FLAGS_##name,     \
                                                          defaultValue,      \
                                                          helpString)
 
-// string2 allows specifying a short name. No check is done to ensure that shortName
-// is actually shorter than name.
-#define DEFINE_string2(name, shortName, defaultValue, helpString)               \
-SkTDArray<const char*> FLAGS_##name;                                            \
-static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),       \
-                                                         TO_STRING(shortName),  \
-                                                         &FLAGS_##name,         \
-                                                         defaultValue,          \
-                                                         helpString)
-
 #define DECLARE_string(name) extern SkTDArray<const char*> FLAGS_##name;
 
 #define DEFINE_int32(name, defaultValue, helpString)                        \
 int32_t FLAGS_##name;                                                       \
 static bool unused_##name = SkFlagInfo::CreateIntFlag(TO_STRING(name),      \
                                                       &FLAGS_##name,        \
                                                       defaultValue,         \
                                                       helpString)
 
 #define DECLARE_int32(name) extern int32_t FLAGS_##name;
@@ skipping 11 matching lines @@
 
 public:
     enum FlagTypes {
         kBool_FlagType,
         kString_FlagType,
         kInt_FlagType,
         kDouble_FlagType,
     };
 
     // Create flags of the desired type, and append to the list.
-    static bool CreateBoolFlag(const char* name, const char* shortName, bool* pBool,
+    static bool CreateBoolFlag(const char* name, bool* pBool,
                                bool defaultValue, const char* helpString) {
         SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kBool_FlagType, helpString));
-        info->fShortName.set(shortName);
         info->fBoolValue = pBool;
         *info->fBoolValue = info->fDefaultBool = defaultValue;
         return true;
     }
 
-    static bool CreateStringFlag(const char* name, const char* shortName,
-                                 SkTDArray<const char*>* pStrings,
+    static bool CreateStringFlag(const char* name, SkTDArray<const char*>* pStrings,
                                  const char* defaultValue, const char* helpString) {
         SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kString_FlagType, helpString));
-        info->fShortName.set(shortName);
         info->fDefaultString.set(defaultValue);
 
         info->fStrings = pStrings;
         info->fStrings->reset();
         // If default is "", leave the array empty.
         if (info->fDefaultString.size() > 0) {
             info->fStrings->append(1, &defaultValue);
         }
         return true;
     }
@@ skipping 12 matching lines @@
         info->fDoubleValue = pDouble;
         *info->fDoubleValue = info->fDefaultDouble = defaultValue;
         return true;
     }
 
     /**
      *  Returns true if the string matches this flag. For a bool, also sets the
      *  value, since a bool is specified as true or false by --name or --noname.
      */
     bool match(const char* string) {
-        if (SkStrStartsWith(string, '-') && strlen(string) > 1) {
+        if (SkStrStartsWith(string, '-')) {
             string++;
             // Allow one or two dashes
-            if (SkStrStartsWith(string, '-') && strlen(string) > 1) {
+            if (SkStrStartsWith(string, '-')) {
                 string++;
             }
             if (kBool_FlagType == fFlagType) {
                 // In this case, go ahead and set the value.
-                if (fName.equals(string) || fShortName.equals(string)) {
+                if (fName.equals(string)) {
                     *fBoolValue = true;
                     return true;
                 }
-                if (SkStrStartsWith(string, "no") && strlen(string) > 2) {
-                    string += 2;
-                    if (fName.equals(string) || fShortName.equals(string)) {
-                        *fBoolValue = false;
-                        return true;
-                    }
-                    return false;
+                SkString noname(fName);
+                noname.prepend("no");
+                if (noname.equals(string)) {
+                    *fBoolValue = false;
+                    return true;
                 }
+                return false;
             }
-            return fName.equals(string) || fShortName.equals(string);
+            return fName.equals(string);
         } else {
             // Has no dash
             return false;
         }
         return false;
     }
 
     FlagTypes getFlagType() const { return fFlagType; }
 
     void resetStrings() {
@@ skipping 80 matching lines @@
         , fIntValue(NULL)
         , fDefaultInt(0)
         , fDoubleValue(NULL)
         , fDefaultDouble(0)
         , fStrings(NULL) {
         fNext = SkFlags::gHead;
         SkFlags::gHead = this;
     }
     // Name of the flag, without initial dashes
     SkString             fName;
-    SkString             fShortName;
     FlagTypes            fFlagType;
     SkString             fHelpString;
     bool*                fBoolValue;
     bool                 fDefaultBool;
     int32_t*             fIntValue;
     int32_t              fDefaultInt;
     double*              fDoubleValue;
     double               fDefaultDouble;
     SkTDArray<const char*>* 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_FLAGS_H