Wire up configurations properly in VisualBench

tools/VisualBench/VisualLightweightBenchModule.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "VisualLightweightBenchModule.h"
 
 #include "ProcStats.h"
@@ skipping 28 matching lines @@
     return HumanizeMs(ms);
 }
 
 #define HUMANIZE(time) humanize(time).c_str()
 
 VisualLightweightBenchModule::VisualLightweightBenchModule(VisualBench* owner)
     : INHERITED(owner, true)
     , fCurrentSample(0)
     , fResults(new ResultsWriter) {
     // Print header
-    SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tbench\n", FLAGS_samples,
-             "samples");
+    SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\tconfig\tbench\n");
 
     // setup json logging if required
     if (!FLAGS_outResultsFile.isEmpty()) {
         fResults.reset(new NanoJSONResultsWriter(FLAGS_outResultsFile[0]));
     }
 
     if (1 == FLAGS_key.count() % 2) {
         SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
     } else {
         for (int i = 1; i < FLAGS_key.count(); i += 2) {
@@ skipping 17 matching lines @@
     benchmark->draw(loops, canvas);
     canvas->flush();
 }
 
 void VisualLightweightBenchModule::printStats(Benchmark* benchmark, int loops) {
     const SkTArray<double>& measurements = fRecords.back().fMeasurements;
     const char* shortName = benchmark->getUniqueName();
 
     // update log
     // Note: We currently log only the minimum.  It would be interesting to log more information
-    SkString configName;
-    if (FLAGS_msaa > 0) {
-        configName.appendf("msaa_%d", FLAGS_msaa);
-    } else {
-        configName.appendf("gpu");
-    }
     // Log bench name
     fResults->bench(shortName, benchmark->getSize().fX, benchmark->getSize().fY);
 
-    fResults->config(configName.c_str());
+    fResults->config(this->owner()->currentConfig().humanReadable().c_str());
     fResults->configOption("name", shortName);
     SkASSERT(measurements.count());
     Stats stats(measurements);
     fResults->metric("min_ms", stats.min);
 
     // Print output
     if (FLAGS_verbose) {
         for (int i = 0; i < measurements.count(); i++) {
             SkDebugf("%s  ", HUMANIZE(measurements[i]));
         }
         SkDebugf("%s\n", shortName);
     } else {
         const double stdDevPercent = 100 * sqrt(stats.var) / stats.mean;
-        SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\n",
+        SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n",
                  sk_tools::getCurrResidentSetSizeMB(),
                  sk_tools::getMaxResidentSetSizeMB(),
                  loops,
                  HUMANIZE(stats.min),
                  HUMANIZE(stats.median),
                  HUMANIZE(stats.mean),
                  HUMANIZE(stats.max),
                  stdDevPercent,
                  stats.plot.c_str(),
+                 this->owner()->currentConfig().humanReadable().c_str(),
                  shortName);
     }
 }
 
 bool VisualLightweightBenchModule::timingFinished(Benchmark* benchmark, int loops,
                                                   double measurement) {
     fRecords.back().fMeasurements.push_back(measurement);
     if (++fCurrentSample > FLAGS_samples) {
         this->printStats(benchmark, loops);
         fRecords.push_back();
         fCurrentSample = 0;
         return true;
     }
     return false;
 }
 
 bool VisualLightweightBenchModule::onHandleChar(SkUnichar c) {
     return true;
 }