Add --properties for things like gitHash that describe the current nanobench run.

tools/PictureResultsWriter.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Classes for writing out bench results in various formats.
  */
 
 #ifndef SkPictureResultsWriter_DEFINED
@@ skipping 156 matching lines @@
  *                          }
  *                      ]
  *                  }
  *              ]
  *          }
  *      ]
  * }*/
 
 class PictureJSONResultsWriter : public PictureResultsWriter {
 public:
-    PictureJSONResultsWriter(const char filename[], 
+    PictureJSONResultsWriter(const char filename[],
                              const char builderName[],
                              int buildNumber,
                              int timestamp,
                              const char gitHash[],
                              int gitNumber)
         : fStream(filename) {
         fBuilderName = SkString(builderName);
         fBuildNumber = buildNumber;
         fTimestamp = timestamp;
         fGitHash = SkString(gitHash);
         fGitNumber = gitNumber;
-        fBuilderData = SkMakeBuilderJSON(fBuilderName);
+        fBuilderData = this->makeBuilderJson();
     }
 
     virtual void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
         fBenchName = SkString(name);
     }
     virtual void logRenderer(sk_tools::PictureRenderer* pr) SK_OVERRIDE {
         fParams = pr->getJSONConfig();
         fConfigString = pr->getConfigName();
     }
     // Apparently tiles aren't used, so tileMeta is empty
@@ skipping 27 matching lines @@
 
             // Not including skpSize because that's deprecated?
             data["key"] = this->makeKey(iter.key().asString().c_str()).c_str();
             // Get the data
             SkTArray<double> times;
             Json::Value val = *iter;
             for(Json::ValueIterator vals = val.begin(); vals != val.end();
                     vals++) {
                 times.push_back((*vals).asDouble());
             }
-            qsort(static_cast<void*>(times.begin()), times.count(), 
+            qsort(static_cast<void*>(times.begin()), times.count(),
                     sizeof(double), PictureJSONResultsWriter::CompareDoubles);
             data["value"] = times[static_cast<int>(times.count() * 0.25f)];
             data["params"]["measurementType"] = iter.key().asString();
             fStream.writeText(Json::FastWriter().write(data).c_str());
         }
     }
     virtual void end() SK_OVERRIDE {
        fStream.flush();
     }
 private:
+    Json::Value makeBuilderJson() const {
+        static const int kNumKeys = 6;
+        static const char* kKeys[kNumKeys] = {
+            "role", "os", "model", "gpu", "arch", "configuration"};
+        Json::Value builderData;
+
+        if (!fBuilderName.isEmpty()) {
+            SkTArray<SkString> splitBuilder;
+            SkStrSplit(fBuilderName.c_str(), "-", &splitBuilder);
+            SkASSERT(splitBuilder.count() >= kNumKeys);
+            for (int i = 0; i < kNumKeys && i < splitBuilder.count(); ++i) {
+                builderData[kKeys[i]] = splitBuilder[i].c_str();
+            }
+            builderData["builderName"] = fBuilderName.c_str();
+            if (kNumKeys < splitBuilder.count()) {
+                SkString extras;
+                for (int i = kNumKeys; i < splitBuilder.count(); ++i) {
+                    extras.append(splitBuilder[i]);
+                    if (i != splitBuilder.count() - 1) {
+                        extras.append("-");
+                    }
+                }
+                builderData["badParams"] = extras.c_str();
+            }
+        }
+        return builderData;
+    }
+
     static int CompareDoubles(const void* p1, const void* p2) {
         if(*static_cast<const double*>(p1) < *static_cast<const double*>(p2)) {
             return -1;
-        } else if(*static_cast<const double*>(p1) == 
+        } else if(*static_cast<const double*>(p1) ==
                 *static_cast<const double*>(p2)) {
-            return 0; 
+            return 0;
         } else {
             return 1;
         }
     }
     SkString makeKey(const char measurementType[]) const {
         SkString tmp(fBuilderName);
         tmp.append("_");
         tmp.append(fBenchName);
         tmp.append("_");
         tmp.append(fConfigString);
         tmp.append("_");
         tmp.append(measurementType);
         return tmp;
     }
 
     SkFILEWStream   fStream;
     Json::Value     fBuilderData;
     SkString        fBenchName;
     Json::Value     fParams;
 
     SkString        fConfigString;
     SkString        fBuilderName;
     int             fBuildNumber;
     int             fTimestamp;
     SkString        fGitHash;
     int             fGitNumber;
 };
 
 #endif