Change the name of SkFlags to SkCommandLineFlags.

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_FLAGS_H
-#define SK_FLAGS_H
+#ifndef SK_COMMAND_LINE_FLAGS_H
+#define SK_COMMAND_LINE_FLAGS_H
 
 #include "SkString.h"
 #include "SkTDArray.h"
 
 /**
- *  Including this file (and compiling SkFlags.cpp) provides command line
+ *  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);
  *
- *  Then, in main, call SkFlags::SetUsage() to describe usage and call
- *  SkFlags::ParseCommandLine() to parse the flags. Henceforth, each flag can
+ *  Then, in main, call SkCommandLineFlags::SetUsage() to describe usage and call
+ *  SkCommandLineFlags::Parse() to parse the flags. Henceforth, each flag can
  *  be referenced using
  *
  *  FLAGS_name
  *
  *  For example, the line
  *
  *  DEFINE_bool(boolean, false, "The variable boolean does such and such");
  *
  *  will create the following variable:
  *
@@ skipping 42 matching lines @@
  *  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);
  *
  *  (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 SkFlags handles it.
- *  SkFlags will also allow creating --flag and --noflag. Uses the same input
+ *  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
  *  format as gflags and creates similarly named variables (i.e. FLAGS_name).
  *  Strings are handled differently (resulting variable will be an array of
  *  strings) so that a flag can be followed by multiple parameters.
  */
 
 
 class SkFlagInfo;
 
-class SkFlags {
+class SkCommandLineFlags {
 
 public:
     /**
      *  Call to set the help message to be displayed. Should be called before
-     *  ParseCommandLine.
+     *  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 ParseCommandLine(int argc, char** argv);
+    static void Parse(int argc, char** argv);
 
 private:
     static SkFlagInfo* gHead;
     static SkString    gUsage;
 
     // For access to gHead.
     friend class SkFlagInfo;
 };
 
 #define TO_STRING2(s) #s
@@ skipping 215 matching lines @@
         : fName(name)
         , fFlagType(type)
         , fHelpString(helpString)
         , fBoolValue(NULL)
         , fDefaultBool(false)
         , fIntValue(NULL)
         , fDefaultInt(0)
         , fDoubleValue(NULL)
         , fDefaultDouble(0)
         , fStrings(NULL) {
-        fNext = SkFlags::gHead;
-        SkFlags::gHead = this;
+        fNext = SkCommandLineFlags::gHead;
+        SkCommandLineFlags::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
+#endif // SK_COMMAND_LINE_FLAGS_H