Factor out VisualBench timing code into a helper class

tools/VisualBench/TimingStateMachine.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
-#ifndef VisualLightweightBenchModule_DEFINED
-#define VisualLightweightBenchModule_DEFINED
+#ifndef TimingStateMachine_DEFINED
+#define TimingStateMachine_DEFINED
 
-#include "VisualModule.h"
-
-#include "ResultsWriter.h"
-#include "SkPicture.h"
+#include "Benchmark.h"
+#include "SkTArray.h"
 #include "Timer.h"
-#include "VisualBench.h"
-#include "VisualBenchmarkStream.h"
 
 class SkCanvas;
 
 /*
- * This module is designed to be a minimal overhead timing module for VisualBench
+ * Manages a timer via a state machine.  Can be used by modules to time benchmarks
+ *
+ * Clients call nextFrame, and must handle any requests from the timing state machine, specifically
+ * to reset.  When kTimingFinished_ParentEvents is returned, then lastMeasurement() will return the
+ * timing and loops() will return the number of loops used to time.
+ *
+ * A client may continue timing the same benchmark indefinitely.  To advance to the next
+ * benchmark, the client should call nextBenchmark.
  */
-class VisualLightweightBenchModule : public VisualModule {
+class TimingStateMachine {
 public:
-    // TODO get rid of backpointer
-    VisualLightweightBenchModule(VisualBench* owner);
+    TimingStateMachine();
 
-    void draw(SkCanvas* canvas) override;
+    enum ParentEvents {
+        kReset_ParentEvents,
+        kTiming_ParentEvents,
+        kTimingFinished_ParentEvents,// This implies parent can read lastMeasurement() and must
+                                     // reset
+    };
 
-    bool onHandleChar(SkUnichar c) override;
+    ParentEvents nextFrame(SkCanvas* canvas, Benchmark* benchmark);
+
+    /*
+     * The caller should call this when they are ready to move to the next benchmark.  The caller
+     * must call this with the *last* benchmark so post draw hooks can be invoked
+     */
+    void nextBenchmark(SkCanvas*, Benchmark*);
+
+
+    /*
+     * When TimingStateMachine returns kTimingFinished_ParentEvents, then the owner can call
+     * lastMeasurement() to get the time
+     */
+    double lastMeasurement() const { return fLastMeasurement; }
+
+    int loops() const { return fLoops; }
 
 private:
     /*
-     * The heart of visual bench is an event driven timing loop.
-     * kWarmup_State:                        We run a dummy bench to let things settle on startup
+     * The heart of the timing state machine is an event driven timing loop.
      * kPreWarmLoopsPerCanvasPreDraw_State:  Before we begin timing, Benchmarks have a hook to
      *                                       access the canvas.  Then we prewarm before the autotune
      *                                       loops step.
      * kPreWarmLoops_State:                  We prewarm the gpu before auto tuning to enter a steady
      *                                       work state
      * kTuneLoops_State:                     Then we tune the loops of the benchmark to ensure we
      *                                       are doing a measurable amount of work
      * kPreWarmTimingPerCanvasPreDraw_State: Because reset the context after tuning loops to ensure
      *                                       coherent state, we need to give the benchmark
      *                                       another hook
      * kPreWarmTiming_State:                 We prewarm the gpu again to enter a steady state
      * kTiming_State:                        Finally we time the benchmark.  When finished timing
      *                                       if we have enough samples then we'll start the next
      *                                       benchmark in the kPreWarmLoopsPerCanvasPreDraw_State.
      *                                       otherwise, we enter the
      *                                       kPreWarmTimingPerCanvasPreDraw_State for another sample
      *                                       In either case we reset the context.
      */
     enum State {
-        kWarmup_State,
         kPreWarmLoopsPerCanvasPreDraw_State,
         kPreWarmLoops_State,
         kTuneLoops_State,
         kPreWarmTimingPerCanvasPreDraw_State,
         kPreWarmTiming_State,
         kTiming_State,
     };
-    void setTitle();
-    bool setupBackend();
-    void setupRenderTarget();
-    void printStats();
-    bool advanceRecordIfNecessary(SkCanvas*);
-    inline void renderFrame(SkCanvas*);
+
     inline void nextState(State);
-    void perCanvasPreDraw(SkCanvas*, State);
-    void preWarm(State nextState);
-    inline void tuneLoops();
-    inline void timing(SkCanvas*);
+    ParentEvents perCanvasPreDraw(SkCanvas*, Benchmark*, State);
+    ParentEvents preWarm(State nextState);
+    inline ParentEvents tuneLoops();
+    inline ParentEvents timing(SkCanvas*, Benchmark*);
     inline double elapsed();
     void resetTimingState();
-    void postDraw(SkCanvas*);
+    void postDraw(SkCanvas*, Benchmark*);
     void recordMeasurement();
-    void warmup(SkCanvas* canvas);
 
-    struct Record {
-        SkTArray<double> fMeasurements;
-    };
-
-    int fCurrentSample;
     int fCurrentFrame;
     int fLoops;
-    SkTArray<Record> fRecords;
+    double fLastMeasurement;
     WallTimer fTimer;
     State fState;
-    SkAutoTDelete<VisualBenchmarkStream> fBenchmarkStream;
-    SkAutoTUnref<Benchmark> fBenchmark;
-
-    // support framework
-    SkAutoTUnref<VisualBench> fOwner;
-    SkAutoTDelete<ResultsWriter> fResults;
-
-    typedef VisualModule INHERITED;
 };
 
 #endif