"undefined" in UI about uc.css.js HOT 24 CLOSED

#PersonalToolbar {
    justify-content: center !important;
}

#PlacesToolbarItems {
    -moz-box-pack: center;
}
#personal-bookmarks {
    width: -moz-available;
}

// ==UserScript==
// @name           Private Tabs
// @version        1.1 (Custom toolbar button version)
// @author         aminomancer
// @homepage       https://github.com/aminomancer
// @description    An fx-autoconfig port of Private Tab by xiaoxiaoflood. Adds buttons and menu items allowing you to open a "private tab" in nearly any circumstance in which you'd be able to open a normal tab. Instead of opening a link in a private window, you can open it in a private tab instead. This will use a special container and prevent history storage, depending on user configuration. You can also toggle tabs back and forth between private and normal mode. This script adds two hotkeys: Ctrl+alt+P to open a new private tab, and ctrl+alt+T to toggle private mode for the active tab. These hotkeys can be configured along with several other options at the top of the script file.
// @include        main
// @include        chrome://browser/content/places/bookmarksSidebar.xhtml
// @include        chrome://browser/content/places/historySidebar.xhtml
// @include        chrome://browser/content/places/places.xhtml
// ==/UserScript==

class PrivateTabManager {
    constructor() {
        if (!_ucUtils.sharedGlobal.privateTabGlobal) _ucUtils.sharedGlobal.privateTabGlobal = {};
        let privateTabGlobal = _ucUtils.sharedGlobal.privateTabGlobal;
        this.config = {
            neverClearData: false, // if you want to not record history but don't care about other data, maybe even want to keep private logins
            restoreTabsOnRestart: true,
            doNotClearDataUntilFxIsClosed: true,
            deleteContainerOnDisable: false,
            clearDataOnDisable: false,
            toggleHotkey: "T", // key for toggling private mode for the active tab. ctrl + alt + T by default.
            newTabHotkey: "P", // key for opening a new private tab. ctrl + alt + P by default.
            toggleModifiers: "alt accel", // modifiers for toggle hotkey. this means alt+ctrl on windows or alt+cmd on mac
            newTabModifiers: "alt accel", // modifiers for new tab hotkey.
        };
        // isn't strictly necessary, but due to a programmer's oversight, this seems to be the only way to prevent irritating animations when toggling private mode on/off for a tab. what's actually happening under the hood is not a simple state change, since that would be insecure. the whole point of all this is to avoid leaking information, so when we turn private mode on, we need to create a brand new tab and restore it from cached data. but the internal duplicateTab method doesn't pass the skipAnimation parameter to addTrustedTab. so we need to make our own function, which requires these unexposed modules.
        let { SessionStoreInternal } = Cu.import(
            "resource:///modules/sessionstore/SessionStore.jsm"
        );
        this.SSI = SessionStoreInternal;
        XPCOMUtils.defineLazyModuleGetters(this, {
            TabState: "resource:///modules/sessionstore/TabState.jsm",
            TabStateFlusher: "resource:///modules/sessionstore/TabStateFlusher.jsm",
        });
        this.sss = Cc["@mozilla.org/content/style-sheet-service;1"].getService(
            Ci.nsIStyleSheetService
        );
        privateTabGlobal.openTabs = new Set();
        if (typeof window.gProton != "undefined") privateTabGlobal.gProton = window.gProton;
        this.menuClass = privateTabGlobal.gProton ? `` : `menuitem-iconic privatetab-icon`;
        this.openTabs = privateTabGlobal.openTabs;
        this.orig_getAttribute = MozElements.MozTab.prototype.getAttribute;
        this.BTN_ID = "privateTab-button";
        this.BTN2_ID = "newPrivateTab-button";
        this.init();
        if (location.href != "chrome://browser/content/browser.xhtml") return this.exec();
        if (gBrowserInit.delayedStartupFinished) this.exec();
        else {
            let delayedListener = (subject, topic) => {
                if (topic == "browser-delayed-startup-finished" && subject == window) {
                    Services.obs.removeObserver(delayedListener, topic);
                    this.exec();
                }
            };
            Services.obs.addObserver(delayedListener, "browser-delayed-startup-finished");
        }
    }

    exec() {
        let privateTabGlobal = _ucUtils.sharedGlobal.privateTabGlobal;
        if (PrivateBrowsingUtils.isWindowPrivate(window)) return;
        let openAll = document.getElementById("placesContext_openBookmarkContainer:tabs");
        let openAllPrivate = _ucUtils.createElement(document, "menuitem", {
            id: "openAllPrivate",
            label: "Open All in Private Tabs",
            accesskey: "v",
            class: this.menuClass,
            oncommand: `event.userContextId = ${
                this.container.userContextId
            }; ${openAll.getAttribute("oncommand")}`,
            onclick: `event.userContextId = ${this.container.userContextId}; ${openAll.getAttribute(
                "onclick"
            )}`,
        });
        openAll.after(openAllPrivate);

        let openAllLinks = document.getElementById("placesContext_openLinks:tabs");
        let openAllLinksPrivate = _ucUtils.createElement(document, "menuitem", {
            id: "openAllLinksPrivate",
            label: "Open All in Private Tabs",
            accesskey: "v",
            class: this.menuClass,
            oncommand: `event.userContextId = ${
                this.container.userContextId
            }; ${openAllLinks.getAttribute("oncommand")}`,
            onclick: `event.userContextId = ${
                this.container.userContextId
            }; ${openAllLinks.getAttribute("onclick")}`,
        });
        openAllLinks.after(openAllLinksPrivate);

        let openTab = document.getElementById("placesContext_open:newtab");
        let openPrivate = _ucUtils.createElement(document, "menuitem", {
            id: "openPrivate",
            label: "Open in a New Private Tab",
            accesskey: "v",
            class: this.menuClass,
            oncommand: `let view = event.target.parentElement._view; PlacesUIUtils._openNodeIn(view.selectedNode, "tab", view.ownerWindow, false, ${this.container.userContextId})`,
        });
        openTab.after(openPrivate);

        document.getElementById("placesContext").addEventListener("popupshowing", this);

        if (location.href != "chrome://browser/content/browser.xhtml") return;

        let keyset = _ucUtils.createElement(document, "keyset", { id: "privateTab-keyset" });
        document.getElementById("mainKeyset").after(keyset);

        let toggleKey = _ucUtils.createElement(document, "key", {
            id: "togglePrivateTab-key",
            modifiers: this.config.toggleModifiers,
            key: this.config.toggleHotkey,
            oncommand: "privateTab.togglePrivate()",
        });
        keyset.appendChild(toggleKey);

        let newPrivateTabKey = _ucUtils.createElement(document, "key", {
            id: "newPrivateTab-key",
            modifiers: this.config.newTabModifiers,
            key: this.config.newTabHotkey,
            oncommand: "privateTab.BrowserOpenTabPrivate()",
        });
        keyset.appendChild(newPrivateTabKey);

        let menuOpenLink = _ucUtils.createElement(document, "menuitem", {
            id: "menu_newPrivateTab",
            label: "New Private Tab",
            accesskey: "v",
            acceltext: ShortcutUtils.prettifyShortcut(newPrivateTabKey),
            class: this.menuClass,
            oncommand: "privateTab.BrowserOpenTabPrivate()",
        });
        document.getElementById("menu_newNavigatorTab").after(menuOpenLink);

        let openLink = _ucUtils.createElement(document, "menuitem", {
            id: "openLinkInPrivateTab",
            label: "Open Link in New Private Tab",
            accesskey: "v",
            class: this.menuClass,
            hidden: true,
            oncommand: `openLinkIn(gContextMenu.linkURL, "tab", gContextMenu._openLinkInParameters({ userContextId: privateTab.container.userContextId, triggeringPrincipal: document.nodePrincipal, }));`,
        });

        document.getElementById("contentAreaContextMenu").addEventListener("popupshowing", this);
        document.getElementById("contentAreaContextMenu").addEventListener("popuphidden", this);
        document.getElementById("context-openlinkintab").after(openLink);

        let toggleTab = _ucUtils.createElement(document, "menuitem", {
            id: "toggleTabPrivateState",
            label: "Private Tab",
            type: "checkbox",
            accesskey: "v",
            acceltext: ShortcutUtils.prettifyShortcut(toggleKey),
            oncommand: "privateTab.togglePrivate(TabContextMenu.contextTab)",
        });
        document.getElementById("context_pinTab").after(toggleTab);
        document.getElementById("tabContextMenu").addEventListener("popupshowing", this);

        let privateMask = document.getElementsByClassName("private-browsing-indicator")[0];
        privateMask.id = "private-mask";

        gBrowser.tabContainer.addEventListener("TabSelect", this);

        addEventListener("XULFrameLoaderCreated", this);

        if (this.observePrivateTabs) gBrowser.tabContainer.addEventListener("TabClose", this);

        MozElements.MozTab.prototype.getAttribute = function (att) {
            if (att == "usercontextid" && this.isToggling) {
                delete this.isToggling;
                return privateTab.orig_getAttribute.call(this, att)
                    ? 0
                    : privateTab.container.userContextId;
            } else return privateTab.orig_getAttribute.call(this, att);
        };

        if (!privateTabGlobal.privateTabsInited)
            CustomizableUI.createWidget({
                id: this.BTN_ID,
                type: "custom",
                defaultArea: CustomizableUI.AREA_NAVBAR,
                showInPrivateBrowsing: false,
                onBuild: (doc) => {
                    let btn = _ucUtils.createElement(doc, "toolbarbutton", {
                        id: this.BTN_ID,
                        label: "New Private Tab",
                        tooltiptext: `Open a new private tab (${ShortcutUtils.prettifyShortcut(
                            newPrivateTabKey
                        )})`,
                        class: "toolbarbutton-1 chromeclass-toolbar-additional",
                        oncommand: "privateTab.BrowserOpenTabPrivate()",
                    });

                    return btn;
                },
            });
        privateTabGlobal.privateTabsInited = true;
    }

    init() {
        let privateTabGlobal = _ucUtils.sharedGlobal.privateTabGlobal;
        ContextualIdentityService.ensureDataReady();
        this.container = ContextualIdentityService._identities.find(
            (container) => container.name == "Private"
        );
        if (!this.container) {
            ContextualIdentityService.create("Private", "fingerprint", "purple");
            this.container = ContextualIdentityService._identities.find(
                (container) => container.name == "Private"
            );
        } else if (!this.config.neverClearData) {
            this.clearData();
        }

        this.setStyle();
        this.sss.loadAndRegisterSheet(this.STYLE.url, this.STYLE.type);

        if (!privateTabGlobal.privateTabsInited) {
            let { getBrowserWindow } = Cu.import("resource:///modules/PlacesUIUtils.jsm");
            let openTabsetString = PlacesUIUtils.openTabset.toString();
            eval(
                `PlacesUIUtils.openTabset = ${
                    openTabsetString.startsWith("function") ? "" : "function "
                }` +
                    openTabsetString.replace(
                        /(\s+)(inBackground: loadInBackground,)/,
                        "$1$2$1userContextId: aEvent.userContextId || 0,"
                    )
            );

            eval(
                "PlacesUIUtils._openNodeIn = " +
                    PlacesUIUtils._openNodeIn
                        .toString()
                        .replace(/(\s+)(aPrivate = false)\n/, "$1$2,$1userContextId = 0\n")
                        .replace(/(\s+)(private: aPrivate,)\n/, "$1$2$1userContextId,\n")
            );
        }

        let { UUIDMap } = Cu.import("resource://gre/modules/Extension.jsm");
        let TST_ID = "[email protected]";
        this.TST_UUID = UUIDMap.get(TST_ID, false);

        if (this.TST_UUID) this.setTstStyle(this.TST_UUID);
        if (AddonManager && location.href === "chrome://browser/content/browser.xhtml")
            AddonManager.addAddonListener({
                onInstalled: (addon) => {
                    if (addon.id == TST_ID) this.setTstStyle(UUIDMap.get(TST_ID, false));
                },
                onUninstalled: (addon) => {
                    if (addon.id == TST_ID)
                        this.sss.unregisterSheet(this.TST_STYLE.url, this.TST_STYLE.type);
                },
            });

        if (!this.config.neverClearData) {
            Services.obs.addObserver(this, "quit-application-granted");
        }
    }

    observe(sub, top, data) {
        this.clearData();
        if (!this.config.restoreTabsOnRestart) this.closeTabs();
    }

    clearData() {
        Services.clearData.deleteDataFromOriginAttributesPattern({
            userContextId: this.container.userContextId,
        });
    }

    closeTabs() {
        ContextualIdentityService._forEachContainerTab((tab, tabbrowser) => {
            if (tab.userContextId == this.container.userContextId) tabbrowser.removeTab(tab);
        });
    }

    duplicateTab(tab, { index, inBackground }) {
        // Create a new tab.
        let userContextId = tab.getAttribute("usercontextid");

        let tabOptions = {
            userContextId,
            index,
            skipAnimation: true,
            ...(tab == gBrowser.selectedTab ? { relatedToCurrent: true, ownerTab: tab } : {}),
        };
        let newTab = gBrowser.addTrustedTab(null, tabOptions);

        // Start the throbber to pretend we're doing something while actually
        // waiting for data from the frame script. This throbber is disabled
        // if the URI is a local about: URI.
        let uriObj = tab.linkedBrowser.currentURI;
        if (!uriObj || (uriObj && !uriObj.schemeIs("about"))) {
            newTab.setAttribute("busy", "true");
        }

        // Hack to ensure that the about:home, about:newtab, and about:welcome
        // favicon is loaded instantaneously, to avoid flickering and improve
        // perceived performance.
        gBrowser.setDefaultIcon(newTab, uriObj);

        // Collect state before flushing.
        let tabState = this.TabState.collect(tab, SessionStore.getCustomTabValue(tab));

        // Flush to get the latest tab state to duplicate.
        let browser = tab.linkedBrowser;
        this.TabStateFlusher.flush(browser).then(() => {
            // The new tab might have been closed in the meantime.
            if (newTab.closing || !newTab.linkedBrowser) return;

            let window = newTab.ownerGlobal;

            // The tab or its window might be gone.
            if (!window || !window.__SSi) return;

            // Update state with flushed data. We can't use TabState.clone() here as
            // the tab to duplicate may have already been closed. In that case we
            // only have access to the <xul:browser>.
            let options = { includePrivateData: true };
            this.TabState.copyFromCache(browser.permanentKey, tabState, options);

            tabState.index += 0;
            tabState.index = Math.max(1, Math.min(tabState.index, tabState.entries.length));
            tabState.pinned = false;

            if (!inBackground) gBrowser.selectedTab = newTab;

            // Restore the state into the new tab.
            this.SSI.restoreTab(newTab, tabState, {
                restoreImmediately: true,
            });
        });

        return newTab;
    }

    togglePrivate(tab = gBrowser.selectedTab) {
        tab.isToggling = true;
        let shouldSelect = tab == gBrowser.selectedTab;
        let newTab = this.duplicateTab(tab, {
            index: shouldSelect ? tab._tPos + 1 : tab._tPos,
            inBackground: !shouldSelect,
        });
        if (shouldSelect) if (gURLBar.focused) gURLBar.focus();
        gBrowser.removeTab(tab, { animate: false, closeWindowWithLastTab: false });
    }

    toggleMask() {
        let privateMask = document.getElementById("private-mask");
        if (gBrowser.selectedTab.isToggling)
            privateMask.setAttribute(
                "enabled",
                gBrowser.selectedTab.userContextId == this.container.userContextId
                    ? "false"
                    : "true"
            );
        else
            privateMask.setAttribute(
                "enabled",
                gBrowser.selectedTab.userContextId == this.container.userContextId
                    ? "true"
                    : "false"
            );
    }

    BrowserOpenTabPrivate() {
        openTrustedLinkIn(BROWSER_NEW_TAB_URL, "tab", {
            userContextId: this.container.userContextId,
        });
    }

    isPrivate(tab) {
        return tab.getAttribute("usercontextid") == this.container.userContextId;
    }

    contentContext(_e) {
        let tab = gBrowser.getTabForBrowser(gContextMenu.browser);
        gContextMenu.showItem(
            "openLinkInPrivateTab",
            gContextMenu.onSaveableLink || gContextMenu.onPlainTextLink
        );
        if (this.isPrivate(tab)) gContextMenu.showItem("context-openlinkincontainertab", false);
    }

    hideContext(_e) {
        document.getElementById("openLinkInPrivateTab").hidden = true;
    }

    tabContext(_e) {
        document
            .getElementById("toggleTabPrivateState")
            .setAttribute(
                "checked",
                TabContextMenu.contextTab.userContextId == this.container.userContextId
            );
    }

    placesContext(_e) {
        document.getElementById("openPrivate").disabled = document.getElementById(
            "placesContext_open:newtab"
        ).disabled;
        document.getElementById("openPrivate").hidden = document.getElementById(
            "placesContext_open:newtab"
        ).hidden;
        document.getElementById("openAllPrivate").disabled = document.getElementById(
            "placesContext_openBookmarkContainer:tabs"
        ).disabled;
        document.getElementById("openAllPrivate").hidden = document.getElementById(
            "placesContext_openBookmarkContainer:tabs"
        ).hidden;
        document.getElementById("openAllLinksPrivate").disabled = document.getElementById(
            "placesContext_openLinks:tabs"
        ).disabled;
        document.getElementById("openAllLinksPrivate").hidden = document.getElementById(
            "placesContext_openLinks:tabs"
        ).hidden;
    }

    handleEvent(e) {
        switch (e.type) {
            case "TabSelect":
                this.onTabSelect(e);
                break;
            case "TabClose":
                this.onTabClose(e);
                break;
            case "XULFrameLoaderCreated":
                this.privateListener(e);
                break;
            case "popupshowing":
                if (e.target === document.getElementById("placesContext")) this.placesContext(e);
                if (e.target === document.getElementById("contentAreaContextMenu"))
                    this.contentContext(e);
                if (e.target === document.getElementById("tabContextMenu")) this.tabContext(e);
                break;
            case "popuphidden":
                if (e.target === document.getElementById("contentAreaContextMenu"))
                    this.hideContext(e);
                break;
            case "click":
                if (e.button == 0) this.BrowserOpenTabPrivate();
                else if (e.button == 2) {
                    document.popupNode = document.getElementById(this.BTN_ID);
                    document
                        .getElementById("toolbar-context-menu")
                        .openPopup(this, "after_start", 14, -10, false, false);
                    document.getElementsByClassName(
                        "customize-context-removeFromToolbar"
                    )[0].disabled = false;
                    document.getElementsByClassName(
                        "customize-context-moveToPanel"
                    )[0].disabled = false;
                    e.preventDefault();
                }
                break;
        }
    }

    privateListener(e) {
        let browser = e.target;
        let tab = gBrowser.getTabForBrowser(browser);
        if (!tab) return;
        let isPrivate = this.isPrivate(tab);

        if (!isPrivate) {
            if (this.observePrivateTabs) {
                this.openTabs.delete(tab);
                if (!this.openTabs.size) this.clearData();
            }
            return;
        }

        if (this.observePrivateTabs) this.openTabs.add(tab);

        browser.browsingContext.useGlobalHistory = false;
    }

    onTabSelect(e) {
        if (e.target.userContextId != e.detail.previousTab.userContextId) this.toggleMask();
    }

    onTabClose(e) {
        if (this.isPrivate(e.target)) {
            this.openTabs.delete(e.target);
            if (!this.openTabs.size) this.clearData();
        }
    }

    get observePrivateTabs() {
        return (
            this._observePrivateTabs ||
            (this._observePrivateTabs =
                !this.config.neverClearData && !this.config.doNotClearDataUntilFxIsClosed)
        );
    }

    setStyle() {
        this.STYLE = {
            url: Services.io.newURI(
                "data:text/css;charset=UTF-8," +
                    encodeURIComponent(
                        `.privatetab-icon, #${this.BTN_ID}, #${this.BTN2_ID} { list-style-image: url(chrome://browser/skin/privateBrowsing.svg) !important; fill: currentColor; -moz-context-properties: fill; } @-moz-document url('chrome://browser/content/browser.xhtml') { #private-mask[enabled="true"] { display: block !important; } #tabbrowser-tabs[hasadjacentnewprivatetabbutton]:not([overflow="true"]) ~ #${this.BTN_ID}, #tabbrowser-tabs[overflow="true"] > #tabbrowser-arrowscrollbox > #${this.BTN2_ID}, #tabbrowser-tabs:not([hasadjacentnewprivatetabbutton]) > #tabbrowser-arrowscrollbox > #${this.BTN2_ID}, #TabsToolbar[customizing="true"] #${this.BTN2_ID} { display: none; } .tabbrowser-tab[usercontextid="${this.container.userContextId}"] .tab-label { text-decoration: underline !important; text-decoration-color: -moz-nativehyperlinktext !important; text-decoration-style: dashed !important; } .tabbrowser-tab[usercontextid="${this.container.userContextId}"][pinned] .tab-icon-image, .tabbrowser-tab[usercontextid="${this.container.userContextId}"][pinned] .tab-throbber { border-bottom: 1px dashed -moz-nativehyperlinktext !important; }}`
                    )
            ),
            type: this.sss.USER_SHEET,
        };
    }

    setTstStyle(uuid) {
        this.TST_STYLE = {
            url: Services.io.newURI(
                "data:text/css;charset=UTF-8," +
                    encodeURIComponent(
                        `@-moz-document url-prefix(moz-extension://${uuid}/sidebar/sidebar.html) { .tab.contextual-identity-firefox-container-${this.container.userContextId} .label-content { text-decoration: underline !important; text-decoration-color: -moz-nativehyperlinktext !important; text-decoration-style: dashed !important; } .tab.contextual-identity-firefox-container-${this.container.userContextId} tab-favicon { border-bottom: 1px dashed -moz-nativehyperlinktext !important;}}`
                    )
            ),
            type: this.sss.USER_SHEET,
        };
        this.sss.loadAndRegisterSheet(this.TST_STYLE.url, this.TST_STYLE.type);
    }
}

window.privateTab = new PrivateTabManager();