Cleanup timing state machine

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"
 
@@ skipping 26 matching lines @@
     if (FLAGS_verbose) {
         return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
     }
     return HumanizeMs(ms);
 }
 
 #define HUMANIZE(time) humanize(time).c_str()
 
 VisualLightweightBenchModule::VisualLightweightBenchModule(VisualBench* owner)
     : fCurrentSample(0)
+    , fHasBeenReset(false)
     , fOwner(SkRef(owner))
     , fResults(new ResultsWriter) {
     fBenchmarkStream.reset(new VisualBenchmarkStream);
 
     // Print header
     SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tbench\n", FLAGS_samples,
              "samples");
 
     // setup json logging if required
     if (!FLAGS_outResultsFile.isEmpty()) {
@@ skipping 68 matching lines @@
         return true;
     }
 
     fBenchmark.reset(fBenchmarkStream->next());
     if (!fBenchmark) {
         return false;
     }
 
     fOwner->clear(canvas, SK_ColorWHITE, 2);
 
-    fBenchmark->delayedSetup();
     fRecords.push_back();
 
     // Log bench name
     fResults->bench(fBenchmark->getUniqueName(), fBenchmark->getSize().fX,
                     fBenchmark->getSize().fY);
+
+    fBenchmark->delayedSetup();
+    fBenchmark->preTimingHooks(canvas);
     return true;
 }
 
 void VisualLightweightBenchModule::draw(SkCanvas* canvas) {
     if (!this->advanceRecordIfNecessary(canvas)) {
         SkDebugf("Exiting VisualBench successfully\n");
         fOwner->closeWindow();
         return;
     }
+
+    if (fHasBeenReset) {
+        fHasBeenReset = false;
+        fBenchmark->preTimingHooks(canvas);
+    }
+
     this->renderFrame(canvas);
-    TimingStateMachine::ParentEvents event = fTSM.nextFrame(canvas, fBenchmark);
+    TimingStateMachine::ParentEvents event = fTSM.nextFrame(true);
     switch (event) {
         case TimingStateMachine::kReset_ParentEvents:
+            fBenchmark->postTimingHooks(canvas);
             fOwner->reset();
+            fHasBeenReset = true;
             break;
         case TimingStateMachine::kTiming_ParentEvents:
             break;
         case TimingStateMachine::kTimingFinished_ParentEvents:
+            fBenchmark->postTimingHooks(canvas);
             fOwner->reset();
             fRecords.back().fMeasurements.push_back(fTSM.lastMeasurement());
             if (++fCurrentSample > FLAGS_samples) {
                 this->printStats();
                 fTSM.nextBenchmark(canvas, fBenchmark);
                 fCurrentSample = 0;
                 fBenchmark.reset(nullptr);
             } else {
-                fTSM.nextSampleWithPrewarm();
+                fHasBeenReset = true;
             }
             break;
     }
 }
 
 bool VisualLightweightBenchModule::onHandleChar(SkUnichar c) {
     return true;
 }