Allow performance tests to test full rendering performance

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 119 matching lines @@
             logLines.push(text);
         else
             logInDocument(text);
     }
 
     PerfTestRunner.logFatalError = function (text) {
         PerfTestRunner.log(text);
         finish();
     }
 
+    PerfTestRunner.forceLayout = function(doc) {
+        doc = doc || document;
+        // Forcing full layout is only fully feasible when window.internals is available.

[leviw_travelin_and_unemployed, 2014/10/30 20:33:53]

I don't think this naming is right. Simply calling offsetTop *does* force a
layout. You can have many layouts in a frame without a compositing update, and
for better or worse that happens with some frequency in the wild. You're calling
this forceLayout, but you're really forcing a layout, a compositing update, and
an invalidation. This means running the state machine *most* of the way through
a frame, but not through rasterization (which is what differentiates this from a
rAF, along with synchronization).

[Xianzhu, 2014/10/30 21:29:12]

I'm not sure what the correct name is. I thought styleRecalc, updateRenderTree,
layout, compositing update and invalidation were all parts of 'full-layout'
(before we get a better name, please allow me to use this term temporarily just
for discussion :) ), and separation of them were implementation-specific. In our
code, 'layout' seems to also mean the 'full layout', e.g. WebView::layout().
From the tests' point of view, PerfTestRunner.forceLayout() forces a layout,
which can be Document::updateLayout() or WebView::layout(), depending on the
value of window.fullLayoutMeasurement.

Thought of 'fullDocumentCycle' (corresponding to DocumentLifecycle), but that
seems to be too implementation-specific and not clear to whom are not familiar
with blink implementation.

The problem of rAF for these tests is that most of the tests run less than 10ms
for a single iteration which rAF couldn't measure them accurately. We could use
the method of JsGameBench which increases the complexity of the page until FPS
drops under 30fps, but that needs changes to the existing benchmarks and seems
not suitable for all tests.

Anyway, I'll hold off on this patch until we get a name agreed.

+        if (window.fullLayoutMeasurement) {
+            if (window.internals)
+                internals.forceCompositingUpdate(doc);
+            else
+                PerfTestRunner.logFatalError('window.internals API is required for full layout measurement.');
+            return;
+        }
+
+        // Otherwise just force style recalc and layout without compositing update and paint invalidation.
+        if (doc.body)
+            doc.body.offsetHeight;
+        else if (doc.documentElement)
+            doc.documentElement.offsetHeight;
+    };
+
     function start(test, 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);
         logLines = window.testRunner ? [] : null;
@@ skipping 154 matching lines @@
             var iframe = document.createElement("iframe");
             document.body.appendChild(iframe);
 
             iframe.sandbox = '';  // Prevent external loads which could cause write() to return before completing the parse.
             iframe.style.width = "600px"; // Have a reasonable size so we're not line-breaking on every character.
             iframe.style.height = "800px";
             iframe.contentDocument.open();
 
             for (var chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                 iframe.contentDocument.write(chunks[chunkIndex]);
-                // Note that we won't cause a style resolve until we've encountered the <body> element.
-                // Thus the number of chunks counted above is not exactly equal to the number of style resolves.
-                if (iframe.contentDocument.body)
-                    iframe.contentDocument.body.clientHeight; // Force a full layout/style-resolve.
-                else if (iframe.documentElement.localName == 'html')
-                    iframe.contentDocument.documentElement.offsetWidth; // Force the painting.
+                PerfTestRunner.forceLayout(iframe.contentDocument);
             }
 
             iframe.contentDocument.close();
             document.body.removeChild(iframe);
         };
 
         PerfTestRunner.measureTime(test);
     }
 
     window.PerfTestRunner = PerfTestRunner;
 })();