Refactor prepareToMeasureValuesAsync to startMeasureValuesAsyn which run test through callback

Motivation:
In order to support tracing metrics for prepareToMeasureValuesAsync method,
we need to be able to trigger tracing between prepareToMeasureValuesAsync &
actual test run. This CL rename prepareToMeasureValuesAsync method to
startMeasureValuesAsyn & refactor it  so that the
actual test code is specified as a callback, which allows the framework
to interject the startTrace() call before running test in the future.

BUG=701059

Review-Url: https://codereview.chromium.org/2858783003
Cr-Commit-Position: refs/heads/master@{#469233}

third_party/WebKit/PerformanceTests/Bindings/post-message.html

@@ -27,12 +27,12 @@ function testDone() {
 }
 
 window.onload = function () {
-    PerfTestRunner.prepareToMeasureValuesAsync({
+    PerfTestRunner.startMeasureValuesAsync({
         description: "Measures time to run 1000 postMessage round trips in serial.",
         unit: 'ms',
+        run: runTest,
         done: testDone,
     });
-    runTest();
 };
 </script>
 <div id="log"></div>

third_party/WebKit/PerformanceTests/Bindings/resources/structured-clone-perf-test.js

@@ -22,12 +22,13 @@ const StructuredClonePerfTestRunner = (function() {
   return {
     measureTimeAsync(test) {
       let isDone = false;
-      PerfTestRunner.prepareToMeasureValuesAsync({
+      PerfTestRunner.startMeasureValuesAsync({
         description: test.description,
         unit: 'ms',
         warmUpCount: test.warmUpCount || 10,
         iterationCount: test.iterationCount || 250,
         done() { isDone = true; },
+        run: pingPongUntilDone,
       });
 
       function pingPongUntilDone() {
@@ -40,7 +41,6 @@ const StructuredClonePerfTestRunner = (function() {
           if (!isDone) pingPongUntilDone();
         });
       }
-      pingPongUntilDone();
     },
   };
 })();

third_party/WebKit/PerformanceTests/BlinkGC/resources/measure-gc.js

@@ -14,9 +14,11 @@ if (!window.GCController && !window.gc)
             test.unit = 'ms';
         if (!test.warmUpCount)
             test.warmUpCount = warmUpCount;
+        if (!test.run)
+            test.run = function() {};
 
         completedIterations = 0;
-        PerfTestRunner.prepareToMeasureValuesAsync(test);
+        PerfTestRunner.startMeasureValuesAsync(test);
 
         // Force a V8 GC before running Blink GC test to avoid measuring marking from stale V8 wrappers.
         if (window.GCController)

third_party/WebKit/PerformanceTests/Canvas/resources/canvas_runner.js

@@ -9,14 +9,18 @@
     var CanvasRunner = {};
 
     CanvasRunner.start = function (test) {
-        PerfTestRunner.prepareToMeasureValuesAsync({unit: 'runs/s',
-            description: test.description, done: testDone});
-        if (!test.doRun) {
-            CanvasRunner.logFatalError("doRun must be set.");
-            return;
-        }
-        currentTest = test;
-        runTest();
+        PerfTestRunner.startMeasureValuesAsync({
+            unit: 'runs/s',
+            description: test.description,
+            done: testDone,
+            run: function() {
+                if (!test.doRun) {
+                    CanvasRunner.logFatalError("doRun must be set.");
+                    return;
+                }
+                currentTest = test;
+                runTest();
+            }});
     }
 
     function runTest() {

third_party/WebKit/PerformanceTests/Canvas/toBlob_duration.html

@@ -39,14 +39,16 @@ function runTest(myCanvas) {
 
 window.onload = function () {
     canvas_idle = createCanvas4kBy4k("canvas_idle");
-    PerfTestRunner.prepareToMeasureValuesAsync({
+    PerfTestRunner.startMeasureValuesAsync({
         unit: 'ms',
         done: function () {
             isDone = true;
         },
-        description: "Measures performance of canvas." 
+        run: function() {
+            runTest(canvas_idle);
+        },
+        description: "Measures performance of canvas."
     });
-    runTest(canvas_idle);
 };
 </script>
 </body>

third_party/WebKit/PerformanceTests/Canvas/toBlob_duration_jpeg.html

@@ -33,14 +33,16 @@ function runTest(myCanvas) {
 
 window.onload = function () {
     canvas_idle = createCanvas4k("canvas_idle");
-    PerfTestRunner.prepareToMeasureValuesAsync({
+    PerfTestRunner.startMeasureValuesAsync({
         unit: 'ms',
         done: function () {
             isDone = true;
         },
+        run: function() {
+            runTest(canvas_idle);
+        },
         description: "Measures performance of canvas."
     });
-    runTest(canvas_idle);
 };
 </script>
 </body>

third_party/WebKit/PerformanceTests/Dromaeo/resources/dromaeorunner.js

@@ -4,38 +4,39 @@
 
          setup: function(testName) {
              var ITERATION_COUNT = 5;
-             PerfTestRunner.prepareToMeasureValuesAsync({
+             PerfTestRunner.startMeasureValuesAsync({
                  iterationCount: ITERATION_COUNT,
                  doNotMeasureMemoryUsage: true,
                  doNotIgnoreInitialRun: true,
-                 unit: 'runs/s'
-             });
-
-             var iframe = document.createElement("iframe");
-             var url = DRT.baseURL + "?" + testName + '&numTests=' + ITERATION_COUNT;
-             iframe.setAttribute("src", url);
-             document.body.insertBefore(iframe, document.body.firstChild);
-             iframe.addEventListener(
-                 "load", function() {
-                     DRT.targetDocument = iframe.contentDocument;
-                     DRT.targetWindow = iframe.contentDocument.defaultView;
-                 });
+                 unit: 'runs/s',
+                 run: function() {
+                     var iframe = document.createElement("iframe");
+                     var url = DRT.baseURL + "?" + testName + '&numTests=' + ITERATION_COUNT;
+                     iframe.setAttribute("src", url);
+                     document.body.insertBefore(iframe, document.body.firstChild);
+                     iframe.addEventListener(
+                         "load", function() {
+                             DRT.targetDocument = iframe.contentDocument;
+                             DRT.targetWindow = iframe.contentDocument.defaultView;
+                         });
 
-             window.addEventListener(
-                 "message",
-                 function(event) {
-                     switch(event.data.name) {
-                     case "dromaeo:ready":
-                         DRT.start();
-                         break;
-                     case "dromaeo:progress":
-                         DRT.progress(event.data);
-                         break;
-                     case "dromaeo:alldone":
-                         DRT.teardown(event.data);
-                         break;
-                     }
-                 });
+                     window.addEventListener(
+                         "message",
+                         function(event) {
+                             switch(event.data.name) {
+                             case "dromaeo:ready":
+                                 DRT.start();
+                                 break;
+                             case "dromaeo:progress":
+                                 DRT.progress(event.data);
+                                 break;
+                             case "dromaeo:alldone":
+                                 DRT.teardown(event.data);
+                                 break;
+                             }
+                         });
+                   }
+             });
          },
 
          start: function() {

third_party/WebKit/PerformanceTests/Parser/html-parser-threaded.html

@@ -9,26 +9,29 @@ iframe.style.display = "none";  // Prevent creation of the rendering tree, so we
 iframe.sandbox = '';  // Prevent external script loads which could cause write() to return before completing the parse.
 document.body.appendChild(iframe);
 
-PerfTestRunner.prepareToMeasureValuesAsync({
-    description: "Measures performance of the threaded HTML parser (if available).",
-    done: onCompletedRun,
-    unit: 'ms'
-});
-
-iframe.onload = function() {
-    var now = PerfTestRunner.now();
-    PerfTestRunner.measureValueAsync(now - then);
-    then = now;
-    iframe.src = specURL;
-}
-var then = PerfTestRunner.now();
-iframe.src = specURL;
-
 function onCompletedRun() {
     iframe.onload = null;
     // FIXME: This should probably remove the iframe, but that currently
     // causes the threaded-parser to never send the load event for the main page.
     // document.body.removeChild(iframe);
 }
+
+
+PerfTestRunner.startMeasureValuesAsync({
+    description: "Measures performance of the threaded HTML parser (if available).",
+    done: onCompletedRun,
+    unit: 'ms',
+    run: function() {
+        iframe.onload = function() {
+            var now = PerfTestRunner.now();
+            PerfTestRunner.measureValueAsync(now - then);
+            then = now;
+            iframe.src = specURL;
+        }
+        var then = PerfTestRunner.now();
+        iframe.src = specURL;
+    }
+});
+
 </script>
 </body>

third_party/WebKit/PerformanceTests/resources/runner.js

@@ -145,7 +145,7 @@ if (window.testRunner) {
     };
 
     function start(test, scheduler, runner) {
-        if (!test) {
+        if (!test || !runner) {
             PerfTestRunner.logFatalError("Got a bad test object.");
             return;
         }
@@ -170,24 +170,36 @@ if (window.testRunner) {
         if (test.doNotIgnoreInitialRun)
             completedIterations++;
 
-        if (runner && test.tracingCategories && window.testRunner &&
-            window.testRunner.supportTracing) {
-            window.testRunner.startTracing(test.tracingCategories, function() {
+        if (!test.tracingCategories) {
+            scheduleNextRun(scheduler, runner);
+            return;
+        }
+
+        if (window.testRunner && window.testRunner.supportTracing) {
+            testRunner.startTracing(test.tracingCategories, function() {
                 scheduleNextRun(scheduler, runner);
             });
-        } else if (runner) {
-            if (test.tracingCategories && !(window.testRuner &&
-                  window.testRunner.supportTracing)) {
-                PerfTestRunner.log("Tracing based metrics are specified but " +
-                    "tracing is not supported on this platform. To get those " +
-                    "metrics from this test, you can run the test using " +
-                    "tools/perf/run_benchmarks script.");
-            }
-            scheduleNextRun(scheduler, runner);
+            return;
         }
+
+        PerfTestRunner.log("Tracing based metrics are specified but " +
+            "tracing is not supported on this platform. To get those " +
+            "metrics from this test, you can run the test using " +
+            "tools/perf/run_benchmarks script.");
+        scheduleNextRun(scheduler, runner);
     }
 
     function scheduleNextRun(scheduler, runner) {
+        if (!scheduler) {
+            // This is an async measurement test which has its own scheduler.
+            try {
+                runner();
+            } catch (exception) {
+                PerfTestRunner.logFatalError("Got an exception while running test.run with name=" + exception.name + ", message=" + exception.message);
+            }
+            return;
+        }
+
         scheduler(function () {
             // This will be used by tools/perf/benchmarks/blink_perf.py to find
             // traces during the measured runs.
@@ -264,9 +276,9 @@ if (window.testRunner) {
         }
     }
 
-    PerfTestRunner.prepareToMeasureValuesAsync = function (test) {
+    PerfTestRunner.startMeasureValuesAsync = function (test) {
         PerfTestRunner.unit = test.unit;
-        start(test);
+        start(test, undefined, function() { test.run() });
     }
 
     PerfTestRunner.measureValueAsync = function (measuredValue) {