Factor out VisualBench timing code into a helper class

tools/VisualBench/VisualBenchmarkStream.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 <VisualBench/VisualBenchmarkStream.h>
 #include "CpuWrappedBenchmark.h"
 #include "GMBench.h"
 #include "SkOSFile.h"
+#include "SkPath.h"
 #include "SkPictureRecorder.h"
 #include "SkStream.h"
+#include "sk_tool_utils.h"
 #include "VisualSKPBench.h"
 
 DEFINE_bool(cpu, false, "Run in CPU mode?");
 DEFINE_string2(match, m, nullptr,
                "[~][^]substring[$] [...] of bench name to run.\n"
                "Multiple matches may be separated by spaces.\n"
                "~ causes a matching bench to always be skipped\n"
                "^ requires the start of the bench to match\n"
                "$ requires the end of the bench to match\n"
                "^ and $ requires an exact match\n"
                "If a bench does not match any list entry,\n"
                "it is skipped unless some list entry starts with ~");
 DEFINE_string(skps, "skps", "Directory to read skps from.");
 
+// We draw a big nonAA path to warmup the gpu / cpu
+#include "SkPerlinNoiseShader.h"
+class WarmupBench : public Benchmark {
+public:
+    WarmupBench() {
+        sk_tool_utils::make_big_path(fPath);
+    }
+private:
+    const char* onGetName() override { return "warmupbench"; }
+    void onDraw(int loops, SkCanvas* canvas) override {
+        // We draw a big path to warm up the cpu, and then use perlin noise shader to warm up the
+        // gpu
+        SkPaint paint;
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(2);
+
+        SkPaint perlinPaint;
+        perlinPaint.setShader(SkPerlinNoiseShader::CreateTurbulence(0.1f, 0.1f, 1, 0,
+                                                                    nullptr))->unref();
+        SkRect rect = SkRect::MakeLTRB(0., 0., 400., 400.);
+        for (int i = 0; i < loops; i++) {
+            canvas->drawPath(fPath, paint);
+            canvas->drawRect(rect, perlinPaint);
+        }
+    }
+    SkPath fPath;
+};
+
 VisualBenchmarkStream::VisualBenchmarkStream()
     : fBenches(BenchRegistry::Head())
     , fGMs(skiagm::GMRegistry::Head())
     , fSourceType(nullptr)
     , fBenchType(nullptr)
-    , fCurrentSKP(0) {
+    , fCurrentSKP(0)
+    , fIsWarmedUp(false) {
     for (int i = 0; i < FLAGS_skps.count(); i++) {
         if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
             fSKPs.push_back() = FLAGS_skps[i];
         } else {
             SkOSFile::Iter it(FLAGS_skps[i], ".skp");
             SkString path;
             while (it.next(&path)) {
                 fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
             }
         }
@@ skipping 15 matching lines @@
 
     pic->reset(SkPicture::CreateFromStream(stream.get()));
     if (pic->get() == nullptr) {
         SkDebugf("Could not read %s as an SkPicture.\n", path);
         return false;
     }
     return true;
 }
 
 Benchmark* VisualBenchmarkStream::next() {
+    if (!fIsWarmedUp) {
+        fIsWarmedUp = true;
+        return new WarmupBench;
+    }
+
     Benchmark* bench;
+
     // skips non matching benches
     while ((bench = this->innerNext()) &&
            (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName()) ||
             !bench->isSuitableFor(Benchmark::kGPU_Backend))) {
         bench->unref();
     }
     if (FLAGS_cpu) {
         return new CpuWrappedBenchmark(bench);
     }
     return bench;
@@ skipping 30 matching lines @@
         }
 
         SkString name = SkOSPath::Basename(path.c_str());
         fSourceType = "skp";
         fBenchType = "playback";
         return new VisualSKPBench(name.c_str(), pic.get());
     }
 
     return nullptr;
 }