2014-03-29 21:01:37 +04:00
|
|
|
/* Any copyright is dedicated to the Public Domain.
|
|
|
|
http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
"use strict";
|
|
|
|
|
2015-10-07 15:03:21 +03:00
|
|
|
var { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
|
2014-03-29 21:01:37 +04:00
|
|
|
|
2016-05-17 21:25:54 +03:00
|
|
|
var { generateUUID } = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator);
|
2015-10-14 02:18:43 +03:00
|
|
|
var { require } = Cu.import("resource://devtools/shared/Loader.jsm", {});
|
2015-09-15 21:19:45 +03:00
|
|
|
|
2016-02-27 15:51:10 +03:00
|
|
|
var Services = require("Services");
|
2015-09-15 21:19:45 +03:00
|
|
|
var promise = require("promise");
|
2016-02-11 15:29:47 +03:00
|
|
|
var { gDevTools } = require("devtools/client/framework/devtools");
|
2015-09-21 20:04:18 +03:00
|
|
|
var { DebuggerClient } = require("devtools/shared/client/main");
|
2015-09-15 21:19:45 +03:00
|
|
|
var { DebuggerServer } = require("devtools/server/main");
|
2016-06-03 20:45:10 +03:00
|
|
|
var { CallWatcherFront } = require("devtools/shared/fronts/call-watcher");
|
2016-06-03 20:45:10 +03:00
|
|
|
var { CanvasFront } = require("devtools/shared/fronts/canvas");
|
2015-09-15 21:19:45 +03:00
|
|
|
var { setTimeout } = require("sdk/timers");
|
2015-09-21 20:04:18 +03:00
|
|
|
var DevToolsUtils = require("devtools/shared/DevToolsUtils");
|
2016-08-06 00:41:01 +03:00
|
|
|
var flags = require("devtools/shared/flags");
|
2015-09-21 20:04:18 +03:00
|
|
|
var { TargetFactory } = require("devtools/client/framework/target");
|
|
|
|
var { Toolbox } = require("devtools/client/framework/toolbox");
|
2016-03-03 13:27:22 +03:00
|
|
|
var { isWebGLSupported } = require("devtools/client/shared/webgl-utils");
|
2016-05-17 21:25:54 +03:00
|
|
|
var mm = null;
|
2014-03-29 21:01:37 +04:00
|
|
|
|
2015-09-21 20:02:37 +03:00
|
|
|
const FRAME_SCRIPT_UTILS_URL = "chrome://devtools/content/shared/frame-script-utils.js";
|
2015-09-21 20:07:31 +03:00
|
|
|
const EXAMPLE_URL = "http://example.com/browser/devtools/client/canvasdebugger/test/";
|
2015-02-24 04:26:56 +03:00
|
|
|
const SET_TIMEOUT_URL = EXAMPLE_URL + "doc_settimeout.html";
|
2015-02-23 20:46:00 +03:00
|
|
|
const NO_CANVAS_URL = EXAMPLE_URL + "doc_no-canvas.html";
|
2015-02-26 02:22:29 +03:00
|
|
|
const RAF_NO_CANVAS_URL = EXAMPLE_URL + "doc_raf-no-canvas.html";
|
2014-03-29 21:01:37 +04:00
|
|
|
const SIMPLE_CANVAS_URL = EXAMPLE_URL + "doc_simple-canvas.html";
|
2014-06-27 14:09:00 +04:00
|
|
|
const SIMPLE_BITMASKS_URL = EXAMPLE_URL + "doc_simple-canvas-bitmasks.html";
|
2014-03-29 21:01:37 +04:00
|
|
|
const SIMPLE_CANVAS_TRANSPARENT_URL = EXAMPLE_URL + "doc_simple-canvas-transparent.html";
|
|
|
|
const SIMPLE_CANVAS_DEEP_STACK_URL = EXAMPLE_URL + "doc_simple-canvas-deep-stack.html";
|
2014-06-30 16:12:00 +04:00
|
|
|
const WEBGL_ENUM_URL = EXAMPLE_URL + "doc_webgl-enum.html";
|
2014-07-22 20:43:24 +04:00
|
|
|
const WEBGL_BINDINGS_URL = EXAMPLE_URL + "doc_webgl-bindings.html";
|
2015-12-15 02:46:00 +03:00
|
|
|
const WEBGL_DRAW_ARRAYS = EXAMPLE_URL + "doc_webgl-drawArrays.html";
|
|
|
|
const WEBGL_DRAW_ELEMENTS = EXAMPLE_URL + "doc_webgl-drawElements.html";
|
2015-02-21 19:56:00 +03:00
|
|
|
const RAF_BEGIN_URL = EXAMPLE_URL + "doc_raf-begin.html";
|
2014-03-29 21:01:37 +04:00
|
|
|
|
2016-02-27 15:51:10 +03:00
|
|
|
// Disable logging for all the tests. Both the debugger server and frontend will
|
|
|
|
// be affected by this pref.
|
|
|
|
var gEnableLogging = Services.prefs.getBoolPref("devtools.debugger.log");
|
|
|
|
Services.prefs.setBoolPref("devtools.debugger.log", false);
|
|
|
|
|
2014-03-29 21:01:37 +04:00
|
|
|
// All tests are asynchronous.
|
|
|
|
waitForExplicitFinish();
|
|
|
|
|
2015-09-15 21:19:45 +03:00
|
|
|
var gToolEnabled = Services.prefs.getBoolPref("devtools.canvasdebugger.enabled");
|
2014-03-29 21:01:37 +04:00
|
|
|
|
2016-08-06 00:41:01 +03:00
|
|
|
flags.testing = true;
|
2015-02-23 20:46:00 +03:00
|
|
|
|
2014-03-29 21:01:37 +04:00
|
|
|
registerCleanupFunction(() => {
|
|
|
|
info("finish() was called, cleaning up...");
|
2016-08-06 00:41:01 +03:00
|
|
|
flags.testing = false;
|
2014-03-29 21:01:37 +04:00
|
|
|
Services.prefs.setBoolPref("devtools.debugger.log", gEnableLogging);
|
|
|
|
Services.prefs.setBoolPref("devtools.canvasdebugger.enabled", gToolEnabled);
|
|
|
|
|
|
|
|
// Some of yhese tests use a lot of memory due to GL contexts, so force a GC
|
|
|
|
// to help fragmentation.
|
|
|
|
info("Forcing GC after canvas debugger test.");
|
|
|
|
Cu.forceGC();
|
|
|
|
});
|
|
|
|
|
2014-10-29 15:03:00 +03:00
|
|
|
/**
|
|
|
|
* Call manually in tests that use frame script utils after initializing
|
|
|
|
* the shader editor. Call after init but before navigating to different pages.
|
|
|
|
*/
|
2016-05-17 21:25:54 +03:00
|
|
|
function loadFrameScripts() {
|
2014-10-29 15:03:00 +03:00
|
|
|
mm = gBrowser.selectedBrowser.messageManager;
|
|
|
|
mm.loadFrameScript(FRAME_SCRIPT_UTILS_URL, false);
|
|
|
|
}
|
|
|
|
|
2014-03-29 21:01:37 +04:00
|
|
|
function addTab(aUrl, aWindow) {
|
|
|
|
info("Adding tab: " + aUrl);
|
|
|
|
|
|
|
|
let deferred = promise.defer();
|
|
|
|
let targetWindow = aWindow || window;
|
|
|
|
let targetBrowser = targetWindow.gBrowser;
|
|
|
|
|
|
|
|
targetWindow.focus();
|
|
|
|
let tab = targetBrowser.selectedTab = targetBrowser.addTab(aUrl);
|
|
|
|
let linkedBrowser = tab.linkedBrowser;
|
|
|
|
|
2016-09-06 17:05:32 +03:00
|
|
|
BrowserTestUtils.browserLoaded(linkedBrowser)
|
|
|
|
.then(function () {
|
|
|
|
info("Tab added and finished loading: " + aUrl);
|
|
|
|
deferred.resolve(tab);
|
|
|
|
});
|
2014-03-29 21:01:37 +04:00
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function removeTab(aTab, aWindow) {
|
|
|
|
info("Removing tab.");
|
|
|
|
|
|
|
|
let deferred = promise.defer();
|
|
|
|
let targetWindow = aWindow || window;
|
|
|
|
let targetBrowser = targetWindow.gBrowser;
|
|
|
|
let tabContainer = targetBrowser.tabContainer;
|
|
|
|
|
2017-01-25 09:01:52 +03:00
|
|
|
tabContainer.addEventListener("TabClose", function (aEvent) {
|
2014-03-29 21:01:37 +04:00
|
|
|
info("Tab removed and finished closing.");
|
|
|
|
deferred.resolve();
|
2017-01-25 09:01:52 +03:00
|
|
|
}, {once: true});
|
2014-03-29 21:01:37 +04:00
|
|
|
|
|
|
|
targetBrowser.removeTab(aTab);
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function handleError(aError) {
|
|
|
|
ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
|
|
|
|
finish();
|
|
|
|
}
|
|
|
|
|
2015-09-15 21:19:45 +03:00
|
|
|
var gRequiresWebGL = false;
|
2014-03-29 21:01:37 +04:00
|
|
|
|
|
|
|
function ifTestingSupported() {
|
|
|
|
ok(false, "You need to define a 'ifTestingSupported' function.");
|
|
|
|
finish();
|
|
|
|
}
|
|
|
|
|
|
|
|
function ifTestingUnsupported() {
|
|
|
|
todo(false, "Skipping test because some required functionality isn't supported.");
|
|
|
|
finish();
|
|
|
|
}
|
|
|
|
|
|
|
|
function test() {
|
|
|
|
let generator = isTestingSupported() ? ifTestingSupported : ifTestingUnsupported;
|
|
|
|
Task.spawn(generator).then(null, handleError);
|
|
|
|
}
|
|
|
|
|
|
|
|
function createCanvas() {
|
|
|
|
return document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
|
|
|
|
}
|
|
|
|
|
|
|
|
function isTestingSupported() {
|
|
|
|
if (!gRequiresWebGL) {
|
|
|
|
info("This test does not require WebGL support.");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-03-03 18:55:36 +03:00
|
|
|
let supported = isWebGLSupported(document);
|
2014-03-29 21:01:37 +04:00
|
|
|
|
|
|
|
info("This test requires WebGL support.");
|
|
|
|
info("Apparently, WebGL is" + (supported ? "" : " not") + " supported.");
|
|
|
|
return supported;
|
|
|
|
}
|
|
|
|
|
|
|
|
function once(aTarget, aEventName, aUseCapture = false) {
|
|
|
|
info("Waiting for event: '" + aEventName + "' on " + aTarget + ".");
|
|
|
|
|
|
|
|
let deferred = promise.defer();
|
|
|
|
|
|
|
|
for (let [add, remove] of [
|
|
|
|
["on", "off"], // Use event emitter before DOM events for consistency
|
|
|
|
["addEventListener", "removeEventListener"],
|
|
|
|
["addListener", "removeListener"]
|
|
|
|
]) {
|
|
|
|
if ((add in aTarget) && (remove in aTarget)) {
|
|
|
|
aTarget[add](aEventName, function onEvent(...aArgs) {
|
2016-07-07 00:17:03 +03:00
|
|
|
info("Got event: '" + aEventName + "' on " + aTarget + ".");
|
2014-03-29 21:01:37 +04:00
|
|
|
aTarget[remove](aEventName, onEvent, aUseCapture);
|
|
|
|
deferred.resolve(...aArgs);
|
|
|
|
}, aUseCapture);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function waitForTick() {
|
|
|
|
let deferred = promise.defer();
|
|
|
|
executeSoon(deferred.resolve);
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function navigateInHistory(aTarget, aDirection, aWaitForTargetEvent = "navigate") {
|
|
|
|
executeSoon(() => content.history[aDirection]());
|
|
|
|
return once(aTarget, aWaitForTargetEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
function navigate(aTarget, aUrl, aWaitForTargetEvent = "navigate") {
|
|
|
|
executeSoon(() => aTarget.activeTab.navigateTo(aUrl));
|
|
|
|
return once(aTarget, aWaitForTargetEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
function reload(aTarget, aWaitForTargetEvent = "navigate") {
|
|
|
|
executeSoon(() => aTarget.activeTab.reload());
|
|
|
|
return once(aTarget, aWaitForTargetEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
function initServer() {
|
|
|
|
if (!DebuggerServer.initialized) {
|
2014-12-02 09:55:56 +03:00
|
|
|
DebuggerServer.init();
|
2014-03-29 21:01:37 +04:00
|
|
|
DebuggerServer.addBrowserActors();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function initCallWatcherBackend(aUrl) {
|
|
|
|
info("Initializing a call watcher front.");
|
|
|
|
initServer();
|
|
|
|
|
2016-05-17 21:25:54 +03:00
|
|
|
return Task.spawn(function* () {
|
2014-03-29 21:01:37 +04:00
|
|
|
let tab = yield addTab(aUrl);
|
|
|
|
let target = TargetFactory.forTab(tab);
|
|
|
|
|
|
|
|
yield target.makeRemote();
|
|
|
|
|
|
|
|
let front = new CallWatcherFront(target.client, target.form);
|
2014-09-25 11:54:54 +04:00
|
|
|
return { target, front };
|
2014-03-29 21:01:37 +04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-09-25 11:54:54 +04:00
|
|
|
function initCanvasDebuggerBackend(aUrl) {
|
2014-03-29 21:01:37 +04:00
|
|
|
info("Initializing a canvas debugger front.");
|
|
|
|
initServer();
|
|
|
|
|
2016-05-17 21:25:54 +03:00
|
|
|
return Task.spawn(function* () {
|
2014-03-29 21:01:37 +04:00
|
|
|
let tab = yield addTab(aUrl);
|
|
|
|
let target = TargetFactory.forTab(tab);
|
|
|
|
|
|
|
|
yield target.makeRemote();
|
|
|
|
|
|
|
|
let front = new CanvasFront(target.client, target.form);
|
2014-09-25 11:54:54 +04:00
|
|
|
return { target, front };
|
2014-03-29 21:01:37 +04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-09-25 11:54:54 +04:00
|
|
|
function initCanvasDebuggerFrontend(aUrl) {
|
2014-03-29 21:01:37 +04:00
|
|
|
info("Initializing a canvas debugger pane.");
|
|
|
|
|
2016-05-17 21:25:54 +03:00
|
|
|
return Task.spawn(function* () {
|
2014-03-29 21:01:37 +04:00
|
|
|
let tab = yield addTab(aUrl);
|
|
|
|
let target = TargetFactory.forTab(tab);
|
|
|
|
|
|
|
|
yield target.makeRemote();
|
|
|
|
|
|
|
|
Services.prefs.setBoolPref("devtools.canvasdebugger.enabled", true);
|
|
|
|
let toolbox = yield gDevTools.showToolbox(target, "canvasdebugger");
|
|
|
|
let panel = toolbox.getCurrentPanel();
|
2014-09-25 11:54:54 +04:00
|
|
|
return { target, panel };
|
2014-03-29 21:01:37 +04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-12-23 09:43:00 +03:00
|
|
|
function teardown({target}) {
|
2014-03-29 21:01:37 +04:00
|
|
|
info("Destroying the specified canvas debugger.");
|
|
|
|
|
2014-12-23 09:43:00 +03:00
|
|
|
let {tab} = target;
|
|
|
|
return gDevTools.closeToolbox(target).then(() => {
|
|
|
|
removeTab(tab);
|
|
|
|
});
|
2014-03-29 21:01:37 +04:00
|
|
|
}
|
2014-10-29 15:03:00 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Takes a string `script` and evaluates it directly in the content
|
|
|
|
* in potentially a different process.
|
|
|
|
*/
|
2016-05-17 21:25:54 +03:00
|
|
|
function evalInDebuggee(script) {
|
2014-10-29 15:03:00 +03:00
|
|
|
let deferred = promise.defer();
|
|
|
|
|
|
|
|
if (!mm) {
|
|
|
|
throw new Error("`loadFrameScripts()` must be called when using MessageManager.");
|
|
|
|
}
|
|
|
|
|
|
|
|
let id = generateUUID().toString();
|
|
|
|
mm.sendAsyncMessage("devtools:test:eval", { script: script, id: id });
|
|
|
|
mm.addMessageListener("devtools:test:eval:response", handler);
|
|
|
|
|
2016-05-17 21:25:54 +03:00
|
|
|
function handler({ data }) {
|
2014-10-29 15:03:00 +03:00
|
|
|
if (id !== data.id) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mm.removeMessageListener("devtools:test:eval:response", handler);
|
|
|
|
deferred.resolve(data.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
2014-11-26 02:02:39 +03:00
|
|
|
|
|
|
|
function getSourceActor(aSources, aURL) {
|
|
|
|
let item = aSources.getItemForAttachment(a => a.source.url === aURL);
|
|
|
|
return item ? item.value : null;
|
|
|
|
}
|
2015-02-21 19:56:00 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Waits until a predicate returns true.
|
|
|
|
*
|
|
|
|
* @param function predicate
|
|
|
|
* Invoked once in a while until it returns true.
|
|
|
|
* @param number interval [optional]
|
|
|
|
* How often the predicate is invoked, in milliseconds.
|
|
|
|
*/
|
2016-05-17 21:25:54 +03:00
|
|
|
function* waitUntil(predicate, interval = 10) {
|
2015-02-21 19:56:00 +03:00
|
|
|
if (yield predicate()) {
|
|
|
|
return Promise.resolve(true);
|
|
|
|
}
|
|
|
|
let deferred = Promise.defer();
|
2016-05-17 21:25:54 +03:00
|
|
|
setTimeout(function () {
|
2015-02-21 19:56:00 +03:00
|
|
|
waitUntil(predicate).then(() => deferred.resolve(true));
|
|
|
|
}, interval);
|
|
|
|
return deferred.promise;
|
|
|
|
}
|