Add performance tests for full frame cycle

third_party/WebKit/PerformanceTests/resources/runner.js

 // There are tests for computeStatistics() located in LayoutTests/fast/harness/perftests
 
 if (window.testRunner) {
     testRunner.waitUntilDone();
     testRunner.dumpAsText();
 }
 
 (function () {
     var logLines = null;
     var completedIterations = -1;
@@ skipping 127 matching lines @@
     }
 
     PerfTestRunner.forceLayout = function(doc) {
         doc = doc || document;
         if (doc.body)
             doc.body.offsetHeight;
         else if (doc.documentElement)
             doc.documentElement.offsetHeight;
     };
 
-    function start(test, runner) {
+    function start(test, scheduler, runner) {
         if (!test) {
             PerfTestRunner.logFatalError("Got a bad test object.");
             return;
         }
         currentTest = test;
         // FIXME: We should be using multiple instances of test runner on Dromaeo as well but it's too slow now.
         // FIXME: Don't hard code the number of in-process iterations to use inside a test runner.
         iterationCount = test.dromaeoIterationCount || (window.testRunner ? 5 : 20);
         if (test.warmUpCount && test.warmUpCount > 0)
             completedIterations = -test.warmUpCount;
         logLines = window.testRunner ? [] : null;
         PerfTestRunner.log("Running " + iterationCount + " times");
         if (test.doNotIgnoreInitialRun)
             completedIterations++;
         if (runner)
-            scheduleNextRun(runner);
+            scheduleNextRun(scheduler, runner);
     }
 
-    function scheduleNextRun(runner) {
+    function scheduleNextRun(scheduler, runner) {
         PerfTestRunner.gc();
-        window.setTimeout(function () {
+        scheduler(function () {
             try {
                 if (currentTest.setup)
                     currentTest.setup();
 
                 var measuredValue = runner();
             } catch (exception) {
                 PerfTestRunner.logFatalError("Got an exception while running test.run with name=" + exception.name + ", message=" + exception.message);
                 return;
             }
 
             completedIterations++;
 
             try {
                 ignoreWarmUpAndLog(measuredValue);
             } catch (exception) {
                 PerfTestRunner.logFatalError("Got an exception while logging the result with name=" + exception.name + ", message=" + exception.message);
                 return;
             }
 
             if (completedIterations < iterationCount)
-                scheduleNextRun(runner);
+                scheduleNextRun(scheduler, runner);
             else
                 finish();
-        }, 0);
+        });
     }
 
     function ignoreWarmUpAndLog(measuredValue) {
         var labeledResult = measuredValue + " " + PerfTestRunner.unit;
         if (completedIterations <= 0)
             PerfTestRunner.log("Ignoring warm-up run (" + labeledResult + ")");
         else {
             results.push(measuredValue);
             if (window.internals && !currentTest.doNotMeasureMemoryUsage) {
                 jsHeapResults.push(getUsedJSHeap());
@@ skipping 34 matching lines @@
             ignoreWarmUpAndLog(measuredValue);
         } catch (exception) {
             PerfTestRunner.logFatalError("Got an exception while logging the result with name=" + exception.name + ", message=" + exception.message);
             return;
         }
 
         if (completedIterations >= iterationCount)
             finish();
     }
 
+    PerfTestRunner.measureFrameTime = function (test) {
+        PerfTestRunner.unit = "ms";
+        start(test, requestAnimationFrame, measureFrameTimeOnce);
+    }
+
+    var lastFrameTime = -1;
+    function measureFrameTimeOnce() {
+        var now = PerfTestRunner.now();
+        var result = lastFrameTime == -1 ? -1 : now - lastFrameTime;
+        lastFrameTime = now;
+
+        var returnValue = currentTest.run();
+        if (returnValue - 0 === returnValue) {
+            if (returnValue < 0)
+                PerfTestRunner.log("runFunction returned a negative value: " + returnValue);
+            return returnValue;
+        }
+
+        return result;
+    }
+
     PerfTestRunner.measureTime = function (test) {
         PerfTestRunner.unit = "ms";
-        start(test, measureTimeOnce);
+        start(test, zeroTimeoutScheduler, measureTimeOnce);
+    }
+
+    function zeroTimeoutScheduler(task) {
+        setTimeout(task, 0);
     }
 
     function measureTimeOnce() {
         var start = PerfTestRunner.now();
         var returnValue = currentTest.run();
         var end = PerfTestRunner.now();
 
         if (returnValue - 0 === returnValue) {
             if (returnValue < 0)
                 PerfTestRunner.log("runFunction returned a negative value: " + returnValue);
             return returnValue;
         }
 
         return end - start;
     }
 
     PerfTestRunner.measureRunsPerSecond = function (test) {
         PerfTestRunner.unit = "runs/s";
-        start(test, measureRunsPerSecondOnce);
+        start(test, zeroTimeoutScheduler, measureRunsPerSecondOnce);
     }
 
     function measureRunsPerSecondOnce() {
         var timeToRun = 750;
         var totalTime = 0;
         var numberOfRuns = 0;
 
         while (totalTime < timeToRun) {
             totalTime += callRunAndMeasureTime(callsPerIteration);
             numberOfRuns += callsPerIteration;
@@ skipping 46 matching lines @@
 
             iframe.contentDocument.close();
             document.body.removeChild(iframe);
         };
 
         PerfTestRunner.measureTime(test);
     }
 
     window.PerfTestRunner = PerfTestRunner;
 })();