Fix an SkCommandLineFlags bug.

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
 
 #include "SkString.h"
-#include "SkTDArray.h"
+#include "SkTArray.h"
 
 /**
  *  Including this file (and compiling SkCommandLineFlags.cpp) provides command line
  *  parsing. In order to use it, use the following macros in global
  *  namespace:
  *
  *  DEFINE_bool(name, defaultValue, helpString);
  *  DEFINE_string(name, defaultValue, helpString);
  *  DEFINE_int32(name, defaultValue, helpString);
  *  DEFINE_double(name, defaultValue, helpString);
@@ skipping 38 matching lines @@
  *
  *  These flags can be set by specifying, for example, "--integer 7" and
  *  "--real 3.14" on the command line.
  *
  *  Unlike the others, the line
  *
  *  DEFINE_string(args, .., ..);
  *
  *  creates an array:
  *
- *  SkTDArray<const char*> FLAGS_args;
+ *  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.
  *
  *  Any flag can be referenced from another file after using the following:
  *
  *  DECLARE_x(name);
  *
@@ skipping 19 matching lines @@
      *  Parse.
      */
     static void SetUsage(const char* usage);
 
     /**
      *  Call at the beginning of main to parse flags created by DEFINE_x, above.
      *  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:
+        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; }
+
+    private:
+        void reset() { fStrings.reset(); }
+
+        void append(const char* string) {
+            fStrings.push_back().set(string);
+        }
+
+        SkTArray<SkString> fStrings;
+
+        friend class SkFlagInfo;
+    };
+
 private:
     static SkFlagInfo* gHead;
     static SkString    gUsage;
 
     // For access to gHead.
     friend class SkFlagInfo;
 };
 
 #define TO_STRING2(s) #s
 #define TO_STRING(s) TO_STRING2(s)
@@ skipping 12 matching lines @@
 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;                                        \
+SkCommandLineFlags::StringArray FLAGS_##name;                               \
 static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),   \
                                                          NULL,              \
                                                          &FLAGS_##name,     \
                                                          defaultValue,      \
                                                          helpString)
 
 // string2 allows specifying a short name. There is an assert that shortName
 // is only 1 character.
 #define DEFINE_string2(name, shortName, defaultValue, helpString)               \
-SkTDArray<const char*> FLAGS_##name;                                            \
+SkCommandLineFlags::StringArray 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 DECLARE_string(name) extern SkCommandLineFlags::StringArray 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 19 matching lines @@
     // Create flags of the desired type, and append to the list.
     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;
     }
 
     static bool CreateStringFlag(const char* name, const char* shortName,
-                                 SkTDArray<const char*>* pStrings,
+                                 SkCommandLineFlags::StringArray* pStrings,
                                  const char* defaultValue, const char* helpString) {
         SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, shortName, kString_FlagType, helpString));
         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);
+            info->fStrings->append(defaultValue);
         }
         return true;
     }
 
     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;
@@ skipping 27 matching lines @@
     void resetStrings() {
         if (kString_FlagType == fFlagType) {
             fStrings->reset();
         } else {
             SkASSERT(!"Can only call resetStrings on kString_FlagType");
         }
     }
 
     void append(const char* string) {
         if (kString_FlagType == fFlagType) {
-            fStrings->append(1, &string);
+            fStrings->append(string);
         } else {
             SkASSERT(!"Can only append to kString_FlagType");
         }
     }
 
     void setInt(int32_t value) {
         if (kInt_FlagType == fFlagType) {
             *fIntValue = value;
         } else {
             SkASSERT(!"Can only call setInt on kInt_FlagType");
@@ skipping 82 matching lines @@
     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;
+    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