mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
512 lines
16 KiB
JavaScript
512 lines
16 KiB
JavaScript
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
var timer = require("sdk/timers");
|
|
var {Cc,Ci} = require("chrome");
|
|
|
|
function onBrowserLoad(callback, event) {
|
|
if (event.target && event.target.defaultView == this) {
|
|
this.removeEventListener("load", onBrowserLoad, true);
|
|
let browsers = this.document.getElementsByTagName("tabbrowser");
|
|
try {
|
|
timer.setTimeout(function (window) {
|
|
callback(window, browsers[0]);
|
|
}, 10, this);
|
|
} catch (e) { console.exception(e); }
|
|
}
|
|
}
|
|
// Utility function to open a new browser window.
|
|
function openBrowserWindow(callback, url) {
|
|
let ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
|
|
getService(Ci.nsIWindowWatcher);
|
|
let urlString = Cc["@mozilla.org/supports-string;1"].
|
|
createInstance(Ci.nsISupportsString);
|
|
urlString.data = url;
|
|
let window = ww.openWindow(null, "chrome://browser/content/browser.xul",
|
|
"_blank", "chrome,all,dialog=no", urlString);
|
|
if (callback)
|
|
window.addEventListener("load", onBrowserLoad.bind(window, callback), true);
|
|
|
|
return window;
|
|
}
|
|
|
|
// Helper for calling code at window close
|
|
function closeBrowserWindow(window, callback) {
|
|
timer.setTimeout(function() {
|
|
window.addEventListener("unload", function onUnload() {
|
|
window.removeEventListener("unload", onUnload, false);
|
|
callback();
|
|
}, false);
|
|
window.close();
|
|
}, 0);
|
|
}
|
|
|
|
// Helper for opening two windows at once
|
|
function openTwoWindows(callback) {
|
|
openBrowserWindow(function (window1) {
|
|
openBrowserWindow(function (window2) {
|
|
callback(window1, window2);
|
|
});
|
|
});
|
|
}
|
|
|
|
// Helper for closing two windows at once
|
|
function closeTwoWindows(window1, window2, callback) {
|
|
closeBrowserWindow(window1, function() {
|
|
closeBrowserWindow(window2, callback);
|
|
});
|
|
}
|
|
|
|
exports.testAddTab = function(test) {
|
|
test.waitUntilDone();
|
|
openBrowserWindow(function(window, browser) {
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
|
|
let cache = [];
|
|
let windowUtils = require("sdk/deprecated/window-utils");
|
|
new windowUtils.WindowTracker({
|
|
onTrack: function(win) {
|
|
cache.push(win);
|
|
},
|
|
onUntrack: function(win) {
|
|
cache.splice(cache.indexOf(win), 1)
|
|
}
|
|
});
|
|
let startWindowCount = cache.length;
|
|
|
|
// Test 1: add a tab
|
|
let firstUrl = "data:text/html;charset=utf-8,one";
|
|
tabBrowser.addTab(firstUrl, {
|
|
onLoad: function(e) {
|
|
let win1 = cache[startWindowCount - 1];
|
|
test.assertEqual(win1.content.location, firstUrl, "URL of new tab in first window matches");
|
|
|
|
// Test 2: add a tab in a new window
|
|
let secondUrl = "data:text/html;charset=utf-8,two";
|
|
tabBrowser.addTab(secondUrl, {
|
|
inNewWindow: true,
|
|
onLoad: function(e) {
|
|
test.assertEqual(cache.length, startWindowCount + 1, "a new window was opened");
|
|
let win2 = cache[startWindowCount];
|
|
let gBrowser = win2.gBrowser;
|
|
gBrowser.addEventListener("DOMContentLoaded", function onLoad(e) {
|
|
gBrowser.removeEventListener("DOMContentLoaded", onLoad, false);
|
|
test.assertEqual(win2.content.location, secondUrl, "URL of new tab in the new window matches");
|
|
|
|
closeBrowserWindow(win2, function() {
|
|
closeBrowserWindow(win1, function() {
|
|
test.done();
|
|
});
|
|
});
|
|
}, false);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
exports.testTrackerWithDelegate = function(test) {
|
|
test.waitUntilDone();
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
|
|
var delegate = {
|
|
state: "initializing",
|
|
onTrack: function onTrack(browser) {
|
|
if (this.state == "initializing") {
|
|
this.state = "waiting for browser window to open";
|
|
}
|
|
else if (this.state == "waiting for browser window to open") {
|
|
this.state = "waiting for browser window to close";
|
|
timer.setTimeout(function() {
|
|
closeBrowserWindow(browser.ownerDocument.defaultView, function() {
|
|
test.assertEqual(delegate.state, "deinitializing");
|
|
tb.unload();
|
|
test.done();
|
|
});
|
|
}, 0);
|
|
}
|
|
else
|
|
test.fail("invalid state");
|
|
},
|
|
onUntrack: function onUntrack(browser) {
|
|
if (this.state == "waiting for browser window to close") {
|
|
test.pass("proper state in onUntrack");
|
|
this.state = "deinitializing";
|
|
}
|
|
else if (this.state != "deinitializing")
|
|
test.fail("invalid state");
|
|
}
|
|
};
|
|
var tb = new tabBrowser.Tracker(delegate);
|
|
|
|
delegate.state = "waiting for browser window to open";
|
|
|
|
openBrowserWindow();
|
|
};
|
|
|
|
exports.testWhenContentLoaded = function(test) {
|
|
test.waitUntilDone();
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
|
|
var tracker = tabBrowser.whenContentLoaded(
|
|
function(window) {
|
|
var item = window.document.getElementById("foo");
|
|
test.assertEqual(item.textContent, "bar",
|
|
"whenContentLoaded() works.");
|
|
tracker.unload();
|
|
closeBrowserWindow(activeWindow(), function() {
|
|
test.done();
|
|
});
|
|
});
|
|
|
|
openBrowserWindow(function(browserWindow, browser) {
|
|
var html = '<div id="foo">bar</div>';
|
|
browser.addTab("data:text/html;charset=utf-8," + html);
|
|
});
|
|
};
|
|
|
|
exports.testTrackerWithoutDelegate = function(test) {
|
|
test.waitUntilDone();
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
|
|
openBrowserWindow(function(browserWindow, browser) {
|
|
var tb = new tabBrowser.Tracker();
|
|
|
|
if (tb.length == 0)
|
|
test.fail("expect at least one tab browser to exist.");
|
|
|
|
for (var i = 0; i < tb.length; i++)
|
|
test.assertEqual(tb.get(i).nodeName, "tabbrowser",
|
|
"get() method and length prop should work");
|
|
for (var b in tb)
|
|
test.assertEqual(b.nodeName, "tabbrowser",
|
|
"iterator should work");
|
|
|
|
var matches = [b for (b in tb)
|
|
if (b == browser)];
|
|
test.assertEqual(matches.length, 1,
|
|
"New browser should be in tracker.");
|
|
tb.unload();
|
|
|
|
closeBrowserWindow(browserWindow, function() {
|
|
test.done();
|
|
});
|
|
});
|
|
};
|
|
|
|
exports.testTabTracker = function(test) {
|
|
test.waitUntilDone();
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
|
|
openBrowserWindow(function(browserWindow, browser) {
|
|
var delegate = {
|
|
tracked: 0,
|
|
onTrack: function(tab) {
|
|
this.tracked++;
|
|
},
|
|
onUntrack: function(tab) {
|
|
this.tracked--;
|
|
}
|
|
};
|
|
|
|
let tabTracker = tabBrowser.TabTracker(delegate);
|
|
|
|
let tracked = delegate.tracked;
|
|
let url1 = "data:text/html;charset=utf-8,1";
|
|
let url2 = "data:text/html;charset=utf-8,2";
|
|
let url3 = "data:text/html;charset=utf-8,3";
|
|
let tabCount = 0;
|
|
|
|
function tabLoadListener(e) {
|
|
let loadedURL = e.target.defaultView.location;
|
|
if (loadedURL == url1)
|
|
tabCount++;
|
|
else if (loadedURL == url2)
|
|
tabCount++;
|
|
else if (loadedURL == url3)
|
|
tabCount++;
|
|
|
|
if (tabCount == 3) {
|
|
test.assertEqual(delegate.tracked, tracked + 3, "delegate tracked tabs matched count");
|
|
tabTracker.unload();
|
|
closeBrowserWindow(browserWindow, function() {
|
|
timer.setTimeout(function() test.done(), 0);
|
|
});
|
|
}
|
|
}
|
|
|
|
tabBrowser.addTab(url1, {
|
|
onLoad: tabLoadListener
|
|
});
|
|
tabBrowser.addTab(url2, {
|
|
onLoad: tabLoadListener
|
|
});
|
|
tabBrowser.addTab(url3, {
|
|
onLoad: tabLoadListener
|
|
});
|
|
});
|
|
};
|
|
|
|
exports.testActiveTab = function(test) {
|
|
test.waitUntilDone();
|
|
openBrowserWindow(function(browserWindow, browser) {
|
|
const tabBrowser = require("sdk/deprecated/tab-browser");
|
|
const TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
let tm = new TabModule(browserWindow);
|
|
test.assertEqual(tm.length, 1);
|
|
let url1 = "data:text/html;charset=utf-8,foo";
|
|
let url2 = "data:text/html;charset=utf-8,bar";
|
|
|
|
function tabURL(tab) tab.ownerDocument.defaultView.content.location.toString()
|
|
|
|
tabBrowser.addTab(url1, {
|
|
onLoad: function(e) {
|
|
// make sure we're running in the right window.
|
|
test.assertEqual(tabBrowser.activeTab.ownerDocument.defaultView, browserWindow, "active window matches");
|
|
browserWindow.focus();
|
|
|
|
test.assertEqual(tabURL(tabBrowser.activeTab), url1, "url1 matches");
|
|
let tabIndex = browser.getBrowserIndexForDocument(e.target);
|
|
let tabAtIndex = browser.tabContainer.getItemAtIndex(tabIndex);
|
|
test.assertEqual(tabAtIndex, tabBrowser.activeTab, "activeTab element matches");
|
|
|
|
tabBrowser.addTab(url2, {
|
|
inBackground: true,
|
|
onLoad: function() {
|
|
test.assertEqual(tabURL(tabBrowser.activeTab), url1, "url1 still matches");
|
|
let tabAtIndex = browser.tabContainer.getItemAtIndex(tabIndex);
|
|
test.assertEqual(tabAtIndex, tabBrowser.activeTab, "activeTab element matches");
|
|
closeBrowserWindow(browserWindow, function() {
|
|
test.done()
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
// TabModule tests
|
|
exports.testEventsAndLengthStayInModule = function(test) {
|
|
test.waitUntilDone();
|
|
let TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
|
|
openTwoWindows(function(window1, window2) {
|
|
let tm1 = new TabModule(window1);
|
|
let tm2 = new TabModule(window2);
|
|
|
|
let counter1 = 0, counter2 = 0;
|
|
let counterTabs = 0;
|
|
|
|
function onOpenListener() {
|
|
++counterTabs;
|
|
if (counterTabs < 5)
|
|
return;
|
|
test.assertEqual(counter1, 2, "Correct number of events fired from window 1");
|
|
test.assertEqual(counter2, 3, "Correct number of events fired from window 2");
|
|
test.assertEqual(counterTabs, 5, "Correct number of events fired from all windows");
|
|
test.assertEqual(tm1.length, 3, "Correct number of tabs in window 1");
|
|
test.assertEqual(tm2.length, 4, "Correct number of tabs in window 2");
|
|
closeTwoWindows(window1, window2, function() test.done());
|
|
}
|
|
|
|
tm1.onOpen = function() ++counter1 && onOpenListener();
|
|
tm2.onOpen = function() ++counter2 && onOpenListener();
|
|
|
|
let url = "data:text/html;charset=utf-8,default";
|
|
tm1.open(url);
|
|
tm1.open(url);
|
|
|
|
tm2.open(url);
|
|
tm2.open(url);
|
|
tm2.open(url);
|
|
});
|
|
}
|
|
|
|
exports.testTabModuleActiveTab_getterAndSetter = function(test) {
|
|
test.waitUntilDone();
|
|
let TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
|
|
openTwoWindows(function(window1, window2) {
|
|
let tm1 = new TabModule(window1);
|
|
let tm2 = new TabModule(window2);
|
|
|
|
// First open two tabs per window
|
|
tm1.open({
|
|
url: "data:text/html;charset=utf-8,<title>window1,tab1</title>",
|
|
onOpen: function(tab1) {
|
|
tm1.open({
|
|
url: "data:text/html;charset=utf-8,<title>window1,tab2</title>",
|
|
onOpen: function (tab2) {
|
|
tm2.open({
|
|
url: "data:text/html;charset=utf-8,<title>window2,tab1</title>",
|
|
onOpen: function (tab3) {
|
|
tm2.open({
|
|
url: "data:text/html;charset=utf-8,<title>window2,tab2</title>",
|
|
onOpen: function(tab4) {
|
|
onTabsOpened(tab1, tab2, tab3, tab4);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// Then try to activate tabs, but wait for all of them to be activated after
|
|
// being opened
|
|
function onTabsOpened(tab1, tab2, tab3, tab4) {
|
|
test.assertEqual(tm1.activeTab.title, "window1,tab2",
|
|
"Correct active tab on window 1");
|
|
test.assertEqual(tm2.activeTab.title, "window2,tab2",
|
|
"Correct active tab on window 2");
|
|
|
|
tm1.onActivate = function onActivate() {
|
|
tm1.onActivate.remove(onActivate);
|
|
timer.setTimeout(function() {
|
|
test.assertEqual(tm1.activeTab.title, "window1,tab1",
|
|
"activeTab setter works (window 1)");
|
|
test.assertEqual(tm2.activeTab.title, "window2,tab2",
|
|
"activeTab is ignored with tabs from another window");
|
|
closeTwoWindows(window1, window2, function() test.done());
|
|
}, 1000);
|
|
}
|
|
|
|
tm1.activeTab = tab1;
|
|
// Setting activeTab from another window should have no effect:
|
|
tm1.activeTab = tab4;
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
// test tabs iterator
|
|
exports.testTabModuleTabsIterator = function(test) {
|
|
test.waitUntilDone();
|
|
let TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
|
|
openBrowserWindow(function(window) {
|
|
let tm1 = new TabModule(window);
|
|
let url = "data:text/html;charset=utf-8,default";
|
|
tm1.open(url);
|
|
tm1.open(url);
|
|
tm1.open({
|
|
url: url,
|
|
onOpen: function(tab) {
|
|
let count = 0;
|
|
for each (let t in tm1) count++;
|
|
test.assertEqual(count, 4, "iterated tab count matches");
|
|
test.assertEqual(count, tm1.length, "length tab count matches");
|
|
closeBrowserWindow(window, function() test.done());
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
// inNewWindow parameter is ignored on single-window modules
|
|
exports.testTabModuleCantOpenInNewWindow = function(test) {
|
|
test.waitUntilDone();
|
|
let TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
|
|
openBrowserWindow(function(window) {
|
|
let tm = new TabModule(window);
|
|
let url = "data:text/html;charset=utf-8,default";
|
|
tm.open({
|
|
url: url,
|
|
inNewWindow: true,
|
|
onOpen: function() {
|
|
test.assertEqual(tm.length, 2, "Tab was open on same window");
|
|
closeBrowserWindow(window, function() test.done());
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
// Test that having two modules attached to the same
|
|
// window won't duplicate events fired on each module
|
|
exports.testModuleListenersDontInteract = function(test) {
|
|
test.waitUntilDone();
|
|
let TabModule = require("sdk/deprecated/tab-browser").TabModule;
|
|
|
|
openBrowserWindow(function(window) {
|
|
let tm1 = new TabModule(window);
|
|
let tm2 = new TabModule(window);
|
|
|
|
let url = "data:text/html;charset=utf-8,foo";
|
|
let eventCount = 0, eventModule1 = 0, eventModule2 = 0;
|
|
|
|
|
|
let listener1 = function() {
|
|
// this should be called twice: when tab is open and when
|
|
// the url location is changed
|
|
eventCount++;
|
|
eventModule1++;
|
|
}
|
|
tm1.onReady = listener1;
|
|
|
|
tm2.open({
|
|
url: "about:blank",
|
|
onOpen: function(tab) {
|
|
// add listener via property assignment
|
|
let listener2 = function() {
|
|
eventCount++;
|
|
eventModule2++;
|
|
};
|
|
tab.onReady = listener2;
|
|
|
|
// add listener via collection add
|
|
let listener3 = function() {
|
|
eventCount++;
|
|
eventModule2++;
|
|
};
|
|
tab.onReady.add(listener3);
|
|
|
|
tab.location = url;
|
|
|
|
test.waitUntilEqual(function () eventCount, 4,
|
|
"Correct global number of events")
|
|
.then(function () {
|
|
test.assertEqual(eventModule1, 2,
|
|
"Correct number of events on module 1");
|
|
test.assertEqual(eventModule2, 2,
|
|
"Correct number of events on module 2");
|
|
|
|
tm1.onReady.remove(listener1);
|
|
tab.onReady.remove(listener2);
|
|
tab.onReady.remove(listener3);
|
|
closeBrowserWindow(window, function() test.done());
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
/******************* helpers *********************/
|
|
|
|
// Helper for getting the active window
|
|
function activeWindow() {
|
|
return Cc["@mozilla.org/appshell/window-mediator;1"].
|
|
getService(Ci.nsIWindowMediator).
|
|
getMostRecentWindow("navigator:browser");
|
|
};
|
|
|
|
// If the module doesn't support the app we're being run in, require() will
|
|
// throw. In that case, remove all tests above from exports, and add one dummy
|
|
// test that passes.
|
|
try {
|
|
require("sdk/deprecated/tab-browser");
|
|
}
|
|
catch (err) {
|
|
if (!/^Unsupported Application/.test(err.message))
|
|
throw err;
|
|
|
|
module.exports = {
|
|
testAppNotSupported: function (test) {
|
|
test.pass(err.message);
|
|
}
|
|
};
|
|
}
|