diff options
Diffstat (limited to 'application/basilisk/components/preferences/sync.js')
| -rw-r--r-- | application/basilisk/components/preferences/sync.js | 671 |
1 files changed, 671 insertions, 0 deletions
diff --git a/application/basilisk/components/preferences/sync.js b/application/basilisk/components/preferences/sync.js new file mode 100644 index 000000000..5d923833c --- /dev/null +++ b/application/basilisk/components/preferences/sync.js @@ -0,0 +1,671 @@ +/* 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/. */ + +Components.utils.import("resource://services-sync/main.js"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +XPCOMUtils.defineLazyGetter(this, "FxAccountsCommon", function() { + return Components.utils.import("resource://gre/modules/FxAccountsCommon.js", {}); +}); + +XPCOMUtils.defineLazyModuleGetter(this, "fxAccounts", + "resource://gre/modules/FxAccounts.jsm"); + +const PAGE_NO_ACCOUNT = 0; +const PAGE_HAS_ACCOUNT = 1; +const PAGE_NEEDS_UPDATE = 2; +const FXA_PAGE_LOGGED_OUT = 3; +const FXA_PAGE_LOGGED_IN = 4; + +// Indexes into the "login status" deck. +// We are in a successful verified state - everything should work! +const FXA_LOGIN_VERIFIED = 0; +// We have logged in to an unverified account. +const FXA_LOGIN_UNVERIFIED = 1; +// We are logged in locally, but the server rejected our credentials. +const FXA_LOGIN_FAILED = 2; + +var gSyncPane = { + prefArray: ["engine.bookmarks", "engine.passwords", "engine.prefs", + "engine.tabs", "engine.history"], + + get page() { + return document.getElementById("weavePrefsDeck").selectedIndex; + }, + + set page(val) { + document.getElementById("weavePrefsDeck").selectedIndex = val; + }, + + get _usingCustomServer() { + return Weave.Svc.Prefs.isSet("serverURL"); + }, + + needsUpdate() { + this.page = PAGE_NEEDS_UPDATE; + let label = document.getElementById("loginError"); + label.textContent = Weave.Utils.getErrorString(Weave.Status.login); + label.className = "error"; + }, + + init() { + this._setupEventListeners(); + + // If the Service hasn't finished initializing, wait for it. + let xps = Components.classes["@mozilla.org/weave/service;1"] + .getService(Components.interfaces.nsISupports) + .wrappedJSObject; + + if (xps.ready) { + this._init(); + return; + } + + // it may take some time before we can determine what provider to use + // and the state of that provider, so show the "please wait" page. + this._showLoadPage(xps); + + let onUnload = function() { + window.removeEventListener("unload", onUnload); + try { + Services.obs.removeObserver(onReady, "weave:service:ready"); + } catch (e) {} + }; + + let onReady = function() { + Services.obs.removeObserver(onReady, "weave:service:ready"); + window.removeEventListener("unload", onUnload); + this._init(); + }.bind(this); + + Services.obs.addObserver(onReady, "weave:service:ready", false); + window.addEventListener("unload", onUnload); + + xps.ensureLoaded(); + }, + + _showLoadPage(xps) { + let username; + try { + username = Services.prefs.getCharPref("services.sync.username"); + } catch (e) {} + if (!username) { + this.page = FXA_PAGE_LOGGED_OUT; + } else if (xps.fxAccountsEnabled) { + // Use cached values while we wait for the up-to-date values + let cachedComputerName; + try { + cachedComputerName = Services.prefs.getCharPref("services.sync.client.name"); + } catch (e) { + cachedComputerName = ""; + } + document.getElementById("fxaEmailAddress1").textContent = username; + this._populateComputerName(cachedComputerName); + this.page = FXA_PAGE_LOGGED_IN; + } else { // Old Sync + this.page = PAGE_HAS_ACCOUNT; + } + }, + + _init() { + let topics = ["weave:service:login:error", + "weave:service:login:finish", + "weave:service:start-over:finish", + "weave:service:setup-complete", + "weave:service:logout:finish", + FxAccountsCommon.ONVERIFIED_NOTIFICATION, + FxAccountsCommon.ONLOGIN_NOTIFICATION, + FxAccountsCommon.ON_PROFILE_CHANGE_NOTIFICATION, + ]; + // Add the observers now and remove them on unload + // XXXzpao This should use Services.obs.* but Weave's Obs does nice handling + // of `this`. Fix in a followup. (bug 583347) + topics.forEach(function(topic) { + Weave.Svc.Obs.add(topic, this.updateWeavePrefs, this); + }, this); + + window.addEventListener("unload", function() { + topics.forEach(function(topic) { + Weave.Svc.Obs.remove(topic, this.updateWeavePrefs, this); + }, gSyncPane); + }); + + XPCOMUtils.defineLazyGetter(this, "_stringBundle", () => { + return Services.strings.createBundle("chrome://browser/locale/preferences/preferences.properties"); + }); + + XPCOMUtils.defineLazyGetter(this, "_accountsStringBundle", () => { + return Services.strings.createBundle("chrome://browser/locale/accounts.properties"); + }); + + let url = Services.prefs.getCharPref("identity.mobilepromo.android") + "sync-preferences"; + document.getElementById("fxaMobilePromo-android").setAttribute("href", url); + document.getElementById("fxaMobilePromo-android-hasFxaAccount").setAttribute("href", url); + url = Services.prefs.getCharPref("identity.mobilepromo.ios") + "sync-preferences"; + document.getElementById("fxaMobilePromo-ios").setAttribute("href", url); + document.getElementById("fxaMobilePromo-ios-hasFxaAccount").setAttribute("href", url); + + document.getElementById("tosPP-small-ToS").setAttribute("href", gSyncUtils.tosURL); + document.getElementById("tosPP-normal-ToS").setAttribute("href", gSyncUtils.tosURL); + document.getElementById("tosPP-small-PP").setAttribute("href", gSyncUtils.privacyPolicyURL); + document.getElementById("tosPP-normal-PP").setAttribute("href", gSyncUtils.privacyPolicyURL); + + fxAccounts.promiseAccountsManageURI(this._getEntryPoint()).then(accountsManageURI => { + document.getElementById("verifiedManage").setAttribute("href", accountsManageURI); + }); + + this.updateWeavePrefs(); + + this._initProfileImageUI(); + }, + + _toggleComputerNameControls(editMode) { + let textbox = document.getElementById("fxaSyncComputerName"); + textbox.disabled = !editMode; + document.getElementById("fxaChangeDeviceName").hidden = editMode; + document.getElementById("fxaCancelChangeDeviceName").hidden = !editMode; + document.getElementById("fxaSaveChangeDeviceName").hidden = !editMode; + }, + + _focusComputerNameTextbox() { + let textbox = document.getElementById("fxaSyncComputerName"); + let valLength = textbox.value.length; + textbox.focus(); + textbox.setSelectionRange(valLength, valLength); + }, + + _blurComputerNameTextbox() { + document.getElementById("fxaSyncComputerName").blur(); + }, + + _focusAfterComputerNameTextbox() { + // Focus the most appropriate element that's *not* the "computer name" box. + Services.focus.moveFocus(window, + document.getElementById("fxaSyncComputerName"), + Services.focus.MOVEFOCUS_FORWARD, 0); + }, + + _updateComputerNameValue(save) { + if (save) { + let textbox = document.getElementById("fxaSyncComputerName"); + Weave.Service.clientsEngine.localName = textbox.value; + } + this._populateComputerName(Weave.Service.clientsEngine.localName); + }, + + _setupEventListeners() { + function setEventListener(aId, aEventType, aCallback) { + document.getElementById(aId) + .addEventListener(aEventType, aCallback.bind(gSyncPane)); + } + + setEventListener("noAccountSetup", "click", function(aEvent) { + aEvent.stopPropagation(); + gSyncPane.openSetup(null); + }); + setEventListener("noAccountPair", "click", function(aEvent) { + aEvent.stopPropagation(); + gSyncPane.openSetup("pair"); + }); + setEventListener("syncChangePassword", "command", + () => gSyncUtils.changePassword()); + setEventListener("syncResetPassphrase", "command", + () => gSyncUtils.resetPassphrase()); + setEventListener("syncReset", "command", gSyncPane.resetSync); + setEventListener("syncAddDeviceLabel", "click", function() { + gSyncPane.openAddDevice(); + return false; + }); + setEventListener("syncEnginesList", "select", function() { + if (this.selectedCount) + this.clearSelection(); + }); + setEventListener("syncComputerName", "change", function(e) { + gSyncUtils.changeName(e.target); + }); + setEventListener("fxaChangeDeviceName", "command", function() { + this._toggleComputerNameControls(true); + this._focusComputerNameTextbox(); + }); + setEventListener("fxaCancelChangeDeviceName", "command", function() { + // We explicitly blur the textbox because of bug 75324, then after + // changing the state of the buttons, force focus to whatever the focus + // manager thinks should be next (which on the mac, depends on an OSX + // keyboard access preference) + this._blurComputerNameTextbox(); + this._toggleComputerNameControls(false); + this._updateComputerNameValue(false); + this._focusAfterComputerNameTextbox(); + }); + setEventListener("fxaSaveChangeDeviceName", "command", function() { + // Work around bug 75324 - see above. + this._blurComputerNameTextbox(); + this._toggleComputerNameControls(false); + this._updateComputerNameValue(true); + this._focusAfterComputerNameTextbox(); + }); + setEventListener("unlinkDevice", "click", function() { + gSyncPane.startOver(true); + return false; + }); + setEventListener("loginErrorUpdatePass", "click", function() { + gSyncPane.updatePass(); + return false; + }); + setEventListener("loginErrorResetPass", "click", function() { + gSyncPane.resetPass(); + return false; + }); + setEventListener("loginErrorStartOver", "click", function() { + gSyncPane.startOver(true); + return false; + }); + setEventListener("noFxaSignUp", "command", function() { + gSyncPane.signUp(); + return false; + }); + setEventListener("noFxaSignIn", "command", function() { + gSyncPane.signIn(); + return false; + }); + setEventListener("fxaUnlinkButton", "command", function() { + gSyncPane.unlinkFirefoxAccount(true); + }); + setEventListener("verifyFxaAccount", "command", + gSyncPane.verifyFirefoxAccount); + setEventListener("unverifiedUnlinkFxaAccount", "command", function() { + /* no warning as account can't have previously synced */ + gSyncPane.unlinkFirefoxAccount(false); + }); + setEventListener("rejectReSignIn", "command", + gSyncPane.reSignIn); + setEventListener("rejectUnlinkFxaAccount", "command", function() { + gSyncPane.unlinkFirefoxAccount(true); + }); + setEventListener("fxaSyncComputerName", "keypress", function(e) { + if (e.keyCode == KeyEvent.DOM_VK_RETURN) { + document.getElementById("fxaSaveChangeDeviceName").click(); + } else if (e.keyCode == KeyEvent.DOM_VK_ESCAPE) { + document.getElementById("fxaCancelChangeDeviceName").click(); + } + }); + }, + + _initProfileImageUI() { + try { + if (Services.prefs.getBoolPref("identity.fxaccounts.profile_image.enabled")) { + document.getElementById("fxaProfileImage").hidden = false; + } + } catch (e) { } + }, + + updateWeavePrefs() { + let service = Components.classes["@mozilla.org/weave/service;1"] + .getService(Components.interfaces.nsISupports) + .wrappedJSObject; + // service.fxAccountsEnabled is false iff sync is already configured for + // the legacy provider. + if (service.fxAccountsEnabled) { + let displayNameLabel = document.getElementById("fxaDisplayName"); + let fxaEmailAddress1Label = document.getElementById("fxaEmailAddress1"); + fxaEmailAddress1Label.hidden = false; + displayNameLabel.hidden = true; + + let profileInfoEnabled; + try { + profileInfoEnabled = Services.prefs.getBoolPref("identity.fxaccounts.profile_image.enabled"); + } catch (ex) {} + + // determine the fxa status... + this._showLoadPage(service); + + fxAccounts.getSignedInUser().then(data => { + if (!data) { + this.page = FXA_PAGE_LOGGED_OUT; + return false; + } + this.page = FXA_PAGE_LOGGED_IN; + // We are logged in locally, but maybe we are in a state where the + // server rejected our credentials (eg, password changed on the server) + let fxaLoginStatus = document.getElementById("fxaLoginStatus"); + let syncReady; + // Not Verfied implies login error state, so check that first. + if (!data.verified) { + fxaLoginStatus.selectedIndex = FXA_LOGIN_UNVERIFIED; + syncReady = false; + // So we think we are logged in, so login problems are next. + // (Although if the Sync identity manager is still initializing, we + // ignore login errors and assume all will eventually be good.) + // LOGIN_FAILED_LOGIN_REJECTED explicitly means "you must log back in". + // All other login failures are assumed to be transient and should go + // away by themselves, so aren't reflected here. + } else if (Weave.Status.login == Weave.LOGIN_FAILED_LOGIN_REJECTED) { + fxaLoginStatus.selectedIndex = FXA_LOGIN_FAILED; + syncReady = false; + // Else we must be golden (or in an error state we expect to magically + // resolve itself) + } else { + fxaLoginStatus.selectedIndex = FXA_LOGIN_VERIFIED; + syncReady = true; + } + fxaEmailAddress1Label.textContent = data.email; + document.getElementById("fxaEmailAddress2").textContent = data.email; + document.getElementById("fxaEmailAddress3").textContent = data.email; + this._populateComputerName(Weave.Service.clientsEngine.localName); + let engines = document.getElementById("fxaSyncEngines") + for (let checkbox of engines.querySelectorAll("checkbox")) { + checkbox.disabled = !syncReady; + } + document.getElementById("fxaChangeDeviceName").disabled = !syncReady; + + // Clear the profile image (if any) of the previously logged in account. + document.getElementById("fxaProfileImage").style.removeProperty("list-style-image"); + + // If the account is verified the next promise in the chain will + // fetch profile data. + return data.verified; + }).then(isVerified => { + if (isVerified) { + return fxAccounts.getSignedInUserProfile(); + } + return null; + }).then(data => { + let fxaLoginStatus = document.getElementById("fxaLoginStatus"); + if (data && profileInfoEnabled) { + if (data.displayName) { + fxaLoginStatus.setAttribute("hasName", true); + displayNameLabel.hidden = false; + displayNameLabel.textContent = data.displayName; + } else { + fxaLoginStatus.removeAttribute("hasName"); + } + if (data.avatar) { + let bgImage = "url(\"" + data.avatar + "\")"; + let profileImageElement = document.getElementById("fxaProfileImage"); + profileImageElement.style.listStyleImage = bgImage; + + let img = new Image(); + img.onerror = () => { + // Clear the image if it has trouble loading. Since this callback is asynchronous + // we check to make sure the image is still the same before we clear it. + if (profileImageElement.style.listStyleImage === bgImage) { + profileImageElement.style.removeProperty("list-style-image"); + } + }; + img.src = data.avatar; + } + } else { + fxaLoginStatus.removeAttribute("hasName"); + } + }, err => { + FxAccountsCommon.log.error(err); + }).catch(err => { + // If we get here something's really busted + Cu.reportError(String(err)); + }); + + // If fxAccountEnabled is false and we are in a "not configured" state, + // then fxAccounts is probably fully disabled rather than just unconfigured, + // so handle this case. This block can be removed once we remove support + // for fxAccounts being disabled. + } else if (Weave.Status.service == Weave.CLIENT_NOT_CONFIGURED || + Weave.Svc.Prefs.get("firstSync", "") == "notReady") { + this.page = PAGE_NO_ACCOUNT; + // else: sync was previously configured for the legacy provider, so we + // make the "old" panels available. + } else if (Weave.Status.login == Weave.LOGIN_FAILED_INVALID_PASSPHRASE || + Weave.Status.login == Weave.LOGIN_FAILED_LOGIN_REJECTED) { + this.needsUpdate(); + } else { + this.page = PAGE_HAS_ACCOUNT; + document.getElementById("accountName").textContent = Weave.Service.identity.account; + document.getElementById("syncComputerName").value = Weave.Service.clientsEngine.localName; + document.getElementById("tosPP-normal").hidden = this._usingCustomServer; + } + }, + + startOver(showDialog) { + if (showDialog) { + let flags = Services.prompt.BUTTON_POS_0 * Services.prompt.BUTTON_TITLE_IS_STRING + + Services.prompt.BUTTON_POS_1 * Services.prompt.BUTTON_TITLE_CANCEL + + Services.prompt.BUTTON_POS_1_DEFAULT; + let buttonChoice = + Services.prompt.confirmEx(window, + this._stringBundle.GetStringFromName("syncUnlink.title"), + this._stringBundle.GetStringFromName("syncUnlink.label"), + flags, + this._stringBundle.GetStringFromName("syncUnlinkConfirm.label"), + null, null, null, {}); + + // If the user selects cancel, just bail + if (buttonChoice == 1) + return; + } + + Weave.Service.startOver(); + this.updateWeavePrefs(); + }, + + updatePass() { + if (Weave.Status.login == Weave.LOGIN_FAILED_LOGIN_REJECTED) + gSyncUtils.changePassword(); + else + gSyncUtils.updatePassphrase(); + }, + + resetPass() { + if (Weave.Status.login == Weave.LOGIN_FAILED_LOGIN_REJECTED) + gSyncUtils.resetPassword(); + else + gSyncUtils.resetPassphrase(); + }, + + _getEntryPoint() { + let params = new URLSearchParams(document.URL.split("#")[0].split("?")[1] || ""); + return params.get("entrypoint") || "preferences"; + }, + + _openAboutAccounts(action) { + let entryPoint = this._getEntryPoint(); + let params = new URLSearchParams(); + if (action) { + params.set("action", action); + } + params.set("entrypoint", entryPoint); + + this.replaceTabWithUrl("about:accounts?" + params); + }, + + /** + * Invoke the Sync setup wizard. + * + * @param wizardType + * Indicates type of wizard to launch: + * null -- regular set up wizard + * "pair" -- pair a device first + * "reset" -- reset sync + */ + openSetup(wizardType) { + let service = Components.classes["@mozilla.org/weave/service;1"] + .getService(Components.interfaces.nsISupports) + .wrappedJSObject; + + if (service.fxAccountsEnabled) { + this._openAboutAccounts(); + } else { + let win = Services.wm.getMostRecentWindow("Weave:AccountSetup"); + if (win) + win.focus(); + else { + window.openDialog("chrome://browser/content/sync/setup.xul", + "weaveSetup", "centerscreen,chrome,resizable=no", + wizardType); + } + } + }, + + openContentInBrowser(url, options) { + let win = Services.wm.getMostRecentWindow("navigator:browser"); + if (!win) { + // no window to use, so use _openLink to create a new one. We don't + // always use that as it prefers to open a new window rather than use + // an existing one. + gSyncUtils._openLink(url); + return; + } + win.switchToTabHavingURI(url, true, options); + }, + + // Replace the current tab with the specified URL. + replaceTabWithUrl(url) { + // Get the <browser> element hosting us. + let browser = window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebNavigation) + .QueryInterface(Ci.nsIDocShell) + .chromeEventHandler; + // And tell it to load our URL. + browser.loadURI(url); + }, + + signUp() { + this._openAboutAccounts("signup"); + }, + + signIn() { + this._openAboutAccounts("signin"); + }, + + reSignIn() { + this._openAboutAccounts("reauth"); + }, + + + clickOrSpaceOrEnterPressed(event) { + // Note: charCode is deprecated, but 'char' not yet implemented. + // Replace charCode with char when implemented, see Bug 680830 + return ((event.type == "click" && event.button == 0) || + (event.type == "keypress" && + (event.charCode == KeyEvent.DOM_VK_SPACE || event.keyCode == KeyEvent.DOM_VK_RETURN))); + }, + + openChangeProfileImage(event) { + if (this.clickOrSpaceOrEnterPressed(event)) { + fxAccounts.promiseAccountsChangeProfileURI(this._getEntryPoint(), "avatar") + .then(url => { + this.openContentInBrowser(url, { + replaceQueryString: true + }); + }); + // Prevent page from scrolling on the space key. + event.preventDefault(); + } + }, + + openManageFirefoxAccount(event) { + if (this.clickOrSpaceOrEnterPressed(event)) { + this.manageFirefoxAccount(); + // Prevent page from scrolling on the space key. + event.preventDefault(); + } + }, + + manageFirefoxAccount() { + fxAccounts.promiseAccountsManageURI(this._getEntryPoint()) + .then(url => { + this.openContentInBrowser(url, { + replaceQueryString: true + }); + }); + }, + + verifyFirefoxAccount() { + let showVerifyNotification = (data) => { + let isError = !data; + let maybeNot = isError ? "Not" : ""; + let sb = this._accountsStringBundle; + let title = sb.GetStringFromName("verification" + maybeNot + "SentTitle"); + let email = !isError && data ? data.email : ""; + let body = sb.formatStringFromName("verification" + maybeNot + "SentBody", [email], 1); + new Notification(title, { body }) + } + + let onError = () => { + showVerifyNotification(); + }; + + let onSuccess = data => { + if (data) { + showVerifyNotification(data); + } else { + onError(); + } + }; + + fxAccounts.resendVerificationEmail() + .then(fxAccounts.getSignedInUser, onError) + .then(onSuccess, onError); + }, + + openOldSyncSupportPage() { + let url = Services.urlFormatter.formatURLPref("app.support.baseURL") + "old-sync"; + this.openContentInBrowser(url); + }, + + unlinkFirefoxAccount(confirm) { + if (confirm) { + // We use a string bundle shared with aboutAccounts. + let sb = Services.strings.createBundle("chrome://browser/locale/syncSetup.properties"); + let disconnectLabel = sb.GetStringFromName("disconnect.label"); + let title = sb.GetStringFromName("disconnect.verify.title"); + let body = sb.GetStringFromName("disconnect.verify.bodyHeading") + + "\n\n" + + sb.GetStringFromName("disconnect.verify.bodyText"); + let ps = Services.prompt; + let buttonFlags = (ps.BUTTON_POS_0 * ps.BUTTON_TITLE_IS_STRING) + + (ps.BUTTON_POS_1 * ps.BUTTON_TITLE_CANCEL) + + ps.BUTTON_POS_1_DEFAULT; + + let factory = Cc["@mozilla.org/prompter;1"] + .getService(Ci.nsIPromptFactory); + let prompt = factory.getPrompt(window, Ci.nsIPrompt); + let bag = prompt.QueryInterface(Ci.nsIWritablePropertyBag2); + bag.setPropertyAsBool("allowTabModal", true); + + let pressed = prompt.confirmEx(title, body, buttonFlags, + disconnectLabel, null, null, null, {}); + + if (pressed != 0) { // 0 is the "continue" button + return; + } + } + fxAccounts.signOut().then(() => { + this.updateWeavePrefs(); + }); + }, + + openAddDevice() { + if (!Weave.Utils.ensureMPUnlocked()) + return; + + let win = Services.wm.getMostRecentWindow("Sync:AddDevice"); + if (win) + win.focus(); + else + window.openDialog("chrome://browser/content/sync/addDevice.xul", + "syncAddDevice", "centerscreen,chrome,resizable=no"); + }, + + resetSync() { + this.openSetup("reset"); + }, + + _populateComputerName(value) { + let textbox = document.getElementById("fxaSyncComputerName"); + if (!textbox.hasAttribute("placeholder")) { + textbox.setAttribute("placeholder", + Weave.Utils.getDefaultDeviceName()); + } + textbox.value = value; + }, +}; |