The Tor Browser: comparison testing/mochitest/tests/SimpleTest/ChromeUtils.js

comparison: testing/mochitest/tests/SimpleTest/ChromeUtils.js

testing/mochitest/tests/SimpleTest/ChromeUtils.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:be1c63a75e1b
+/**
+* ChromeUtils.js is a set of mochitest utilities that are used to
+* synthesize events in the browser.  These are only used by
+* mochitest-chrome and browser-chrome tests.  Originally these functions were in
+* EventUtils.js, but when porting to specialPowers, we didn't want
+* to move unnecessary functions.
+*
+*/
+const EventUtils = {};
+const scriptLoader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"].
+getService(Components.interfaces.mozIJSSubScriptLoader);
+scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/EventUtils.js", EventUtils);
+/**
+* Synthesize a query text content event.
+*
+* @param aOffset  The character offset.  0 means the first character in the
+*                 selection root.
+* @param aLength  The length of getting text.  If the length is too long,
+*                 the extra length is ignored.
+* @param aWindow  Optional (If null, current |window| will be used)
+* @return         An nsIQueryContentEventResult object.  If this failed,
+*                 the result might be null.
+*/
+function synthesizeQueryTextContent(aOffset, aLength, aWindow)
+{
+var utils = _getDOMWindowUtils(aWindow);
+if (!utils) {
+return nullptr;
+}
+return utils.sendQueryContentEvent(utils.QUERY_TEXT_CONTENT,
+aOffset, aLength, 0, 0,
+QUERY_CONTENT_FLAG_USE_NATIVE_LINE_BREAK);
+}
+/**
+* Synthesize a query text rect event.
+*
+* @param aOffset  The character offset.  0 means the first character in the
+*                 selection root.
+* @param aLength  The length of the text.  If the length is too long,
+*                 the extra length is ignored.
+* @param aWindow  Optional (If null, current |window| will be used)
+* @return         An nsIQueryContentEventResult object.  If this failed,
+*                 the result might be null.
+*/
+function synthesizeQueryTextRect(aOffset, aLength, aWindow)
+{
+var utils = _getDOMWindowUtils(aWindow);
+if (!utils) {
+return nullptr;
+}
+return utils.sendQueryContentEvent(utils.QUERY_TEXT_RECT,
+aOffset, aLength, 0, 0,
+QUERY_CONTENT_FLAG_USE_NATIVE_LINE_BREAK);
+}
+/**
+* Synthesize a query editor rect event.
+*
+* @param aWindow  Optional (If null, current |window| will be used)
+* @return         An nsIQueryContentEventResult object.  If this failed,
+*                 the result might be null.
+*/
+function synthesizeQueryEditorRect(aWindow)
+{
+var utils = _getDOMWindowUtils(aWindow);
+if (!utils) {
+return nullptr;
+}
+return utils.sendQueryContentEvent(utils.QUERY_EDITOR_RECT, 0, 0, 0, 0,
+QUERY_CONTENT_FLAG_USE_NATIVE_LINE_BREAK);
+}
+/**
+* Synthesize a character at point event.
+*
+* @param aX, aY   The offset in the client area of the DOM window.
+* @param aWindow  Optional (If null, current |window| will be used)
+* @return         An nsIQueryContentEventResult object.  If this failed,
+*                 the result might be null.
+*/
+function synthesizeCharAtPoint(aX, aY, aWindow)
+{
+var utils = _getDOMWindowUtils(aWindow);
+if (!utils) {
+return nullptr;
+}
+return utils.sendQueryContentEvent(utils.QUERY_CHARACTER_AT_POINT,
+0, 0, aX, aY,
+QUERY_CONTENT_FLAG_USE_NATIVE_LINE_BREAK);
+}
+/**
+* Emulate a dragstart event.
+*  element - element to fire the dragstart event on
+*  expectedDragData - the data you expect the data transfer to contain afterwards
+*                      This data is in the format:
+*                         [ [ {type: value, data: value, test: function}, ... ], ... ]
+*                     can be null
+*  aWindow - optional; defaults to the current window object.
+*  x - optional; initial x coordinate
+*  y - optional; initial y coordinate
+* Returns null if data matches.
+* Returns the event.dataTransfer if data does not match
+*
+* eqTest is an optional function if comparison can't be done with x == y;
+*   function (actualData, expectedData) {return boolean}
+*   @param actualData from dataTransfer
+*   @param expectedData from expectedDragData
+* see bug 462172 for example of use
+*
+*/
+function synthesizeDragStart(element, expectedDragData, aWindow, x, y)
+{
+if (!aWindow)
+aWindow = window;
+x = x || 2;
+y = y || 2;
+const step = 9;
+var result = "trapDrag was not called";
+var trapDrag = function(event) {
+try {
+var dataTransfer = event.dataTransfer;
+result = null;
+if (!dataTransfer)
+throw "no dataTransfer";
+if (expectedDragData == null ||
+dataTransfer.mozItemCount != expectedDragData.length)
+throw dataTransfer;
+for (var i = 0; i < dataTransfer.mozItemCount; i++) {
+var dtTypes = dataTransfer.mozTypesAt(i);
+if (dtTypes.length != expectedDragData[i].length)
+throw dataTransfer;
+for (var j = 0; j < dtTypes.length; j++) {
+if (dtTypes[j] != expectedDragData[i][j].type)
+throw dataTransfer;
+var dtData = dataTransfer.mozGetDataAt(dtTypes[j],i);
+if (expectedDragData[i][j].eqTest) {
+if (!expectedDragData[i][j].eqTest(dtData, expectedDragData[i][j].data))
+throw dataTransfer;
+}
+else if (expectedDragData[i][j].data != dtData)
+throw dataTransfer;
+}
+}
+} catch(ex) {
+result = ex;
+}
+event.preventDefault();
+event.stopPropagation();
+}
+aWindow.addEventListener("dragstart", trapDrag, false);
+EventUtils.synthesizeMouse(element, x, y, { type: "mousedown" }, aWindow);
+x += step; y += step;
+EventUtils.synthesizeMouse(element, x, y, { type: "mousemove" }, aWindow);
+x += step; y += step;
+EventUtils.synthesizeMouse(element, x, y, { type: "mousemove" }, aWindow);
+aWindow.removeEventListener("dragstart", trapDrag, false);
+EventUtils.synthesizeMouse(element, x, y, { type: "mouseup" }, aWindow);
+return result;
+}
+/**
+* Emulate a drop by emulating a dragstart and firing events dragenter, dragover, and drop.
+*  srcElement - the element to use to start the drag, usually the same as destElement
+*               but if destElement isn't suitable to start a drag on pass a suitable
+*               element for srcElement
+*  destElement - the element to fire the dragover, dragleave and drop events
+*  dragData - the data to supply for the data transfer
+*                     This data is in the format:
+*                       [ [ {type: value, data: value}, ...], ... ]
+*  dropEffect - the drop effect to set during the dragstart event, or 'move' if null
+*  aWindow - optional; defaults to the current window object.
+*  aDestWindow - optional; defaults to aWindow.
+*                Used when destElement is in a different window than srcElement.
+*
+* Returns the drop effect that was desired.
+*/
+function synthesizeDrop(srcElement, destElement, dragData, dropEffect, aWindow, aDestWindow)
+{
+if (!aWindow)
+aWindow = window;
+if (!aDestWindow)
+aDestWindow = aWindow;
+var gWindowUtils = aDestWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor).
+getInterface(Components.interfaces.nsIDOMWindowUtils);
+var ds = Components.classes["@mozilla.org/widget/dragservice;1"].
+getService(Components.interfaces.nsIDragService);
+var dataTransfer;
+var trapDrag = function(event) {
+dataTransfer = event.dataTransfer;
+for (var i = 0; i < dragData.length; i++) {
+var item = dragData[i];
+for (var j = 0; j < item.length; j++) {
+dataTransfer.mozSetDataAt(item[j].type, item[j].data, i);
+}
+}
+dataTransfer.dropEffect = dropEffect || "move";
+event.preventDefault();
+event.stopPropagation();
+}
+ds.startDragSession();
+try {
+// need to use real mouse action
+aWindow.addEventListener("dragstart", trapDrag, true);
+EventUtils.synthesizeMouseAtCenter(srcElement, { type: "mousedown" }, aWindow);
+var rect = srcElement.getBoundingClientRect();
+var x = rect.width / 2;
+var y = rect.height / 2;
+EventUtils.synthesizeMouse(srcElement, x, y, { type: "mousemove" }, aWindow);
+EventUtils.synthesizeMouse(srcElement, x+10, y+10, { type: "mousemove" }, aWindow);
+aWindow.removeEventListener("dragstart", trapDrag, true);
+event = aDestWindow.document.createEvent("DragEvents");
+event.initDragEvent("dragenter", true, true, aDestWindow, 0, 0, 0, 0, 0, false, false, false, false, 0, null, dataTransfer);
+gWindowUtils.dispatchDOMEventViaPresShell(destElement, event, true);
+var event = aDestWindow.document.createEvent("DragEvents");
+event.initDragEvent("dragover", true, true, aDestWindow, 0, 0, 0, 0, 0, false, false, false, false, 0, null, dataTransfer);
+if (gWindowUtils.dispatchDOMEventViaPresShell(destElement, event, true)) {
+EventUtils.synthesizeMouseAtCenter(destElement, { type: "mouseup" }, aDestWindow);
+return "none";
+}
+if (dataTransfer.dropEffect != "none") {
+event = aDestWindow.document.createEvent("DragEvents");
+event.initDragEvent("drop", true, true, aDestWindow, 0, 0, 0, 0, 0, false, false, false, false, 0, null, dataTransfer);
+gWindowUtils.dispatchDOMEventViaPresShell(destElement, event, true);
+}
+EventUtils.synthesizeMouseAtCenter(destElement, { type: "mouseup" }, aDestWindow);
+return dataTransfer.dropEffect;
+} finally {
+ds.endDragSession(true);
+}
+};
+var PluginUtils =
+{
+withTestPlugin : function(callback)
+{
+if (typeof Components == "undefined")
+{
+todo(false, "Not a Mozilla-based browser");
+return false;
+}
+var ph = Components.classes["@mozilla.org/plugin/host;1"]
+.getService(Components.interfaces.nsIPluginHost);
+var tags = ph.getPluginTags();
+// Find the test plugin
+for (var i = 0; i < tags.length; i++)
+{
+if (tags[i].name == "Test Plug-in")
+{
+callback(tags[i]);
+return true;
+}
+}
+todo(false, "Need a test plugin on this platform");
+return false;
+}
+};