Treat default command line argument properly.

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 114 matching lines @@
 
         bool isEmpty() const { return this->count() == 0; }
 
     private:
         void reset() { fStrings.reset(); }
 
         void append(const char* string) {
             fStrings.push_back().set(string);
         }
 
+        void append(const char* string, size_t length) {
+            fStrings.push_back().set(string, length);
+        }
+
         SkTArray<SkString> fStrings;
 
         friend class SkFlagInfo;
     };
 
 private:
     static SkFlagInfo* gHead;
     static SkString    gUsage;
 
     // For access to gHead.
@@ skipping 64 matching lines @@
 class SkFlagInfo {
 
 public:
     enum FlagTypes {
         kBool_FlagType,
         kString_FlagType,
         kInt_FlagType,
         kDouble_FlagType,
     };
 
-    // Create flags of the desired type, and append to the list.
+    /**
+     *  Each Create<Type>Flag function creates an SkFlagInfo of the specified type. The SkFlagInfo
+     *  object is appended to a list, which is deleted when SkCommandLineFlags::Parse is called.
+     *  Therefore, each call should be made before the call to ::Parse. They are not intended
+     *  to be called directly. Instead, use the macros described above.
+     *  @param name Long version (at least 2 characters) of the name of the flag. This name can
+     *      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 = SkNEW_ARGS(SkFlagInfo, (name, shortName, kBool_FlagType, helpString));
         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) {
-        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, shortName, kString_FlagType, helpString));
-        info->fDefaultString.set(defaultValue);
+                                 const char* defaultValue, const char* helpString);
 
-        info->fStrings = pStrings;
-        info->fStrings->reset();
-        // If default is "", leave the array empty.
-        if (info->fDefaultString.size() > 0) {
-            info->fStrings->append(defaultValue);
-        }
-        return true;
-    }
-
+    /**
+     *  See comments for CreateBoolFlag.
+     */
     static bool CreateIntFlag(const char* name, int32_t* pInt,
                               int32_t defaultValue, const char* helpString) {
         SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, NULL, kInt_FlagType, helpString));
         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 = SkNEW_ARGS(SkFlagInfo, (name, NULL, kDouble_FlagType, helpString));
         info->fDoubleValue = pDouble;
         *info->fDoubleValue = info->fDefaultDouble = defaultValue;
         return true;
     }
 
     /**
      *  Returns true if the string matches this flag.
@@ skipping 107 matching lines @@
         , fIntValue(NULL)
         , fDefaultInt(0)
         , fDoubleValue(NULL)
         , fDefaultDouble(0)
         , fStrings(NULL) {
         fNext = SkCommandLineFlags::gHead;
         SkCommandLineFlags::gHead = this;
         SkASSERT(NULL != name && strlen(name) > 1);
         SkASSERT(NULL == 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;
     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