423 lines
13 KiB
JavaScript
423 lines
13 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/. */
|
|
|
|
import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
|
|
import { BrowserUtils } from "resource://gre/modules/BrowserUtils.sys.mjs";
|
|
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
|
|
|
|
const APPLE_COPY_LINK = "com.apple.share.CopyLink.invite";
|
|
|
|
let lazy = {};
|
|
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
QRCodeGenerator:
|
|
"moz-src:///browser/components/qrcode/QRCodeGenerator.sys.mjs",
|
|
});
|
|
|
|
XPCOMUtils.defineLazyServiceGetters(lazy, {
|
|
WindowsUIUtils: ["@mozilla.org/windows-ui-utils;1", Ci.nsIWindowsUIUtils],
|
|
});
|
|
|
|
// Use a non-caching getter so tests can swap out the service via MockRegistrar.
|
|
Object.defineProperty(lazy, "MacSharingService", {
|
|
get() {
|
|
return Cc["@mozilla.org/widget/macsharingservice;1"].getService(
|
|
Ci.nsIMacSharingService
|
|
);
|
|
},
|
|
});
|
|
|
|
class SharingUtilsCls {
|
|
/**
|
|
* Ensures a "Share" submenu exists in a given menu, creating it if necessary.
|
|
*
|
|
* @param {MozBrowser} contextBrowser
|
|
* The browser of the right-clicked (context) tab.
|
|
* @param {MozBrowser[]|null} browsers
|
|
* All selected browsers in tab strip order. Pass null for single URL sharing.
|
|
* @param {Element} insertAfterEl
|
|
* The menu item after which the share item is inserted.
|
|
*/
|
|
ensureShareMenu(contextBrowser, browsers, insertAfterEl) {
|
|
if (!Services.prefs.getBoolPref("browser.menu.share_url.allow", true)) {
|
|
return;
|
|
}
|
|
|
|
let hasShareableURL =
|
|
browsers !== null
|
|
? browsers.some(b => BrowserUtils.getShareableURL(b.currentURI))
|
|
: !!BrowserUtils.getShareableURL(contextBrowser.currentURI);
|
|
|
|
let shareMenu;
|
|
let oldElement = insertAfterEl.nextElementSibling;
|
|
|
|
if (oldElement?.matches(".share-tab-url-item")) {
|
|
shareMenu = oldElement;
|
|
} else {
|
|
shareMenu = this.#createShareMenu(insertAfterEl);
|
|
}
|
|
|
|
shareMenu.contextBrowserToShare = Cu.getWeakReference(contextBrowser);
|
|
shareMenu.browsersToShare =
|
|
browsers?.map(b => Cu.getWeakReference(b)) ?? null;
|
|
|
|
if (AppConstants.platform != "macosx") {
|
|
// On macOS, we keep the item visible and handle enable/disable
|
|
// inside the menupopup.
|
|
shareMenu.hidden = !hasShareableURL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates and inserts the "Share" <menu> element with a <menupopup> child.
|
|
* All platforms now use a submenu.
|
|
*/
|
|
#createShareMenu(insertAfterEl) {
|
|
let parentMenu = insertAfterEl.parentNode;
|
|
let document = insertAfterEl.ownerDocument;
|
|
|
|
let l10nID =
|
|
parentMenu.id == "tabContextMenu"
|
|
? "tab-context-share-url"
|
|
: "menu-file-share-url";
|
|
|
|
let menu = document.createXULElement("menu");
|
|
let menuPopup = document.createXULElement("menupopup");
|
|
menuPopup.addEventListener("popupshowing", this);
|
|
menu.appendChild(menuPopup);
|
|
|
|
document.l10n.setAttributes(menu, l10nID);
|
|
menu.classList.add("share-tab-url-item");
|
|
|
|
parentMenu.insertBefore(menu, insertAfterEl.nextSibling);
|
|
return menu;
|
|
}
|
|
|
|
/**
|
|
* Return a menuitem that copies the link(s) to the clipboard.
|
|
*/
|
|
#createCopyLinkMenuItem(document, shareableCount) {
|
|
let item = document.createXULElement("menuitem");
|
|
document.l10n.setAttributes(item, "menu-share-copy-links", {
|
|
// shareableCount can be zero when about:blank tabs are selected but no
|
|
// "real" tabs are. Clamp to 1 so the localized string is correct.
|
|
count: Math.max(1, shareableCount),
|
|
});
|
|
item.classList.add("menuitem-iconic", "share-copy-link");
|
|
item.setAttribute("image", "chrome://global/skin/icons/link.svg");
|
|
return item;
|
|
}
|
|
|
|
async #showQRCodePanel(win, browser, url) {
|
|
let tab = win.gBrowser.getTabForBrowser(browser);
|
|
if (tab && win.gBrowser.selectedTab !== tab) {
|
|
let wait = null;
|
|
if (!tab.linkedPanel) {
|
|
wait = this.#waitForTabRestored(tab);
|
|
}
|
|
win.gBrowser.selectedTab = tab;
|
|
if (wait) {
|
|
if (win.gBrowser.selectedTab === tab) {
|
|
await wait.promise;
|
|
} else {
|
|
wait.cancel();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!tab || !tab.linkedBrowser || tab.closing) {
|
|
return;
|
|
}
|
|
|
|
let qrCodeDataURI = null;
|
|
try {
|
|
qrCodeDataURI = await lazy.QRCodeGenerator.generateQRCode(url);
|
|
} catch (error) {
|
|
console.error("Failed to generate QR code:", error);
|
|
}
|
|
|
|
let params = {
|
|
url,
|
|
qrCodeDataURI,
|
|
};
|
|
|
|
win.gBrowser
|
|
.getTabDialogBox(browser)
|
|
.open(
|
|
"chrome://browser/content/qrcode/qrcode-dialog.html",
|
|
{ features: "resizable=no", allowDuplicateDialogs: false },
|
|
params
|
|
);
|
|
}
|
|
|
|
#waitForTabRestored(tab) {
|
|
let { promise, resolve } = Promise.withResolvers();
|
|
let cleanup = () => {
|
|
tab.removeEventListener("SSTabRestored", cleanup);
|
|
tab.removeEventListener("TabClose", cleanup);
|
|
resolve();
|
|
};
|
|
tab.addEventListener("SSTabRestored", cleanup, { once: true });
|
|
tab.addEventListener("TabClose", cleanup, { once: true });
|
|
return { promise, cancel: cleanup };
|
|
}
|
|
|
|
/**
|
|
* Get the sharing data for the context browser on a DOM node.
|
|
*/
|
|
getLinkToShare(node) {
|
|
let browser = node.contextBrowserToShare?.get();
|
|
let urlToShare = null;
|
|
let titleToShare = null;
|
|
|
|
if (browser) {
|
|
let maybeToShare = BrowserUtils.getShareableURL(browser.currentURI);
|
|
if (maybeToShare) {
|
|
let { gURLBar } = node.documentGlobal;
|
|
urlToShare = gURLBar.makeURIReadable(maybeToShare).displaySpec;
|
|
titleToShare = browser.contentTitle;
|
|
}
|
|
}
|
|
return { urlToShare, titleToShare };
|
|
}
|
|
|
|
/**
|
|
* Get the link data for all browsers stored on a DOM node.
|
|
*
|
|
* @returns {Array<{url: string, title: string}>}
|
|
*/
|
|
getLinksToShare(node) {
|
|
let browsers = node.browsersToShare ?? [node.contextBrowserToShare];
|
|
let links = [];
|
|
for (let weakRef of browsers) {
|
|
let browser = weakRef.get();
|
|
if (!browser) {
|
|
continue;
|
|
}
|
|
let maybeToShare = BrowserUtils.getShareableURL(browser.currentURI);
|
|
if (maybeToShare) {
|
|
let { gURLBar } = node.documentGlobal;
|
|
links.push({
|
|
url: gURLBar.makeURIReadable(maybeToShare).displaySpec,
|
|
title: browser.contentTitle,
|
|
});
|
|
}
|
|
}
|
|
return links;
|
|
}
|
|
|
|
#initSharePopup(menuPopup) {
|
|
this.populateSharePopup(menuPopup);
|
|
|
|
menuPopup.parentNode
|
|
.closest("menupopup")
|
|
.addEventListener("popuphiding", this);
|
|
}
|
|
|
|
/**
|
|
* Populates the share submenu popup with platform-appropriate items.
|
|
*/
|
|
populateSharePopup(menuPopup) {
|
|
// Ensure the command listener is registered.
|
|
menuPopup.addEventListener("command", this);
|
|
|
|
while (menuPopup.firstChild) {
|
|
menuPopup.firstChild.remove();
|
|
}
|
|
|
|
let document = menuPopup.ownerDocument;
|
|
let node = menuPopup.parentNode;
|
|
let isMultiTab = node.browsersToShare !== null;
|
|
|
|
let { urlToShare } = this.getLinkToShare(node);
|
|
|
|
// If we can't share the current URL, we display the items disabled,
|
|
// but enable the "more..." item at the bottom on macOS, to allow the
|
|
// user to change sharing preferences in the system dialog.
|
|
let shouldEnable = !!urlToShare;
|
|
|
|
let shareableCount;
|
|
if (isMultiTab) {
|
|
shareableCount = this.getLinksToShare(node).length;
|
|
} else {
|
|
shareableCount = shouldEnable ? 1 : 0;
|
|
}
|
|
let copyLinkEnabled = shareableCount > 0;
|
|
|
|
// On macOS, query native services. We need this list to check whether
|
|
// Apple already provides a "Copy Link" service.
|
|
let services = [];
|
|
if (AppConstants.platform == "macosx") {
|
|
if (!urlToShare) {
|
|
// Fake it so we can ask the sharing service for services:
|
|
urlToShare = "https://mozilla.org/";
|
|
}
|
|
services = lazy.MacSharingService.getSharingProviders(urlToShare);
|
|
}
|
|
|
|
// Copy Link(s) - all platforms. Apple seems reluctant to provide copy
|
|
// link as a feature, so add it if it's not already in the services list.
|
|
if (
|
|
AppConstants.platform != "macosx" ||
|
|
!services.some(s => s.name == APPLE_COPY_LINK)
|
|
) {
|
|
let copyItem = this.#createCopyLinkMenuItem(document, shareableCount);
|
|
if (!copyLinkEnabled) {
|
|
copyItem.setAttribute("disabled", "true");
|
|
}
|
|
menuPopup.appendChild(copyItem);
|
|
}
|
|
|
|
// QR code - all platforms
|
|
if (Services.prefs.getBoolPref("browser.shareqrcode.enabled", false)) {
|
|
let qrCodeItem = document.createXULElement("menuitem");
|
|
qrCodeItem.classList.add("menuitem-iconic", "share-qrcode-item");
|
|
document.l10n.setAttributes(qrCodeItem, "menu-file-share-qrcode");
|
|
qrCodeItem.setAttribute("image", "chrome://browser/skin/qrcode.svg");
|
|
if (!shouldEnable || isMultiTab) {
|
|
qrCodeItem.setAttribute("disabled", "true");
|
|
}
|
|
menuPopup.appendChild(qrCodeItem);
|
|
}
|
|
|
|
// macOS: native sharing services + "More..."
|
|
if (AppConstants.platform == "macosx") {
|
|
if (services.length) {
|
|
menuPopup.appendChild(document.createXULElement("menuseparator"));
|
|
}
|
|
// Share service items
|
|
services.forEach(share => {
|
|
let item = document.createXULElement("menuitem");
|
|
item.classList.add("menuitem-iconic");
|
|
item.setAttribute("label", share.menuItemTitle);
|
|
item.setAttribute("data-share-name", share.name);
|
|
item.setAttribute("image", ChromeUtils.encodeURIForSrcset(share.image));
|
|
if (!shouldEnable) {
|
|
item.setAttribute("disabled", "true");
|
|
}
|
|
menuPopup.appendChild(item);
|
|
});
|
|
menuPopup.appendChild(document.createXULElement("menuseparator"));
|
|
|
|
// More item
|
|
let moreItem = document.createXULElement("menuitem");
|
|
document.l10n.setAttributes(moreItem, "menu-share-more");
|
|
moreItem.classList.add("menuitem-iconic", "share-more-button");
|
|
moreItem.setAttribute("data-share-name", "share_macosx_more");
|
|
menuPopup.appendChild(moreItem);
|
|
}
|
|
|
|
// Windows: native share dialog
|
|
if (AppConstants.platform == "win") {
|
|
menuPopup.appendChild(document.createXULElement("menuseparator"));
|
|
let winShareItem = document.createXULElement("menuitem");
|
|
winShareItem.classList.add("share-windows-item");
|
|
document.l10n.setAttributes(winShareItem, "menu-share-windows");
|
|
if (!shouldEnable || isMultiTab) {
|
|
winShareItem.setAttribute("disabled", "true");
|
|
}
|
|
menuPopup.appendChild(winShareItem);
|
|
}
|
|
}
|
|
|
|
#onCommand(event) {
|
|
let node = event.currentTarget.parentNode;
|
|
if (event.target.classList.contains("share-qrcode-item")) {
|
|
let { urlToShare: url } = this.getLinkToShare(node);
|
|
let browser = node.contextBrowserToShare?.get();
|
|
if (url && browser) {
|
|
Glean.qrcode.opened.add(1);
|
|
this.#showQRCodePanel(node.documentGlobal, browser, url);
|
|
}
|
|
} else if (event.target.classList.contains("share-more-button")) {
|
|
this.openMacSharePreferences();
|
|
} else if (event.target.classList.contains("share-copy-link")) {
|
|
this.copyLink(node);
|
|
} else if (event.target.classList.contains("share-windows-item")) {
|
|
this.shareOnWindows(node);
|
|
} else if (event.target.dataset.shareName) {
|
|
this.shareOnMac(node, event.target.dataset.shareName);
|
|
}
|
|
}
|
|
|
|
onPopupHiding(event) {
|
|
// We don't want to rebuild the contents of the "Share" menupopup if only its submenu is
|
|
// hidden. So bail if this isn't the top menupopup in the DOM tree:
|
|
if (event.target.parentNode.closest("menupopup")) {
|
|
return;
|
|
}
|
|
let menupopup = event.target.querySelector(
|
|
".share-tab-url-item"
|
|
)?.menupopup;
|
|
menupopup?.removeEventListener("command", this);
|
|
event.target.removeEventListener("popuphiding", this);
|
|
}
|
|
|
|
onPopupShowing(event) {
|
|
this.#initSharePopup(event.target);
|
|
}
|
|
|
|
handleEvent(aEvent) {
|
|
switch (aEvent.type) {
|
|
case "command":
|
|
this.#onCommand(aEvent);
|
|
break;
|
|
case "popuphiding":
|
|
this.onPopupHiding(aEvent);
|
|
break;
|
|
case "popupshowing":
|
|
this.onPopupShowing(aEvent);
|
|
break;
|
|
}
|
|
}
|
|
|
|
copyLink(node) {
|
|
let links = this.getLinksToShare(node);
|
|
if (links.length) {
|
|
BrowserUtils.copyLinks(links);
|
|
}
|
|
}
|
|
|
|
shareOnWindows(node) {
|
|
let { urlToShare, titleToShare } = this.getLinkToShare(node);
|
|
if (!urlToShare) {
|
|
return;
|
|
}
|
|
|
|
lazy.WindowsUIUtils.shareUrl(urlToShare, titleToShare);
|
|
}
|
|
|
|
shareOnMac(node, serviceName) {
|
|
let { urlToShare, titleToShare } = this.getLinkToShare(node);
|
|
if (!urlToShare) {
|
|
return;
|
|
}
|
|
|
|
lazy.MacSharingService.shareUrl(serviceName, urlToShare, titleToShare);
|
|
}
|
|
|
|
openMacSharePreferences() {
|
|
lazy.MacSharingService.openSharingPreferences();
|
|
}
|
|
|
|
testOnlyMockUIUtils(mock) {
|
|
if (!Cu.isInAutomation) {
|
|
throw new Error("Can only mock utils in automation.");
|
|
}
|
|
// eslint-disable-next-line mozilla/valid-lazy
|
|
Object.defineProperty(lazy, "WindowsUIUtils", {
|
|
get() {
|
|
if (mock) {
|
|
return mock;
|
|
}
|
|
return Cc["@mozilla.org/windows-ui-utils;1"].getService(
|
|
Ci.nsIWindowsUIUtils
|
|
);
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
export let SharingUtils = new SharingUtilsCls();
|