The Tor Browser: browser/devtools/canvasdebugger/test/head.js@6474c204b198 (annotated)

browser/devtools/canvasdebugger/test/head.js@6474c204b198 (annotated)

browser/devtools/canvasdebugger/test/head.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 const { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
 let { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
 // Disable logging for all the tests. Both the debugger server and frontend will
 // be affected by this pref.
 let gEnableLogging = Services.prefs.getBoolPref("devtools.debugger.log");
 Services.prefs.setBoolPref("devtools.debugger.log", false);
 let { Task } = Cu.import("resource://gre/modules/Task.jsm", {});
 let { Promise: promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
 let { gDevTools } = Cu.import("resource:///modules/devtools/gDevTools.jsm", {});
 let { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {});
 let { DebuggerServer } = Cu.import("resource://gre/modules/devtools/dbg-server.jsm", {});
 let { DebuggerClient } = Cu.import("resource://gre/modules/devtools/dbg-client.jsm", {});
 let { CallWatcherFront } = devtools.require("devtools/server/actors/call-watcher");
 let { CanvasFront } = devtools.require("devtools/server/actors/canvas");
 let TiltGL = devtools.require("devtools/tilt/tilt-gl");
 let TargetFactory = devtools.TargetFactory;
 let Toolbox = devtools.Toolbox;
 const EXAMPLE_URL = "http://example.com/browser/browser/devtools/canvasdebugger/test/";
 const SIMPLE_CANVAS_URL = EXAMPLE_URL + "doc_simple-canvas.html";
 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";
 // All tests are asynchronous.
 waitForExplicitFinish();
 let gToolEnabled = Services.prefs.getBoolPref("devtools.canvasdebugger.enabled");
 registerCleanupFunction(() => {
   info("finish() was called, cleaning up...");
   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();
 });
 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;
   linkedBrowser.addEventListener("load", function onLoad() {
     linkedBrowser.removeEventListener("load", onLoad, true);
     info("Tab added and finished loading: " + aUrl);
     deferred.resolve(tab);
   }, true);
   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;
   tabContainer.addEventListener("TabClose", function onClose(aEvent) {
     tabContainer.removeEventListener("TabClose", onClose, false);
     info("Tab removed and finished closing.");
     deferred.resolve();
   }, false);
   targetBrowser.removeTab(aTab);
   return deferred.promise;
 }
 function handleError(aError) {
   ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
   finish();
 }
 let gRequiresWebGL = false;
 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;
   }
   let supported =
     !TiltGL.isWebGLForceEnabled() &&
      TiltGL.isWebGLSupported() &&
      TiltGL.create3DContext(createCanvas());
   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) {
         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) {
     DebuggerServer.init(() => true);
     DebuggerServer.addBrowserActors();
   }
 }
 function initCallWatcherBackend(aUrl) {
   info("Initializing a call watcher front.");
   initServer();
   return Task.spawn(function*() {
     let tab = yield addTab(aUrl);
     let target = TargetFactory.forTab(tab);
     let debuggee = target.window.wrappedJSObject;
     yield target.makeRemote();
     let front = new CallWatcherFront(target.client, target.form);
     return [target, debuggee, front];
   });
 }
 function initCanavsDebuggerBackend(aUrl) {
   info("Initializing a canvas debugger front.");
   initServer();
   return Task.spawn(function*() {
     let tab = yield addTab(aUrl);
     let target = TargetFactory.forTab(tab);
     let debuggee = target.window.wrappedJSObject;
     yield target.makeRemote();
     let front = new CanvasFront(target.client, target.form);
     return [target, debuggee, front];
   });
 }
 function initCanavsDebuggerFrontend(aUrl) {
   info("Initializing a canvas debugger pane.");
   return Task.spawn(function*() {
     let tab = yield addTab(aUrl);
     let target = TargetFactory.forTab(tab);
     let debuggee = target.window.wrappedJSObject;
     yield target.makeRemote();
     Services.prefs.setBoolPref("devtools.canvasdebugger.enabled", true);
     let toolbox = yield gDevTools.showToolbox(target, "canvasdebugger");
     let panel = toolbox.getCurrentPanel();
     return [target, debuggee, panel];
   });
 }
 function teardown(aPanel) {
   info("Destroying the specified canvas debugger.");
   return promise.all([
     once(aPanel, "destroyed"),
     removeTab(aPanel.target.tab)
   ]);
 }