Create module system for VisualBench

tools/VisualBench/VisualLightweightBenchModule.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 VisualBench_DEFINED
-#define VisualBench_DEFINED
+#ifndef VisualLightweightBenchModule_DEFINED
+#define VisualLightweightBenchModule_DEFINED
 
-#include "SkWindow.h"
+#include "VisualModule.h"
 
 #include "ResultsWriter.h"
 #include "SkPicture.h"
-#include "SkString.h"
-#include "SkSurface.h"
 #include "Timer.h"
+#include "VisualBench.h"
 #include "VisualBenchmarkStream.h"
-#include "gl/SkGLContext.h"
 
-class GrContext;
-struct GrGLInterface;
-class GrRenderTarget;
 class SkCanvas;
 
 /*
- * A Visual benchmarking tool for gpu benchmarking
+ * This module is designed to be a minimal overhead timing module for VisualBench
  */
-class VisualBench : public SkOSWindow {
+class VisualLightweightBenchModule : public VisualModule {
 public:
-    VisualBench(void* hwnd, int argc, char** argv);
-    ~VisualBench() override;
-
-protected:
-    SkSurface* createSurface() override;
+    // TODO get rid of backpointer
+    VisualLightweightBenchModule(VisualBench* owner);
 
     void draw(SkCanvas* canvas) override;
 
-    void onSizeChange() override;
-
 private:
     /*
      * The heart of visual bench 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
@@ skipping 11 matching lines @@
     enum State {
         kPreWarmLoopsPerCanvasPreDraw_State,
         kPreWarmLoops_State,
         kTuneLoops_State,
         kPreWarmTimingPerCanvasPreDraw_State,
         kPreWarmTiming_State,
         kTiming_State,
     };
     void setTitle();
     bool setupBackend();
-    void resetContext();
     void setupRenderTarget();
-    bool onHandleChar(SkUnichar unichar) override;
     void printStats();
     bool advanceRecordIfNecessary(SkCanvas*);
     inline void renderFrame(SkCanvas*);
     inline void nextState(State);
     void perCanvasPreDraw(SkCanvas*, State);
     void preWarm(State nextState);
     void scaleLoops(double elapsedMs);
     inline void tuneLoops();
     inline void timing(SkCanvas*);
     inline double elapsed();
     void resetTimingState();
     void postDraw(SkCanvas*);
     void recordMeasurement();
 
     struct Record {
         SkTArray<double> fMeasurements;
     };
 
     int fCurrentSample;
     int fCurrentFrame;
     int fLoops;
     SkTArray<Record> fRecords;
     WallTimer fTimer;
     State fState;
     SkAutoTDelete<VisualBenchmarkStream> fBenchmarkStream;
     SkAutoTUnref<Benchmark> fBenchmark;
 
     // support framework
-    SkAutoTUnref<SkSurface> fSurface;
-    SkAutoTUnref<GrContext> fContext;
-    SkAutoTUnref<GrRenderTarget> fRenderTarget;
-    AttachmentInfo fAttachmentInfo;
-    SkAutoTUnref<const GrGLInterface> fInterface;
+    SkAutoTUnref<VisualBench> fOwner;
     SkAutoTDelete<ResultsWriter> fResults;
 
-    typedef SkOSWindow INHERITED;
+    typedef VisualModule INHERITED;
 };
 
 #endif