config: chrome/pageloader.js comparison

comparison chrome/pageloader.js @ 202:0b38ce037298

Bug 661918 - Tp should wait for MozAfterPaint after onload. r=tnikkel,vlad

author	Joel Maher <jmaher@mozilla.com>
date	Wed, 14 Sep 2011 16:41:38 -0400
parents	bffb8b1b0948
children	4dec1e56c677

comparison

equal deleted inserted replaced

-:bffb8b1b0948
+:0b38ce037298
 var delay = 250;
 var timeoutEvent = -1;
 var running = false;
 var forceCC = true;
+var useMozAfterPaint = false;
+var gPaintWindow = window;
+var gPaintListener = false;
+//when TEST_DOES_OWN_TIMING, we need to store the time from the page as MozAfterPaint can be slower than pageload
+var gTime = -1;
+var gStartTime = -1;
 var content;
 var TEST_DOES_OWN_TIMING = 1;
 var browserWindow = null;
 if (args.height) winHeight = parseInt(args.height);
 if (args.filter) pageFilterRegexp = new RegExp(args.filter);
 if (args.noisy) noisy = true;
 if (args.timeout) timeout = parseInt(args.timeout);
 if (args.delay) delay = parseInt(args.delay);
+if (args.mozafterpaint) useMozAfterPaint = true;
 forceCC = !args.noForceCC;
 doRenderTest = args.doRender;
 if (forceCC &&
 !window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
 blank.data = "about:blank";
 browserWindow = wwatch.openWindow
 (null, "chrome://browser/content/", "_blank",
 "chrome,all,dialog=no,width=" + winWidth + ",height=" + winHeight, blank);
+gPaintWindow = browserWindow;
 // get our window out of the way
 window.resizeTo(10,10);
 var browserLoadFunc = function (ev) {
 browserWindow.removeEventListener('load', browserLoadFunc, true);
 content = browserWindow.getBrowser();
 // Load the frame script for e10s / IPC message support
 if (content.getAttribute("remote") == "true") {
-let contentScript = "data:,addEventListener('load', function(e) { " +
+let contentScript = "data:,function _contentLoadHandler(e) { " +
 "  if (e.originalTarget.defaultView == content) { " +
-"    sendAsyncMessage('PageLoader:Load', {}); " +
+"    content.wrappedJSObject.tpRecordTime = function(t, s) { sendAsyncMessage('PageLoader:RecordTime', { time: t, startTime: s }); }; ";
-"    content.wrappedJSObject.tpRecordTime = function(t) { sendAsyncMessage('PageLoader:RecordTime', { time: t }); } " +
+if (useMozAfterPaint) {
+contentScript += "" +
+"function _contentPaintHandler() { " +
+"  var utils = content.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIDOMWindowUtils); " +
+"  if (utils.isMozAfterPaintPending) { " +
+"    addEventListener('MozAfterPaint', function(e) { " +
+"      removeEventListener('MozAfterPaint', arguments.callee, true); " +
+"      sendAsyncMessage('PageLoader:MozAfterPaint', {}); " +
+"    }, true); " +
+"  } else { " +
+"    sendAsyncMessage('PageLoader:MozAfterPaint', {}); " +
+"  } " +
+"}; " +
+"content.wrappedJSObject.setTimeout(_contentPaintHandler, 0); ";
+} else {
+contentScript += "    sendAsyncMessage('PageLoader:Load', {}); ";
+}
+contentScript += "" +
 "  }" +
-"}, true);"
+"} " +
+"addEventListener('load', _contentLoadHandler, true); ";
 content.messageManager.loadFrameScript(contentScript, false);
 }
 setTimeout(plLoadPage, 100);
 }, 500);
 };
 browserWindow.addEventListener('load', browserLoadFunc, true);
 } else {
+gPaintWindow = window;
 window.resizeTo(winWidth, winHeight);
 content = document.getElementById('contentPageloader');
 setTimeout(plLoadPage, delay);
 removeLastAddedMsgListener();
 if (plPageFlags() & TEST_DOES_OWN_TIMING) {
 // if the page does its own timing, use a capturing handler
 // to make sure that we can set up the function for content to call
 content.addEventListener('load', plLoadHandlerCapturing, true);
 removeLastAddedListener = function() {
 content.removeEventListener('load', plLoadHandlerCapturing, true);
+if (useMozAfterPaint) {
+content.removeEventListener("MozAfterPaint", plPaintedCapturing, true);
+gPaintHandler = false;
+}
 };
 } else {
 // if the page doesn't do its own timing, use a bubbling handler
 // to make sure that we're called after the page's own onload() handling
 // XXX we use a capturing event here too -- load events don't bubble up
 // to the <browser> element.  See bug 390263.
 content.addEventListener('load', plLoadHandler, true);
 removeLastAddedListener = function() {
 content.removeEventListener('load', plLoadHandler, true);
+if (useMozAfterPaint) {
+gPaintWindow.removeEventListener("MozAfterPaint", plPainted, true);
+gPaintHandler = false;
+}
 };
 }
 // If the test browser is remote (e10s / IPC) we need to use messages to watch for page load
 if (content.getAttribute("remote") == "true") {
 content.messageManager.addMessageListener('PageLoader:Load', plLoadHandlerMessage);
 content.messageManager.addMessageListener('PageLoader:RecordTime', plRecordTimeMessage);
+if (useMozAfterPaint)
+content.messageManager.addMessageListener('PageLoader:MozAfterPaint', plPaintHandler);
 removeLastAddedMsgListener = function() {
 content.messageManager.removeMessageListener('PageLoader:Load', plLoadHandlerMessage);
 content.messageManager.removeMessageListener('PageLoader:RecordTime', plRecordTimeMessage);
+if (useMozAfterPaint)
+content.messageManager.removeMessageListener('PageLoader:MozAfterPaint', plPaintHandler);
 };
 }
 if (timeout > 0) {
 timeoutEvent = setTimeout('loadFail()', timeout);
 function plLoadHandlerCapturing(evt) {
 // make sure we pick up the right load event
 if (evt.type != 'load' ||
 evt.originalTarget.defaultView.frameElement)
 return;
+//set the tpRecordTime function (called from test pages we load to store a global time.
+content.contentWindow.wrappedJSObject.tpRecordTime = function (time, startTime) {
+gTime = time;
+gStartTime = startTime;
+setTimeout(plWaitForPaintingCapturing, 0);
+}
+content.removeEventListener('load', plLoadHandlerCapturing, true);
+setTimeout(plWaitForPaintingCapturing, 0);
+}
+function plWaitForPaintingCapturing() {
+if (gPaintListener)
+return;
+var utils = gPaintWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+.getInterface(Components.interfaces.nsIDOMWindowUtils);
+if (utils.isMozAfterPaintPending && useMozAfterPaint) {
+if (gPaintListener == false)
+gPaintWindow.addEventListener("MozAfterPaint", plPaintedCapturing, true);
+gPaintListener = true;
+return;
+}
+_loadHandlerCapturing();
+}
+function plPaintedCapturing() {
+gPaintWindow.removeEventListener("MozAfterPaint", plPaintedCapturing, true);
+gPaintListener = false;
+_loadHandlerCapturing();
+}
+function _loadHandlerCapturing() {
 if (timeout > 0) {
 clearTimeout(timeoutEvent);
 }
 if (!(plPageFlags() & TEST_DOES_OWN_TIMING)) {
 dumpLine("tp: Capturing onload handler used with page that doesn't do its own timing?");
 plStop(true);
 }
+if (useMozAfterPaint) {
+if (gStartTime != null && gStartTime >= 0) {
+gTime = (new Date()) - gStartTime;
+gStartTime = -1;
+}
+}
 // set up the function for content to call
-content.contentWindow.wrappedJSObject.tpRecordTime = function (time) {
+if (gTime >= 0) {
-plRecordTime(time);
+plRecordTime(gTime);
+gTime = -1;
 setTimeout(plNextPage, delay);
 };
 }
 // the onload handler
 function plLoadHandler(evt) {
 // make sure we pick up the right load event
 if (evt.type != 'load' ||
 evt.originalTarget.defaultView.frameElement)
 return;
+content.removeEventListener('load', plLoadHandler, true);
+setTimeout(waitForPainted, 0);
+}
+// This is called after we have received a load event, now we wait for painted
+function waitForPainted() {
+var utils = gPaintWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+.getInterface(Components.interfaces.nsIDOMWindowUtils);
+if (!utils.isMozAfterPaintPending || !useMozAfterPaint) {
+_loadHandler();
+return;
+}
+if (gPaintListener == false)
+gPaintWindow.addEventListener("MozAfterPaint", plPainted, true);
+gPaintListener = true;
+}
+function plPainted() {
+gPaintWindow.removeEventListener("MozAfterPaint", plPainted, true);
+gPaintListener = false;
+_loadHandler();
+}
+function _loadHandler() {
 if (timeout > 0) {
 clearTimeout(timeoutEvent);
 }
 var docElem;
 if (browserWindow)
 plNextPage();
 }
 // the onload handler used for remote (e10s) browser
 function plLoadHandlerMessage(message) {
+_loadHandlerMessage();
+}
+// the mozafterpaint handler for remote (e10s) browser
+function plPaintHandler(message) {
+_loadHandlerMessage();
+}
+// the core handler for remote (e10s) browser
+function _loadHandlerMessage() {
 if (timeout > 0) {
 clearTimeout(timeoutEvent);
 }
+var time = -1;
 // does this page want to do its own timing?
-// if so, let's bail
+if ((plPageFlags() & TEST_DOES_OWN_TIMING)) {
-if (plPageFlags() & TEST_DOES_OWN_TIMING)
+if (typeof(gStartTime) != "number")
-return;
+gStartTime = Date.parse(gStartTime);
-var end_time = Date.now();
+if (gTime >= 0) {
-var time = (end_time - start_time);
+if (useMozAfterPaint && gStartTime >= 0) {
+gTime = Date.now() - gStartTime;
-plRecordTime(time);
+gStartTime = -1;
+} else if (useMozAfterPaint) {
-if (doRenderTest)
+gTime = -1;
-runRenderTest();
+}
+time = gTime;
-plNextPage();
+gTime = -1;
+}
+} else {
+var end_time = Date.now();
+time = (end_time - start_time);
+}
+if (time >= 0) {
+plRecordTime(time);
+if (doRenderTest)
+runRenderTest();
+plNextPage();
+}
 }
 // the record time handler used for remote (e10s) browser
 function plRecordTimeMessage(message) {
-plRecordTime(message.json.time);
+gTime = message.json.time;
-setTimeout(plNextPage, delay);
+if (useMozAfterPaint) {
+gStartTime = message.json.startTime;
+}
+_loadHandlerMessage();
 }
 function runRenderTest() {
 const redrawsPerSample = 500;
 } catch (e) {
 dumpLine(e);
 }
 if (content) {
+content.removeEventListener('load', plLoadHandlerCapturing, true);
 content.removeEventListener('load', plLoadHandler, true);
-if (content.getAttribute("remote") == "true")
+if (useMozAfterPaint)
+content.removeEventListener("MozAfterPaint", plPaintedCapturing, true);
+content.removeEventListener("MozAfterPaint", plPainted, true);
+if (content.getAttribute("remote") == "true") {
 content.messageManager.removeMessageListener('PageLoader:Load', plLoadHandlerMessage);
+content.messageManager.removeMessageListener('PageLoader:RecordTime', plRecordTimeMessage);
+if (MozAfterPaint)
+content.messageManager.removeMessageListener('PageLoader:MozAfterPaint', plPaintHandler);
+content.messageManager.loadFrameScript("data:,removeEventListener('load', _contentLoadHandler, true);", false);
+}
 }
 if (MozillaFileLogger)
 MozillaFileLogger.close();