diff options
Diffstat (limited to 'toolkit/components/alerts')
30 files changed, 3534 insertions, 0 deletions
diff --git a/toolkit/components/alerts/AlertNotification.cpp b/toolkit/components/alerts/AlertNotification.cpp new file mode 100644 index 0000000000..3cc2ec4380 --- /dev/null +++ b/toolkit/components/alerts/AlertNotification.cpp @@ -0,0 +1,373 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "mozilla/AlertNotification.h" + +#include "imgIContainer.h" +#include "imgINotificationObserver.h" +#include "imgIRequest.h" +#include "imgLoader.h" +#include "nsAlertsUtils.h" +#include "nsComponentManagerUtils.h" +#include "nsContentUtils.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" + +#include "mozilla/Unused.h" + +namespace mozilla { + +NS_IMPL_ISUPPORTS(AlertNotification, nsIAlertNotification) + +AlertNotification::AlertNotification() + : mTextClickable(false), mInPrivateBrowsing(false) {} + +AlertNotification::~AlertNotification() = default; + +NS_IMETHODIMP +AlertNotification::Init(const nsAString& aName, const nsAString& aImageURL, + const nsAString& aTitle, const nsAString& aText, + bool aTextClickable, const nsAString& aCookie, + const nsAString& aDir, const nsAString& aLang, + const nsAString& aData, nsIPrincipal* aPrincipal, + bool aInPrivateBrowsing, bool aRequireInteraction, + bool aSilent, const nsTArray<uint32_t>& aVibrate) { + mName = aName; + mImageURL = aImageURL; + mTitle = aTitle; + mText = aText; + mTextClickable = aTextClickable; + mCookie = aCookie; + mDir = aDir; + mLang = aLang; + mData = aData; + mPrincipal = aPrincipal; + mInPrivateBrowsing = aInPrivateBrowsing; + mRequireInteraction = aRequireInteraction; + mSilent = aSilent; + mVibrate = aVibrate.Clone(); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::SetActions( + const nsTArray<RefPtr<nsIAlertAction>>& aActions) { + mActions = aActions.Clone(); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetName(nsAString& aName) { + aName = mName; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetImageURL(nsAString& aImageURL) { + aImageURL = mImageURL; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetTitle(nsAString& aTitle) { + aTitle = mTitle; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetText(nsAString& aText) { + aText = mText; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetTextClickable(bool* aTextClickable) { + *aTextClickable = mTextClickable; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetCookie(nsAString& aCookie) { + aCookie = mCookie; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetDir(nsAString& aDir) { + aDir = mDir; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetLang(nsAString& aLang) { + aLang = mLang; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetRequireInteraction(bool* aRequireInteraction) { + *aRequireInteraction = mRequireInteraction; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetData(nsAString& aData) { + aData = mData; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetPrincipal(nsIPrincipal** aPrincipal) { + NS_IF_ADDREF(*aPrincipal = mPrincipal); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetURI(nsIURI** aURI) { + if (!nsAlertsUtils::IsActionablePrincipal(mPrincipal)) { + *aURI = nullptr; + return NS_OK; + } + auto* basePrin = BasePrincipal::Cast(mPrincipal); + return basePrin->GetURI(aURI); +} + +NS_IMETHODIMP +AlertNotification::GetInPrivateBrowsing(bool* aInPrivateBrowsing) { + *aInPrivateBrowsing = mInPrivateBrowsing; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetActionable(bool* aActionable) { + *aActionable = nsAlertsUtils::IsActionablePrincipal(mPrincipal); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetSilent(bool* aSilent) { + *aSilent = mSilent; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetVibrate(nsTArray<uint32_t>& aVibrate) { + aVibrate = mVibrate.Clone(); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetActions(nsTArray<RefPtr<nsIAlertAction>>& aActions) { + aActions = mActions.Clone(); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetSource(nsAString& aSource) { + nsAlertsUtils::GetSourceHostPort(mPrincipal, aSource); + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::GetOpaqueRelaunchData(nsAString& aOpaqueRelaunchData) { + aOpaqueRelaunchData = mOpaqueRelaunchData; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::SetOpaqueRelaunchData(const nsAString& aOpaqueRelaunchData) { + mOpaqueRelaunchData = aOpaqueRelaunchData; + return NS_OK; +} + +NS_IMETHODIMP +AlertNotification::LoadImage(uint32_t aTimeout, + nsIAlertNotificationImageListener* aListener, + nsISupports* aUserData, nsICancelable** aRequest) { + NS_ENSURE_ARG(aListener); + NS_ENSURE_ARG_POINTER(aRequest); + *aRequest = nullptr; + + // Exit early if this alert doesn't have an image. + if (mImageURL.IsEmpty()) { + return aListener->OnImageMissing(aUserData); + } + nsCOMPtr<nsIURI> imageURI; + NS_NewURI(getter_AddRefs(imageURI), mImageURL); + if (!imageURI) { + return aListener->OnImageMissing(aUserData); + } + + RefPtr<AlertImageRequest> request = new AlertImageRequest( + imageURI, mPrincipal, mInPrivateBrowsing, aTimeout, aListener, aUserData); + request->Start(); + request.forget(aRequest); + return NS_OK; +} + +NS_IMPL_CYCLE_COLLECTION(AlertImageRequest, mURI, mPrincipal, mListener, + mUserData) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AlertImageRequest) + NS_INTERFACE_MAP_ENTRY(imgINotificationObserver) + NS_INTERFACE_MAP_ENTRY(nsICancelable) + NS_INTERFACE_MAP_ENTRY(nsITimerCallback) + NS_INTERFACE_MAP_ENTRY(nsINamed) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, imgINotificationObserver) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(AlertImageRequest) +NS_IMPL_CYCLE_COLLECTING_RELEASE(AlertImageRequest) + +AlertImageRequest::AlertImageRequest( + nsIURI* aURI, nsIPrincipal* aPrincipal, bool aInPrivateBrowsing, + uint32_t aTimeout, nsIAlertNotificationImageListener* aListener, + nsISupports* aUserData) + : mURI(aURI), + mPrincipal(aPrincipal), + mInPrivateBrowsing(aInPrivateBrowsing), + mTimeout(aTimeout), + mListener(aListener), + mUserData(aUserData) {} + +AlertImageRequest::~AlertImageRequest() { + if (mRequest) { + mRequest->CancelAndForgetObserver(NS_BINDING_ABORTED); + } +} + +void AlertImageRequest::Notify(imgIRequest* aRequest, int32_t aType, + const nsIntRect* aData) { + MOZ_ASSERT(aRequest == mRequest); + + uint32_t imgStatus = imgIRequest::STATUS_ERROR; + nsresult rv = aRequest->GetImageStatus(&imgStatus); + if (NS_WARN_IF(NS_FAILED(rv)) || (imgStatus & imgIRequest::STATUS_ERROR)) { + NotifyMissing(); + return; + } + + // If the image is already decoded, `FRAME_COMPLETE` will fire before + // `LOAD_COMPLETE`, so we can notify the listener immediately. Otherwise, + // we'll need to request a decode when `LOAD_COMPLETE` fires, and wait + // for the first frame. + + if (aType == imgINotificationObserver::LOAD_COMPLETE) { + if (!(imgStatus & imgIRequest::STATUS_FRAME_COMPLETE)) { + nsCOMPtr<imgIContainer> image; + rv = aRequest->GetImage(getter_AddRefs(image)); + if (NS_WARN_IF(NS_FAILED(rv) || !image)) { + NotifyMissing(); + return; + } + + // Ask the image to decode at its intrinsic size. + int32_t width = 0, height = 0; + image->GetWidth(&width); + image->GetHeight(&height); + image->RequestDecodeForSize(gfx::IntSize(width, height), + imgIContainer::FLAG_HIGH_QUALITY_SCALING); + } + return; + } + + if (aType == imgINotificationObserver::FRAME_COMPLETE) { + return NotifyComplete(); + } +} + +NS_IMETHODIMP +AlertImageRequest::Notify(nsITimer* aTimer) { + MOZ_ASSERT(aTimer == mTimer); + return NotifyMissing(); +} + +NS_IMETHODIMP +AlertImageRequest::GetName(nsACString& aName) { + aName.AssignLiteral("AlertImageRequest"); + return NS_OK; +} + +NS_IMETHODIMP +AlertImageRequest::Cancel(nsresult aReason) { + if (mRequest) { + mRequest->Cancel(aReason); + } + // We call `NotifyMissing` here because we won't receive a `LOAD_COMPLETE` + // notification if we cancel the request before it loads (bug 1233086, + // comment 33). Once that's fixed, `nsIAlertNotification::loadImage` could + // return the underlying `imgIRequest` instead of the wrapper. + return NotifyMissing(); +} + +nsresult AlertImageRequest::Start() { + // Keep the request alive until we notify the image listener. + NS_ADDREF_THIS(); + + nsresult rv; + if (mTimeout > 0) { + rv = NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, mTimeout, + nsITimer::TYPE_ONE_SHOT); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NotifyMissing(); + } + } + + // Begin loading the image. + imgLoader* il = imgLoader::NormalLoader(); + if (!il) { + return NotifyMissing(); + } + + // Bug 1237405: `LOAD_ANONYMOUS` disables cookies, but we want to use a + // temporary cookie jar instead. We should also use + // `imgLoader::PrivateBrowsingLoader()` instead of the normal loader. + // Unfortunately, the PB loader checks the load group, and asserts if its + // load context's PB flag isn't set. The fix is to pass the load group to + // `nsIAlertNotification::loadImage`. + int32_t loadFlags = nsIRequest::LOAD_NORMAL; + if (mInPrivateBrowsing) { + loadFlags = nsIRequest::LOAD_ANONYMOUS; + } + + rv = il->LoadImageXPCOM( + mURI, nullptr, nullptr, mPrincipal, nullptr, this, nullptr, loadFlags, + nullptr, nsIContentPolicy::TYPE_INTERNAL_IMAGE, getter_AddRefs(mRequest)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NotifyMissing(); + } + + return NS_OK; +} + +nsresult AlertImageRequest::NotifyMissing() { + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } + if (nsCOMPtr<nsIAlertNotificationImageListener> listener = + std::move(mListener)) { + nsresult rv = listener->OnImageMissing(mUserData); + NS_RELEASE_THIS(); + return rv; + } + + return NS_OK; +} + +void AlertImageRequest::NotifyComplete() { + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } + if (nsCOMPtr<nsIAlertNotificationImageListener> listener = + std::move(mListener)) { + listener->OnImageReady(mUserData, mRequest); + NS_RELEASE_THIS(); + } +} + +} // namespace mozilla diff --git a/toolkit/components/alerts/AlertNotification.h b/toolkit/components/alerts/AlertNotification.h new file mode 100644 index 0000000000..3ecf3c8eea --- /dev/null +++ b/toolkit/components/alerts/AlertNotification.h @@ -0,0 +1,86 @@ +/* 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/. */ + +#ifndef mozilla_AlertNotification_h__ +#define mozilla_AlertNotification_h__ + +#include "imgINotificationObserver.h" +#include "nsIAlertsService.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "nsICancelable.h" +#include "nsINamed.h" +#include "nsIPrincipal.h" +#include "nsString.h" +#include "nsITimer.h" + +namespace mozilla { + +class AlertImageRequest final : public imgINotificationObserver, + public nsICancelable, + public nsITimerCallback, + public nsINamed { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(AlertImageRequest, + imgINotificationObserver) + NS_DECL_IMGINOTIFICATIONOBSERVER + NS_DECL_NSICANCELABLE + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + + AlertImageRequest(nsIURI* aURI, nsIPrincipal* aPrincipal, + bool aInPrivateBrowsing, uint32_t aTimeout, + nsIAlertNotificationImageListener* aListener, + nsISupports* aUserData); + + nsresult Start(); + + private: + virtual ~AlertImageRequest(); + + nsresult NotifyMissing(); + void NotifyComplete(); + + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsIPrincipal> mPrincipal; + bool mInPrivateBrowsing; + uint32_t mTimeout; + nsCOMPtr<nsIAlertNotificationImageListener> mListener; + nsCOMPtr<nsISupports> mUserData; + nsCOMPtr<nsITimer> mTimer; + nsCOMPtr<imgIRequest> mRequest; +}; + +class AlertNotification : public nsIAlertNotification { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIALERTNOTIFICATION + AlertNotification(); + + protected: + virtual ~AlertNotification(); + + private: + nsString mName; + nsString mImageURL; + nsString mTitle; + nsString mText; + bool mTextClickable; + nsString mCookie; + nsString mDir; + nsString mLang; + bool mRequireInteraction; + nsString mData; + nsCOMPtr<nsIPrincipal> mPrincipal; + bool mInPrivateBrowsing; + bool mSilent; + nsTArray<uint32_t> mVibrate; + nsTArray<RefPtr<nsIAlertAction>> mActions; + nsString mOpaqueRelaunchData; +}; + +} // namespace mozilla + +#endif /* mozilla_AlertNotification_h__ */ diff --git a/toolkit/components/alerts/AlertNotificationIPCSerializer.h b/toolkit/components/alerts/AlertNotificationIPCSerializer.h new file mode 100644 index 0000000000..bdec9a8f47 --- /dev/null +++ b/toolkit/components/alerts/AlertNotificationIPCSerializer.h @@ -0,0 +1,128 @@ +/* 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/. */ + +#ifndef mozilla_AlertNotificationIPCSerializer_h__ +#define mozilla_AlertNotificationIPCSerializer_h__ + +#include "nsComponentManagerUtils.h" +#include "nsCOMPtr.h" +#include "nsIAlertsService.h" +#include "nsIPrincipal.h" +#include "nsString.h" + +#include "ipc/IPCMessageUtils.h" + +#include "mozilla/dom/PermissionMessageUtils.h" + +namespace mozilla { +namespace ipc { + +template <> +struct IPDLParamTraits<nsIAlertNotification*> { + static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor, + nsIAlertNotification* aParam) { + bool isNull = !aParam; + if (isNull) { + WriteIPDLParam(aWriter, aActor, isNull); + return; + } + + nsString name, imageURL, title, text, cookie, dir, lang, data; + bool textClickable, inPrivateBrowsing, requireInteraction, silent; + nsCOMPtr<nsIPrincipal> principal; + nsTArray<uint32_t> vibrate; + + if (NS_WARN_IF(NS_FAILED(aParam->GetName(name))) || + NS_WARN_IF(NS_FAILED(aParam->GetImageURL(imageURL))) || + NS_WARN_IF(NS_FAILED(aParam->GetTitle(title))) || + NS_WARN_IF(NS_FAILED(aParam->GetText(text))) || + NS_WARN_IF(NS_FAILED(aParam->GetTextClickable(&textClickable))) || + NS_WARN_IF(NS_FAILED(aParam->GetCookie(cookie))) || + NS_WARN_IF(NS_FAILED(aParam->GetDir(dir))) || + NS_WARN_IF(NS_FAILED(aParam->GetLang(lang))) || + NS_WARN_IF(NS_FAILED(aParam->GetData(data))) || + NS_WARN_IF( + NS_FAILED(aParam->GetPrincipal(getter_AddRefs(principal)))) || + NS_WARN_IF( + NS_FAILED(aParam->GetInPrivateBrowsing(&inPrivateBrowsing))) || + NS_WARN_IF( + NS_FAILED(aParam->GetRequireInteraction(&requireInteraction))) || + NS_WARN_IF(NS_FAILED(aParam->GetSilent(&silent))) || + NS_WARN_IF(NS_FAILED(aParam->GetVibrate(vibrate)))) { + // Write a `null` object if any getter returns an error. Otherwise, the + // receiver will try to deserialize an incomplete object and crash. + WriteIPDLParam(aWriter, aActor, /* isNull */ true); + return; + } + + WriteIPDLParam(aWriter, aActor, isNull); + WriteIPDLParam(aWriter, aActor, name); + WriteIPDLParam(aWriter, aActor, imageURL); + WriteIPDLParam(aWriter, aActor, title); + WriteIPDLParam(aWriter, aActor, text); + WriteIPDLParam(aWriter, aActor, textClickable); + WriteIPDLParam(aWriter, aActor, cookie); + WriteIPDLParam(aWriter, aActor, dir); + WriteIPDLParam(aWriter, aActor, lang); + WriteIPDLParam(aWriter, aActor, data); + WriteIPDLParam(aWriter, aActor, principal); + WriteIPDLParam(aWriter, aActor, inPrivateBrowsing); + WriteIPDLParam(aWriter, aActor, requireInteraction); + WriteIPDLParam(aWriter, aActor, silent); + WriteIPDLParam(aWriter, aActor, vibrate); + } + + static bool Read(IPC::MessageReader* aReader, IProtocol* aActor, + RefPtr<nsIAlertNotification>* aResult) { + bool isNull; + NS_ENSURE_TRUE(ReadIPDLParam(aReader, aActor, &isNull), false); + if (isNull) { + *aResult = nullptr; + return true; + } + + nsString name, imageURL, title, text, cookie, dir, lang, data; + bool textClickable, inPrivateBrowsing, requireInteraction, silent; + nsCOMPtr<nsIPrincipal> principal; + nsTArray<uint32_t> vibrate; + + if (!ReadIPDLParam(aReader, aActor, &name) || + !ReadIPDLParam(aReader, aActor, &imageURL) || + !ReadIPDLParam(aReader, aActor, &title) || + !ReadIPDLParam(aReader, aActor, &text) || + !ReadIPDLParam(aReader, aActor, &textClickable) || + !ReadIPDLParam(aReader, aActor, &cookie) || + !ReadIPDLParam(aReader, aActor, &dir) || + !ReadIPDLParam(aReader, aActor, &lang) || + !ReadIPDLParam(aReader, aActor, &data) || + !ReadIPDLParam(aReader, aActor, &principal) || + !ReadIPDLParam(aReader, aActor, &inPrivateBrowsing) || + !ReadIPDLParam(aReader, aActor, &requireInteraction) || + !ReadIPDLParam(aReader, aActor, &silent) || + !ReadIPDLParam(aReader, aActor, &vibrate)) { + return false; + } + + nsCOMPtr<nsIAlertNotification> alert = + do_CreateInstance(ALERT_NOTIFICATION_CONTRACTID); + if (NS_WARN_IF(!alert)) { + *aResult = nullptr; + return true; + } + nsresult rv = alert->Init( + name, imageURL, title, text, textClickable, cookie, dir, lang, data, + principal, inPrivateBrowsing, requireInteraction, silent, vibrate); + if (NS_WARN_IF(NS_FAILED(rv))) { + *aResult = nullptr; + return true; + } + *aResult = ToRefPtr(std::move(alert)); + return true; + } +}; + +} // namespace ipc +} // namespace mozilla + +#endif /* mozilla_AlertNotificationIPCSerializer_h__ */ diff --git a/toolkit/components/alerts/alert.css b/toolkit/components/alerts/alert.css new file mode 100644 index 0000000000..273646f399 --- /dev/null +++ b/toolkit/components/alerts/alert.css @@ -0,0 +1,37 @@ +/* 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/. */ + +#alertBox[animate] { + animation-duration: 20s; + animation-fill-mode: both; + animation-name: alert-animation; +} + +#alertBox[animate]:not([clicked], [closing]):hover { + animation-play-state: paused; +} + +#alertBox:not([hasOrigin]) > box > #alertTextBox > #alertFooter, +#alertBox:not([hasIcon]) > box > #alertIcon, +#alertImage:not([src]) { + display: none; +} + +#alertTitleBox { + justify-content: center; + align-items: center; +} + +.alertText { + white-space: pre-wrap; +} + +@keyframes alert-animation { + from { + visibility: visible; + } + to { + visibility: hidden; + } +} diff --git a/toolkit/components/alerts/alert.js b/toolkit/components/alerts/alert.js new file mode 100644 index 0000000000..8a097f967b --- /dev/null +++ b/toolkit/components/alerts/alert.js @@ -0,0 +1,394 @@ +/* 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/. */ + +const { AppConstants } = ChromeUtils.importESModule( + "resource://gre/modules/AppConstants.sys.mjs" +); + +// Copied from nsILookAndFeel.h, see comments on eMetric_AlertNotificationOrigin +const NS_ALERT_HORIZONTAL = 1; +const NS_ALERT_LEFT = 2; +const NS_ALERT_TOP = 4; + +const WINDOW_MARGIN = AppConstants.platform == "win" ? 0 : 10; +const BODY_TEXT_LIMIT = 200; +const WINDOW_SHADOW_SPREAD = AppConstants.platform == "win" ? 10 : 0; + +var gOrigin = 0; // Default value: alert from bottom right. +var gReplacedWindow = null; +var gAlertListener = null; +var gAlertTextClickable = false; +var gAlertCookie = ""; +var gIsActive = false; +var gIsReplaced = false; +var gRequireInteraction = false; + +function prefillAlertInfo() { + // unwrap all the args.... + // arguments[0] --> the image src url + // arguments[1] --> the alert title + // arguments[2] --> the alert text + // arguments[3] --> is the text clickable? + // arguments[4] --> the alert cookie to be passed back to the listener + // arguments[5] --> the alert origin reported by the look and feel + // arguments[6] --> bidi + // arguments[7] --> lang + // arguments[8] --> requires interaction + // arguments[9] --> replaced alert window (nsIDOMWindow) + // arguments[10] --> an optional callback listener (nsIObserver) + // arguments[11] -> the nsIURI.hostPort of the origin, optional + // arguments[12] -> the alert icon URL, optional + + switch (window.arguments.length) { + default: + case 13: { + if (window.arguments[12]) { + let alertBox = document.getElementById("alertBox"); + alertBox.setAttribute("hasIcon", true); + + let icon = document.getElementById("alertIcon"); + icon.src = window.arguments[12]; + } + } + // fall through + case 12: { + if (window.arguments[11]) { + let alertBox = document.getElementById("alertBox"); + alertBox.setAttribute("hasOrigin", true); + + let hostPort = window.arguments[11]; + const ALERT_BUNDLE = Services.strings.createBundle( + "chrome://alerts/locale/alert.properties" + ); + const BRAND_BUNDLE = Services.strings.createBundle( + "chrome://branding/locale/brand.properties" + ); + const BRAND_NAME = BRAND_BUNDLE.GetStringFromName("brandShortName"); + let label = document.getElementById("alertSourceLabel"); + label.setAttribute( + "value", + ALERT_BUNDLE.formatStringFromName("source.label", [hostPort]) + ); + let doNotDisturbMenuItem = document.getElementById( + "doNotDisturbMenuItem" + ); + doNotDisturbMenuItem.setAttribute( + "label", + ALERT_BUNDLE.formatStringFromName("pauseNotifications.label", [ + BRAND_NAME, + ]) + ); + let disableForOrigin = document.getElementById( + "disableForOriginMenuItem" + ); + disableForOrigin.setAttribute( + "label", + ALERT_BUNDLE.formatStringFromName( + "webActions.disableForOrigin.label", + [hostPort] + ) + ); + let openSettings = document.getElementById("openSettingsMenuItem"); + openSettings.setAttribute( + "label", + ALERT_BUNDLE.GetStringFromName("webActions.settings.label") + ); + } + } + // fall through + case 11: + gAlertListener = window.arguments[10]; + // fall through + case 10: + gReplacedWindow = window.arguments[9]; + // fall through + case 9: + gRequireInteraction = window.arguments[8]; + // fall through + case 8: + if (window.arguments[7]) { + document + .getElementById("alertTitleLabel") + .setAttribute("lang", window.arguments[7]); + document + .getElementById("alertTextLabel") + .setAttribute("lang", window.arguments[7]); + } + // fall through + case 7: + if (window.arguments[6]) { + document.getElementById("alertNotification").style.direction = + window.arguments[6]; + } + // fall through + case 6: + gOrigin = window.arguments[5]; + // fall through + case 5: + gAlertCookie = window.arguments[4]; + // fall through + case 4: + gAlertTextClickable = window.arguments[3]; + if (gAlertTextClickable) { + document + .getElementById("alertNotification") + .setAttribute("clickable", true); + document + .getElementById("alertTextLabel") + .setAttribute("clickable", true); + } + // fall through + case 3: + if (window.arguments[2]) { + document.getElementById("alertBox").setAttribute("hasBodyText", true); + let bodyText = window.arguments[2]; + let bodyTextLabel = document.getElementById("alertTextLabel"); + + if (bodyText.length > BODY_TEXT_LIMIT) { + bodyTextLabel.setAttribute("tooltiptext", bodyText); + + let ellipsis = "\u2026"; + try { + ellipsis = Services.prefs.getComplexValue( + "intl.ellipsis", + Ci.nsIPrefLocalizedString + ).data; + } catch (e) {} + + // Copied from nsContextMenu.js' formatSearchContextItem(). + // If the JS character after our truncation point is a trail surrogate, + // include it in the truncated string to avoid splitting a surrogate pair. + let truncLength = BODY_TEXT_LIMIT; + let truncChar = bodyText[BODY_TEXT_LIMIT].charCodeAt(0); + if (truncChar >= 0xdc00 && truncChar <= 0xdfff) { + truncLength++; + } + + bodyText = bodyText.substring(0, truncLength) + ellipsis; + } + bodyTextLabel.textContent = bodyText; + } + // fall through + case 2: + document + .getElementById("alertTitleLabel") + .setAttribute("value", window.arguments[1]); + // fall through + case 1: + if (window.arguments[0]) { + document.getElementById("alertBox").setAttribute("hasImage", true); + document + .getElementById("alertImage") + .setAttribute("src", window.arguments[0]); + } + // fall through + case 0: + break; + } +} + +function onAlertLoad() { + const ALERT_DURATION_IMMEDIATE = 20000; + let alertTextBox = document.getElementById("alertTextBox"); + let alertImageBox = document.getElementById("alertImageBox"); + alertImageBox.style.minHeight = alertTextBox.scrollHeight + "px"; + + window.sizeToContent(); + + if (gReplacedWindow && !gReplacedWindow.closed) { + moveWindowToReplace(gReplacedWindow); + gReplacedWindow.gIsReplaced = true; + gReplacedWindow.close(); + } else { + moveWindowToEnd(); + } + + window.addEventListener("XULAlertClose", function () { + window.close(); + }); + + // If the require interaction flag is set, prevent auto-closing the notification. + if (!gRequireInteraction) { + if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) { + setTimeout(function () { + window.close(); + }, ALERT_DURATION_IMMEDIATE); + } else { + let alertBox = document.getElementById("alertBox"); + alertBox.addEventListener("animationend", function hideAlert(event) { + if ( + event.animationName == "alert-animation" || + event.animationName == "alert-clicked-animation" || + event.animationName == "alert-closing-animation" + ) { + alertBox.removeEventListener("animationend", hideAlert); + window.close(); + } + }); + alertBox.setAttribute("animate", true); + } + } + + let alertSettings = document.getElementById("alertSettings"); + alertSettings.addEventListener("focus", onAlertSettingsFocus); + alertSettings.addEventListener("click", onAlertSettingsClick); + + gIsActive = true; + + let ev = new CustomEvent("AlertActive", { bubbles: true, cancelable: true }); + document.documentElement.dispatchEvent(ev); + + if (gAlertListener) { + gAlertListener.observe(null, "alertshow", gAlertCookie); + } +} + +function moveWindowToReplace(aReplacedAlert) { + let heightDelta = window.outerHeight - aReplacedAlert.outerHeight; + + // Move windows that come after the replaced alert if the height is different. + if (heightDelta != 0) { + for (let alertWindow of Services.wm.getEnumerator("alert:alert")) { + if (!alertWindow.gIsActive) { + continue; + } + // boolean to determine if the alert window is after the replaced alert. + let alertIsAfter = + gOrigin & NS_ALERT_TOP + ? alertWindow.screenY > aReplacedAlert.screenY + : aReplacedAlert.screenY > alertWindow.screenY; + if (alertIsAfter) { + // The new Y position of the window. + let adjustedY = + gOrigin & NS_ALERT_TOP + ? alertWindow.screenY + heightDelta + : alertWindow.screenY - heightDelta; + alertWindow.moveTo(alertWindow.screenX, adjustedY); + } + } + } + + let adjustedY = + gOrigin & NS_ALERT_TOP + ? aReplacedAlert.screenY + : aReplacedAlert.screenY - heightDelta; + window.moveTo(aReplacedAlert.screenX, adjustedY); +} + +function moveWindowToEnd() { + // Determine position + let x = + gOrigin & NS_ALERT_LEFT + ? screen.availLeft + : screen.availLeft + screen.availWidth - window.outerWidth; + let y = + gOrigin & NS_ALERT_TOP + ? screen.availTop + : screen.availTop + screen.availHeight - window.outerHeight; + + // Position the window at the end of all alerts. + for (let alertWindow of Services.wm.getEnumerator("alert:alert")) { + if (alertWindow != window && alertWindow.gIsActive) { + if (gOrigin & NS_ALERT_TOP) { + y = Math.max( + y, + alertWindow.screenY + alertWindow.outerHeight - WINDOW_SHADOW_SPREAD + ); + } else { + y = Math.min( + y, + alertWindow.screenY - window.outerHeight + WINDOW_SHADOW_SPREAD + ); + } + } + } + + // Offset the alert by WINDOW_MARGIN pixels from the edge of the screen + y += gOrigin & NS_ALERT_TOP ? WINDOW_MARGIN : -WINDOW_MARGIN; + x += gOrigin & NS_ALERT_LEFT ? WINDOW_MARGIN : -WINDOW_MARGIN; + + window.moveTo(x, y); +} + +function onAlertBeforeUnload() { + if (!gIsReplaced) { + // Move other alert windows to fill the gap left by closing alert. + let heightDelta = window.outerHeight + WINDOW_MARGIN - WINDOW_SHADOW_SPREAD; + for (let alertWindow of Services.wm.getEnumerator("alert:alert")) { + if (alertWindow != window && alertWindow.gIsActive) { + if (gOrigin & NS_ALERT_TOP) { + if (alertWindow.screenY > window.screenY) { + alertWindow.moveTo( + alertWindow.screenX, + alertWindow.screenY - heightDelta + ); + } + } else if (window.screenY > alertWindow.screenY) { + alertWindow.moveTo( + alertWindow.screenX, + alertWindow.screenY + heightDelta + ); + } + } + } + } + + if (gAlertListener) { + gAlertListener.observe(null, "alertfinished", gAlertCookie); + } +} + +function onAlertClick() { + if (gAlertListener && gAlertTextClickable) { + gAlertListener.observe(null, "alertclickcallback", gAlertCookie); + } + + let alertBox = document.getElementById("alertBox"); + if (alertBox.getAttribute("animate") == "true") { + // Closed when the animation ends. + alertBox.setAttribute("clicked", "true"); + } else { + window.close(); + } +} + +function doNotDisturb() { + const alertService = Cc["@mozilla.org/alerts-service;1"] + .getService(Ci.nsIAlertsService) + .QueryInterface(Ci.nsIAlertsDoNotDisturb); + alertService.manualDoNotDisturb = true; + onAlertClose(); +} + +function disableForOrigin() { + gAlertListener.observe(null, "alertdisablecallback", gAlertCookie); + onAlertClose(); +} + +function onAlertSettingsFocus(event) { + event.target.removeAttribute("focusedViaMouse"); +} + +function onAlertSettingsClick(event) { + // XXXjaws Hack used to remove the focus-ring only + // from mouse interaction, but focus-ring drawing + // should only be enabled when interacting via keyboard. + event.target.setAttribute("focusedViaMouse", true); + event.stopPropagation(); +} + +function openSettings() { + gAlertListener.observe(null, "alertsettingscallback", gAlertCookie); + onAlertClose(); +} + +function onAlertClose() { + let alertBox = document.getElementById("alertBox"); + if (alertBox.getAttribute("animate") == "true") { + // Closed when the animation ends. + alertBox.setAttribute("closing", "true"); + } else { + window.close(); + } +} diff --git a/toolkit/components/alerts/alert.xhtml b/toolkit/components/alerts/alert.xhtml new file mode 100644 index 0000000000..8f7c706452 --- /dev/null +++ b/toolkit/components/alerts/alert.xhtml @@ -0,0 +1,85 @@ +<?xml version="1.0"?> +<!-- 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/. --> + +<!DOCTYPE window> + +<window + id="alertNotification" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + windowtype="alert:alert" + xmlns:xhtml="http://www.w3.org/1999/xhtml" + role="alert" + pack="start" + onload="onAlertLoad();" + onclick="onAlertClick();" + onbeforeunload="onAlertBeforeUnload();" +> + <linkset> + <xhtml:link + rel="stylesheet" + href="chrome://global/content/alerts/alert.css" + /> + <xhtml:link rel="stylesheet" href="chrome://global/skin/alert.css" /> + + <xhtml:link rel="localization" href="toolkit/global/alert.ftl" /> + </linkset> + + <script src="chrome://global/content/alerts/alert.js" /> + + <vbox id="alertBox"> + <box id="alertTitleBox"> + <image id="alertIcon" /> + <label id="alertTitleLabel" class="alertTitle plain" crop="end" /> + <vbox> + <toolbarbutton + class="close-icon" + data-l10n-id="alert-close" + onclick="event.stopPropagation();" + oncommand="onAlertClose();" + /> + </vbox> + </box> + <box> + <hbox + id="alertImageBox" + class="alertImageBox" + align="center" + pack="center" + > + <image id="alertImage" /> + </hbox> + + <vbox id="alertTextBox" class="alertTextBox"> + <label id="alertTextLabel" class="alertText plain" /> + <spacer flex="1" /> + <box id="alertFooter"> + <label id="alertSourceLabel" class="alertSource plain" /> + <button + type="menu" + id="alertSettings" + data-l10n-id="alert-settings-title" + > + <menupopup position="after_end"> + <menuitem id="doNotDisturbMenuItem" oncommand="doNotDisturb();" /> + <menuseparator /> + <menuitem + id="disableForOriginMenuItem" + oncommand="disableForOrigin();" + /> + <menuitem id="openSettingsMenuItem" oncommand="openSettings();" /> + </menupopup> + </button> + </box> + </vbox> + </box> + </vbox> + + <!-- This method is called inline because we want to make sure we establish the width + and height of the alert before we fire the onload handler. --> + <script> + /* eslint-disable no-undef */ + prefillAlertInfo(); + </script> +</window> diff --git a/toolkit/components/alerts/jar.mn b/toolkit/components/alerts/jar.mn new file mode 100644 index 0000000000..533df4c224 --- /dev/null +++ b/toolkit/components/alerts/jar.mn @@ -0,0 +1,8 @@ +# 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/. + +toolkit.jar: + content/global/alerts/alert.css (alert.css) + content/global/alerts/alert.xhtml (alert.xhtml) + content/global/alerts/alert.js (alert.js) diff --git a/toolkit/components/alerts/moz.build b/toolkit/components/alerts/moz.build new file mode 100644 index 0000000000..b07ce72f0d --- /dev/null +++ b/toolkit/components/alerts/moz.build @@ -0,0 +1,45 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +MOCHITEST_MANIFESTS += ["test/mochitest.toml"] + +BROWSER_CHROME_MANIFESTS += ["test/browser.toml"] + +XPIDL_SOURCES += [ + "nsIAlertsService.idl", +] + +if CONFIG["OS_ARCH"] == "WINNT": + XPIDL_SOURCES += [ + "nsIWindowsAlertsService.idl", + ] + +XPIDL_MODULE = "alerts" + +EXPORTS += [ + "nsAlertsUtils.h", +] + +EXPORTS.mozilla += [ + "AlertNotification.h", + "AlertNotificationIPCSerializer.h", +] + +UNIFIED_SOURCES += [ + "AlertNotification.cpp", + "nsAlertsService.cpp", + "nsAlertsUtils.cpp", + "nsXULAlerts.cpp", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" + +JAR_MANIFESTS += ["jar.mn"] + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "Alerts Service") diff --git a/toolkit/components/alerts/nsAlertsService.cpp b/toolkit/components/alerts/nsAlertsService.cpp new file mode 100644 index 0000000000..9a8fb7e7dc --- /dev/null +++ b/toolkit/components/alerts/nsAlertsService.cpp @@ -0,0 +1,342 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "mozilla/dom/ContentChild.h" +#include "mozilla/dom/PermissionMessageUtils.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_alerts.h" +#include "mozilla/Telemetry.h" +#include "nsXULAppAPI.h" + +#include "nsAlertsService.h" + +#include "nsXPCOM.h" +#include "nsPromiseFlatString.h" +#include "nsToolkitCompsCID.h" +#include "nsComponentManagerUtils.h" + +#ifdef MOZ_PLACES +# include "nsIFaviconService.h" +#endif // MOZ_PLACES + +#ifdef XP_WIN +# include <shellapi.h> +#endif + +using namespace mozilla; + +using mozilla::dom::ContentChild; + +namespace { + +#ifdef MOZ_PLACES + +class IconCallback final : public nsIFaviconDataCallback { + public: + NS_DECL_ISUPPORTS + + IconCallback(nsIAlertsService* aBackend, nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) + : mBackend(aBackend), mAlert(aAlert), mAlertListener(aAlertListener) {} + + NS_IMETHOD + OnComplete(nsIURI* aIconURI, uint32_t aIconSize, const uint8_t* aIconData, + const nsACString& aMimeType, uint16_t aWidth) override { + nsresult rv = NS_ERROR_FAILURE; + if (aIconSize > 0) { + nsCOMPtr<nsIAlertsIconData> alertsIconData(do_QueryInterface(mBackend)); + if (alertsIconData) { + rv = alertsIconData->ShowAlertWithIconData(mAlert, mAlertListener, + aIconSize, aIconData); + } + } else if (aIconURI) { + nsCOMPtr<nsIAlertsIconURI> alertsIconURI(do_QueryInterface(mBackend)); + if (alertsIconURI) { + rv = alertsIconURI->ShowAlertWithIconURI(mAlert, mAlertListener, + aIconURI); + } + } + if (NS_FAILED(rv)) { + rv = mBackend->ShowAlert(mAlert, mAlertListener); + } + return rv; + } + + private: + virtual ~IconCallback() = default; + + nsCOMPtr<nsIAlertsService> mBackend; + nsCOMPtr<nsIAlertNotification> mAlert; + nsCOMPtr<nsIObserver> mAlertListener; +}; + +NS_IMPL_ISUPPORTS(IconCallback, nsIFaviconDataCallback) + +#endif // MOZ_PLACES + +nsresult ShowWithIconBackend(nsIAlertsService* aBackend, + nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) { +#ifdef MOZ_PLACES + nsCOMPtr<nsIURI> uri; + nsresult rv = aAlert->GetURI(getter_AddRefs(uri)); + if (NS_FAILED(rv) || !uri) { + return NS_ERROR_FAILURE; + } + + // Ensure the backend supports favicons. + nsCOMPtr<nsIAlertsIconData> alertsIconData(do_QueryInterface(aBackend)); + nsCOMPtr<nsIAlertsIconURI> alertsIconURI; + if (!alertsIconData) { + alertsIconURI = do_QueryInterface(aBackend); + } + if (!alertsIconData && !alertsIconURI) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + nsCOMPtr<nsIFaviconService> favicons( + do_GetService("@mozilla.org/browser/favicon-service;1")); + NS_ENSURE_TRUE(favicons, NS_ERROR_FAILURE); + + nsCOMPtr<nsIFaviconDataCallback> callback = + new IconCallback(aBackend, aAlert, aAlertListener); + if (alertsIconData) { + return favicons->GetFaviconDataForPage(uri, callback, 0); + } + return favicons->GetFaviconURLForPage(uri, callback, 0); +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif // !MOZ_PLACES +} + +nsresult ShowWithBackend(nsIAlertsService* aBackend, + nsIAlertNotification* aAlert, + nsIObserver* aAlertListener, + const nsAString& aPersistentData) { + if (!aPersistentData.IsEmpty()) { + return aBackend->ShowPersistentNotification(aPersistentData, aAlert, + aAlertListener); + } + + if (Preferences::GetBool("alerts.showFavicons")) { + nsresult rv = ShowWithIconBackend(aBackend, aAlert, aAlertListener); + if (NS_SUCCEEDED(rv)) { + return rv; + } + } + + // If favicons are disabled, or the backend doesn't support them, show the + // alert without one. + return aBackend->ShowAlert(aAlert, aAlertListener); +} + +} // anonymous namespace + +NS_IMPL_ISUPPORTS(nsAlertsService, nsIAlertsService, nsIAlertsDoNotDisturb) + +nsAlertsService::nsAlertsService() : mBackend(nullptr) { + mBackend = do_GetService(NS_SYSTEMALERTSERVICE_CONTRACTID); +} + +nsAlertsService::~nsAlertsService() = default; + +bool nsAlertsService::ShouldShowAlert() { + bool result = true; + +#ifdef XP_WIN + if (!xpc::IsInAutomation()) { + QUERY_USER_NOTIFICATION_STATE qstate; + if (SUCCEEDED(SHQueryUserNotificationState(&qstate))) { + if (qstate != QUNS_ACCEPTS_NOTIFICATIONS) { + result = false; + } + } + } +#endif + + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(GetDNDBackend()); + if (alertsDND) { + bool suppressForScreenSharing = false; + nsresult rv = + alertsDND->GetSuppressForScreenSharing(&suppressForScreenSharing); + if (NS_SUCCEEDED(rv)) { + result &= !suppressForScreenSharing; + } + } + + return result; +} + +bool nsAlertsService::ShouldUseSystemBackend() { + if (!mBackend) { + return false; + } + return StaticPrefs::alerts_useSystemBackend(); +} + +NS_IMETHODIMP nsAlertsService::ShowAlertNotification( + const nsAString& aImageUrl, const nsAString& aAlertTitle, + const nsAString& aAlertText, bool aAlertTextClickable, + const nsAString& aAlertCookie, nsIObserver* aAlertListener, + const nsAString& aAlertName, const nsAString& aBidi, const nsAString& aLang, + const nsAString& aData, nsIPrincipal* aPrincipal, bool aInPrivateBrowsing, + bool aRequireInteraction) { + nsCOMPtr<nsIAlertNotification> alert = + do_CreateInstance(ALERT_NOTIFICATION_CONTRACTID); + NS_ENSURE_TRUE(alert, NS_ERROR_FAILURE); + // vibrate is unused + nsTArray<uint32_t> vibrate; + nsresult rv = alert->Init(aAlertName, aImageUrl, aAlertTitle, aAlertText, + aAlertTextClickable, aAlertCookie, aBidi, aLang, + aData, aPrincipal, aInPrivateBrowsing, + aRequireInteraction, false, vibrate); + NS_ENSURE_SUCCESS(rv, rv); + return ShowAlert(alert, aAlertListener); +} + +NS_IMETHODIMP nsAlertsService::ShowAlert(nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) { + return ShowPersistentNotification(u""_ns, aAlert, aAlertListener); +} + +static bool ShouldFallBackToXUL() { +#if defined(XP_WIN) || defined(XP_MACOSX) + // We know we always have system backend on Windows and macOS. Let's not + // permanently fall back to XUL just because of temporary failure. + return false; +#else + // The system may not have the notification library, we should fall back to + // XUL. + return true; +#endif +} + +NS_IMETHODIMP nsAlertsService::ShowPersistentNotification( + const nsAString& aPersistentData, nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) { + NS_ENSURE_ARG(aAlert); + + nsAutoString cookie; + nsresult rv = aAlert->GetCookie(cookie); + NS_ENSURE_SUCCESS(rv, rv); + + if (XRE_IsContentProcess()) { + ContentChild* cpc = ContentChild::GetSingleton(); + + if (aAlertListener) cpc->AddRemoteAlertObserver(cookie, aAlertListener); + + cpc->SendShowAlert(aAlert); + return NS_OK; + } + + // Check if there is an optional service that handles system-level + // notifications + if (ShouldUseSystemBackend()) { + rv = ShowWithBackend(mBackend, aAlert, aAlertListener, aPersistentData); + if (NS_SUCCEEDED(rv) || !ShouldFallBackToXUL()) { + return rv; + } + // If the system backend failed to show the alert, clear the backend and + // retry with XUL notifications. Future alerts will always use XUL. + mBackend = nullptr; + } + + if (!ShouldShowAlert()) { + // Do not display the alert. Instead call alertfinished and get out. + if (aAlertListener) + aAlertListener->Observe(nullptr, "alertfinished", cookie.get()); + return NS_OK; + } + + // Use XUL notifications as a fallback if above methods have failed. + nsCOMPtr<nsIAlertsService> xulBackend(nsXULAlerts::GetInstance()); + NS_ENSURE_TRUE(xulBackend, NS_ERROR_FAILURE); + return ShowWithBackend(xulBackend, aAlert, aAlertListener, aPersistentData); +} + +NS_IMETHODIMP nsAlertsService::CloseAlert(const nsAString& aAlertName, + bool aContextClosed) { + if (XRE_IsContentProcess()) { + ContentChild* cpc = ContentChild::GetSingleton(); + cpc->SendCloseAlert(nsAutoString(aAlertName), aContextClosed); + return NS_OK; + } + + nsresult rv; + // Try the system notification service. + if (ShouldUseSystemBackend()) { + rv = mBackend->CloseAlert(aAlertName, aContextClosed); + if (NS_WARN_IF(NS_FAILED(rv)) && ShouldFallBackToXUL()) { + // If the system backend failed to close the alert, fall back to XUL for + // future alerts. + mBackend = nullptr; + } + } else { + nsCOMPtr<nsIAlertsService> xulBackend(nsXULAlerts::GetInstance()); + NS_ENSURE_TRUE(xulBackend, NS_ERROR_FAILURE); + rv = xulBackend->CloseAlert(aAlertName, aContextClosed); + } + return rv; +} + +// nsIAlertsDoNotDisturb +NS_IMETHODIMP nsAlertsService::GetManualDoNotDisturb(bool* aRetVal) { +#ifdef MOZ_WIDGET_ANDROID + return NS_ERROR_NOT_IMPLEMENTED; +#else + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(GetDNDBackend()); + NS_ENSURE_TRUE(alertsDND, NS_ERROR_NOT_IMPLEMENTED); + return alertsDND->GetManualDoNotDisturb(aRetVal); +#endif +} + +NS_IMETHODIMP nsAlertsService::SetManualDoNotDisturb(bool aDoNotDisturb) { +#ifdef MOZ_WIDGET_ANDROID + return NS_ERROR_NOT_IMPLEMENTED; +#else + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(GetDNDBackend()); + NS_ENSURE_TRUE(alertsDND, NS_ERROR_NOT_IMPLEMENTED); + + nsresult rv = alertsDND->SetManualDoNotDisturb(aDoNotDisturb); + if (NS_SUCCEEDED(rv)) { + Telemetry::Accumulate(Telemetry::ALERTS_SERVICE_DND_ENABLED, 1); + } + return rv; +#endif +} + +NS_IMETHODIMP nsAlertsService::GetSuppressForScreenSharing(bool* aRetVal) { +#ifdef MOZ_WIDGET_ANDROID + return NS_ERROR_NOT_IMPLEMENTED; +#else + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(GetDNDBackend()); + NS_ENSURE_TRUE(alertsDND, NS_ERROR_NOT_IMPLEMENTED); + return alertsDND->GetSuppressForScreenSharing(aRetVal); +#endif +} + +NS_IMETHODIMP nsAlertsService::SetSuppressForScreenSharing(bool aSuppress) { +#ifdef MOZ_WIDGET_ANDROID + return NS_ERROR_NOT_IMPLEMENTED; +#else + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(GetDNDBackend()); + NS_ENSURE_TRUE(alertsDND, NS_ERROR_NOT_IMPLEMENTED); + return alertsDND->SetSuppressForScreenSharing(aSuppress); +#endif +} + +already_AddRefed<nsIAlertsDoNotDisturb> nsAlertsService::GetDNDBackend() { + nsCOMPtr<nsIAlertsService> backend; + // Try the system notification service. + if (ShouldUseSystemBackend()) { + backend = mBackend; + } + if (!backend) { + backend = nsXULAlerts::GetInstance(); + } + + nsCOMPtr<nsIAlertsDoNotDisturb> alertsDND(do_QueryInterface(backend)); + return alertsDND.forget(); +} diff --git a/toolkit/components/alerts/nsAlertsService.h b/toolkit/components/alerts/nsAlertsService.h new file mode 100644 index 0000000000..b228f57383 --- /dev/null +++ b/toolkit/components/alerts/nsAlertsService.h @@ -0,0 +1,30 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsAlertsService_h__ +#define nsAlertsService_h__ + +#include "nsIAlertsService.h" +#include "nsCOMPtr.h" +#include "nsXULAlerts.h" + +class nsAlertsService : public nsIAlertsService, public nsIAlertsDoNotDisturb { + public: + NS_DECL_NSIALERTSDONOTDISTURB + NS_DECL_NSIALERTSSERVICE + NS_DECL_ISUPPORTS + + nsAlertsService(); + + protected: + virtual ~nsAlertsService(); + + bool ShouldShowAlert(); + bool ShouldUseSystemBackend(); + already_AddRefed<nsIAlertsDoNotDisturb> GetDNDBackend(); + nsCOMPtr<nsIAlertsService> mBackend; +}; + +#endif /* nsAlertsService_h__ */ diff --git a/toolkit/components/alerts/nsAlertsUtils.cpp b/toolkit/components/alerts/nsAlertsUtils.cpp new file mode 100644 index 0000000000..b63b368c75 --- /dev/null +++ b/toolkit/components/alerts/nsAlertsUtils.cpp @@ -0,0 +1,30 @@ +/* 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/. */ + +#include "nsAlertsUtils.h" + +#include "nsCOMPtr.h" +#include "nsContentUtils.h" +#include "nsIURI.h" +#include "nsString.h" + +/* static */ +bool nsAlertsUtils::IsActionablePrincipal(nsIPrincipal* aPrincipal) { + return aPrincipal && + !nsContentUtils::IsSystemOrExpandedPrincipal(aPrincipal) && + !aPrincipal->GetIsNullPrincipal(); +} + +/* static */ +void nsAlertsUtils::GetSourceHostPort(nsIPrincipal* aPrincipal, + nsAString& aHostPort) { + if (!IsActionablePrincipal(aPrincipal)) { + return; + } + nsAutoCString hostPort; + if (NS_WARN_IF(NS_FAILED(aPrincipal->GetHostPort(hostPort)))) { + return; + } + CopyUTF8toUTF16(hostPort, aHostPort); +} diff --git a/toolkit/components/alerts/nsAlertsUtils.h b/toolkit/components/alerts/nsAlertsUtils.h new file mode 100644 index 0000000000..c126769de7 --- /dev/null +++ b/toolkit/components/alerts/nsAlertsUtils.h @@ -0,0 +1,29 @@ +/* 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/. */ + +#ifndef nsAlertsUtils_h +#define nsAlertsUtils_h + +#include "nsIPrincipal.h" +#include "nsString.h" + +class nsAlertsUtils final { + private: + nsAlertsUtils() = delete; + + public: + /** + * Indicates whether an alert from |aPrincipal| should include the source + * string and action buttons. Returns false if |aPrincipal| is |nullptr|, or + * a system, expanded, or null principal. + */ + static bool IsActionablePrincipal(nsIPrincipal* aPrincipal); + + /** + * Sets |aHostPort| to the host and port from |aPrincipal|'s URI, or an + * empty string if |aPrincipal| is not actionable. + */ + static void GetSourceHostPort(nsIPrincipal* aPrincipal, nsAString& aHostPort); +}; +#endif /* nsAlertsUtils_h */ diff --git a/toolkit/components/alerts/nsIAlertsService.idl b/toolkit/components/alerts/nsIAlertsService.idl new file mode 100644 index 0000000000..2e75205ef5 --- /dev/null +++ b/toolkit/components/alerts/nsIAlertsService.idl @@ -0,0 +1,351 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "nsISupports.idl" +#include "nsIObserver.idl" + +interface imgIRequest; +interface nsICancelable; +interface nsIPrincipal; +interface nsIURI; + +%{C++ +#define ALERT_NOTIFICATION_CONTRACTID "@mozilla.org/alert-notification;1" +%} + +[scriptable, uuid(a71a637d-de1d-47c6-a8d2-c60b2596f471)] +interface nsIAlertNotificationImageListener : nsISupports +{ + /** + * Called when the image finishes loading. + * + * @param aUserData An opaque parameter passed to |loadImage|. + * @param aRequest The image request. + */ + void onImageReady(in nsISupports aUserData, in imgIRequest aRequest); + + /** + * Called if the alert doesn't have an image, or if the image request times + * out or fails. + * + * @param aUserData An opaque parameter passed to |loadImage|. + */ + void onImageMissing(in nsISupports aUserData); +}; + +[scriptable, uuid(a054c2c9-2787-4686-859c-45609d790056)] +interface nsIAlertAction : nsISupports +{ + /** + * Returns a string identifying a user action to be displayed on the alert. + * + * This string is an opaque identifier that identifies an action in potential + * callbacks; it is not displayed to the user. + */ + readonly attribute AString action; + + /** + * Returns a string containing action text to be shown to the user. + */ + readonly attribute AString title; + + /** + * Returns a string containing the URL of an icon to display with the action. + */ + readonly attribute AString iconURL; + + /** + * On Windows, chrome-privileged notifications -- i.e., those with a + * non-actionable principal -- can have actions that are activated by Windows + * and not processed by Firefox. When `windowsSystemActivationType` is true, + * we request Windows to process `action`. At the time of writing, Windows + * recognizes the following actions: + * + * - `action="dismiss"` dismisses the alert entirely. + * - `action="snooze"` snoozes the alert, generally making it disappear before + * reappearing a Windows-determined amount of time later. + * + * On non-Windows, this field is ignored. + */ + readonly attribute boolean windowsSystemActivationType; + + /** + * On Windows, chrome-privileged notifications -- i.e., those with a + * non-actionable principal -- can have action-specific `opaqueRelaunchData`. + * This data will be provided to the application at relaunch and can trigger + * specific actions. + * + * On non-Windows, this field is ignored. + */ + readonly attribute AString opaqueRelaunchData; +}; + +[scriptable, uuid(cf2e4cb6-4b8f-4eca-aea9-d51a8f9f7a50)] +interface nsIAlertNotification : nsISupports +{ + /** Initializes an alert notification. */ + void init([optional] in AString aName, + [optional] in AString aImageURL, + [optional] in AString aTitle, + [optional] in AString aText, + [optional] in boolean aTextClickable, + [optional] in AString aCookie, + [optional] in AString aDir, + [optional] in AString aLang, + [optional] in AString aData, + [optional] in nsIPrincipal aPrincipal, + [optional] in boolean aInPrivateBrowsing, + [optional] in boolean aRequireInteraction, + [optional] in boolean aSilent, + [optional] in Array<uint32_t> aVibrate); + + /** + * The name of the notification. On Windows and Android, the name is hashed + * and used as a notification ID. Notifications will replace previous + * notifications with the same name. + */ + readonly attribute AString name; + + /** + * A URL identifying the image to put in the alert. The OS X backend limits + * the amount of time it will wait for the image to load to six seconds. After + * that time, the alert will show without an image. + */ + readonly attribute AString imageURL; + + /** The title for the alert. */ + readonly attribute AString title; + + /** The contents of the alert. */ + readonly attribute AString text; + + /** + * Controls the click behavior. If true, the alert listener will be notified + * when the user clicks on the alert. + */ + readonly attribute boolean textClickable; + + /** + * An opaque cookie that will be passed to the alert listener for each + * callback. + */ + readonly attribute AString cookie; + + /** + * Bidi override for the title and contents. Valid values are "auto", "ltr", + * or "rtl". Ignored if the backend doesn't support localization. + */ + readonly attribute AString dir; + + /** + * Language of the title and text. Ignored if the backend doesn't support + * localization. + */ + readonly attribute AString lang; + + /** + * A Base64-encoded structured clone buffer containing data associated with + * this alert. Only used for web notifications. Chrome callers should use a + * cookie instead. + */ + readonly attribute AString data; + + /** + * The principal of the page that created the alert. Used for IPC security + * checks, and to determine whether the alert is actionable. + */ + readonly attribute nsIPrincipal principal; + + /** + * The URI of the page that created the alert. |null| if the alert is not + * actionable. + */ + readonly attribute nsIURI URI; + + /** + * Controls the image loading behavior. If true, the image request will be + * loaded anonymously (without cookies or authorization tokens). + */ + readonly attribute boolean inPrivateBrowsing; + + /** + * Indicates that the notification should remain readily available until + * the user activates or dismisses the notification. + */ + readonly attribute boolean requireInteraction; + + /** + * When set, indicates that no sounds or vibrations should be made. + */ + readonly attribute boolean silent; + + /** + * A vibration pattern to run with the display of the notification. A + * vibration pattern can be an array with as few as one member. The values + * are times in milliseconds where the even indices (0, 2, 4, etc.) indicate + * how long to vibrate and the odd indices indicate how long to pause. For + * example, [300, 100, 400] would vibrate 300ms, pause 100ms, then vibrate + * 400ms. + */ + readonly attribute Array<uint32_t> vibrate; + + /** + * Actions available for users to choose from for interacting with + * the notification. + * + * Implemented only for the system backend on Windows. + */ + attribute Array<nsIAlertAction> actions; + + /** + * Indicates whether this alert should show the source string and action + * buttons. False for system alerts (which can omit the principal), or + * expanded, system, and null principals. + */ + readonly attribute boolean actionable; + + /** + * The host and port of the originating page, or an empty string if the alert + * is not actionable. + */ + readonly attribute AString source; + + /** + * On Windows, chrome-privileged notifications -- i.e., those with a + * non-actionable principal -- can have `opaqueRelaunchData`. This data will + * be provided to the application at relaunch and can trigger specific + * actions. + * + * On non-Windows, this field is ignored. + */ + attribute AString opaqueRelaunchData; + + /** + * Loads the image associated with this alert. + * + * @param aTimeout The number of milliseconds to wait before cancelling the + * image request. If zero, there is no timeout. + * @param aListener An |nsIAlertNotificationImageListener| implementation, + * notified when the image loads. The listener is kept alive + * until the request completes. + * @param aUserData An opaque parameter passed to the listener's methods. + * Not used by the libnotify backend, but the OS X backend + * passes the pending notification. + */ + nsICancelable loadImage(in unsigned long aTimeout, + in nsIAlertNotificationImageListener aListener, + [optional] in nsISupports aUserData); +}; + +[scriptable, uuid(f7a36392-d98b-4141-a7d7-4e46642684e3)] +interface nsIAlertsService : nsISupports +{ + void showPersistentNotification(in AString aPersistentData, + in nsIAlertNotification aAlert, + [optional] in nsIObserver aAlertListener); + + void showAlert(in nsIAlertNotification aAlert, + [optional] in nsIObserver aAlertListener); + /** + * Initializes and shows an |nsIAlertNotification| with the given parameters. + * + * @param aAlertListener Used for callbacks. May be null if the caller + * doesn't care about callbacks. + * @see nsIAlertNotification for descriptions of all other parameters. + * @throws NS_ERROR_NOT_AVAILABLE If the notification cannot be displayed. + * + * The following arguments will be passed to the alertListener's observe() + * method: + * subject - null + * topic - "alertfinished" when the alert goes away + * "alertdisablecallback" when alerts should be disabled for the principal + * "alertsettingscallback" when alert settings should be opened + * "alertclickcallback" when the text is clicked + * "alertshow" when the alert is shown + * data - the value of the cookie parameter passed to showAlertNotification. + * + * @note Depending on current circumstances (if the user's in a fullscreen + * application, for instance), the alert might not be displayed at all. + * In that case, if an alert listener is passed in it will receive the + * "alertfinished" notification immediately. + */ + void showAlertNotification(in AString aImageURL, + in AString aTitle, + in AString aText, + [optional] in boolean aTextClickable, + [optional] in AString aCookie, + [optional] in nsIObserver aAlertListener, + [optional] in AString aName, + [optional] in AString aDir, + [optional] in AString aLang, + [optional] in AString aData, + [optional] in nsIPrincipal aPrincipal, + [optional] in boolean aInPrivateBrowsing, + [optional] in boolean aRequireInteraction); + + /** + * Close alerts created by the service. + * + * @param aName The name of the notification to close. If no name + * is provided then only a notification created with + * no name (if any) will be closed. + * @param aContextClosed The notification was implicitly closed, e.g. by tab + * or window closure. This is necessary to track as some + * platforms intentionally leave the notification visible + * unless explicitly closed, e.g. by notification.close(). + */ + void closeAlert([optional] in AString aName, [optional] in boolean aContextClosed); + +}; + +[scriptable, uuid(c5d63e3a-259d-45a8-b964-8377967cb4d2)] +interface nsIAlertsDoNotDisturb : nsISupports +{ + /** + * Toggles a manual Do Not Disturb mode for the service to reduce the amount + * of disruption that alerts cause the user. + * This may mean only displaying them in a notification tray/center or not + * displaying them at all. If a system backend already supports a similar + * feature controlled by the user, enabling this may not have any impact on + * code to show an alert. e.g. on OS X, the system will take care not + * disrupting a user if we simply create a notification like usual. + */ + attribute bool manualDoNotDisturb; + + /** + * Toggles a mode for the service to suppress all notifications from + * being dispatched when sharing the screen via the getMediaDisplay + * API. + */ + attribute bool suppressForScreenSharing; +}; + +[scriptable, uuid(fc6d7f0a-0cf6-4268-8c71-ab640842b9b1)] +interface nsIAlertsIconData : nsISupports +{ + /** + * Shows an alert with an icon. Web notifications use the favicon of the + * page that created the alert. If the favicon is not in the Places database, + * |aIconSize| will be zero. + */ + void showAlertWithIconData(in nsIAlertNotification aAlert, + in nsIObserver aAlertListener, + in uint32_t aIconSize, + [const, array, size_is(aIconSize)] in uint8_t + aIconData); +}; + +[scriptable, uuid(f3c82915-bf60-41ea-91ce-6c46b22e381a)] +interface nsIAlertsIconURI : nsISupports +{ + /** + * Shows an alert with an icon URI. Web notifications use |cached-favicon:| + * URIs to reference favicons from Places. If the page doesn't have a + * favicon, |aIconURI| will be |null|. + */ + void showAlertWithIconURI(in nsIAlertNotification aAlert, + [optional] in nsIObserver aAlertListener, + [optional] in nsIURI aIconURI); +}; diff --git a/toolkit/components/alerts/nsIWindowsAlertsService.idl b/toolkit/components/alerts/nsIWindowsAlertsService.idl new file mode 100644 index 0000000000..7e7a122eeb --- /dev/null +++ b/toolkit/components/alerts/nsIWindowsAlertsService.idl @@ -0,0 +1,76 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "nsIAlertsService.idl" + +[scriptable, uuid(a46c385b-a45c-4b48-ab7c-aaed1252bb83)] +interface nsIWindowsAlertNotification : nsIAlertNotification +{ + /** + * Boolean to signal that notification button actions will be handled, and the + * resulting action should be communicated back on clicks through the + * `aData` field. + */ + attribute boolean handleActions; + + /** + * Image placements corresponding to placements in Windows Toast + * Notification XML. + */ + cenum ImagePlacement : 8 { + eInline, + eHero, + eIcon, + }; + + /** + * Enum to specify image placement we want in the notification. n.b. in the + * future we could extend this to instead allow multiple images in differing + * placements in the same notification. + */ + attribute nsIWindowsAlertNotification_ImagePlacement imagePlacement; +}; + +[scriptable, uuid(e01c8066-fb4b-4304-b9c9-ab6ed4a8322c)] +interface nsIWindowsAlertsService : nsIAlertsService +{ + /** + * If callbacks for the given Windows-specific tag string will be handled by + * this Firefox process, set the associated event. + * + * @param {AString} aWindowsTag the tag + * @return {Promise} + * @resolves {Object} + * Resolves with an Object, may contain the following optional + * properties if notification exists but wasn't registered with + * the WindowsAlertsService: + * + * `notificationData` {string} relaunch data, generally opaque to + * the Windows notification server DLL, for this relaunch. + * + * @rejects `nsresult` when there was an error retrieving the notification. + */ + [implicit_jscontext] + Promise handleWindowsTag(in AString aWindowsTag); + + /** + * Get the Windows-specific XML generated for the given alert. + * + * @note This method is intended for testing purposes. + * + * @param {nsIAlertNotification} aAlert the alert + * @param {AString} an optional Windows tag; default is generated + * @return {string} generated XML + */ + AString getXmlStringForWindowsAlert(in nsIAlertNotification aAlert, + [optional] in AString aWindowsTag); + + /** + * Removes all action center and snoozed notifications associated with this + * install. Note that this removes all notifications regardless of which profile + * they originated from. + */ + void removeAllNotificationsForInstall(); +}; diff --git a/toolkit/components/alerts/nsXULAlerts.cpp b/toolkit/components/alerts/nsXULAlerts.cpp new file mode 100644 index 0000000000..0a8c9ea752 --- /dev/null +++ b/toolkit/components/alerts/nsXULAlerts.cpp @@ -0,0 +1,403 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "nsXULAlerts.h" + +#include "nsArray.h" +#include "nsComponentManagerUtils.h" +#include "nsCOMPtr.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/EventForwards.h" +#include "mozilla/LookAndFeel.h" +#include "mozilla/dom/Notification.h" +#include "nsISupportsPrimitives.h" +#include "nsPIDOMWindow.h" +#include "nsIWindowWatcher.h" + +using namespace mozilla; + +namespace { +StaticRefPtr<nsXULAlerts> gXULAlerts; +} // anonymous namespace + +NS_IMPL_CYCLE_COLLECTION(nsXULAlertObserver, mAlertWindow) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXULAlertObserver) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(nsXULAlertObserver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(nsXULAlertObserver) + +NS_IMETHODIMP +nsXULAlertObserver::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp("alertfinished", aTopic)) { + mozIDOMWindowProxy* currentAlert = + mXULAlerts->mNamedWindows.GetWeak(mAlertName); + // The window in mNamedWindows might be a replacement, thus it should only + // be removed if it is the same window that is associated with this + // listener. + if (currentAlert == mAlertWindow) { + mXULAlerts->mNamedWindows.Remove(mAlertName); + + if (mIsPersistent) { + mXULAlerts->PersistentAlertFinished(); + } + } + } + + nsresult rv = NS_OK; + if (mObserver) { + rv = mObserver->Observe(aSubject, aTopic, aData); + } + return rv; +} + +// We don't cycle collect nsXULAlerts since gXULAlerts will keep the instance +// alive till shutdown anyway. +NS_IMPL_ISUPPORTS(nsXULAlerts, nsIAlertsService, nsIAlertsDoNotDisturb, + nsIAlertsIconURI) + +/* static */ +already_AddRefed<nsXULAlerts> nsXULAlerts::GetInstance() { + // Gecko on Android does not fully support XUL windows. +#ifndef MOZ_WIDGET_ANDROID + if (!gXULAlerts) { + gXULAlerts = new nsXULAlerts(); + ClearOnShutdown(&gXULAlerts); + } +#endif // MOZ_WIDGET_ANDROID + RefPtr<nsXULAlerts> instance = gXULAlerts.get(); + return instance.forget(); +} + +void nsXULAlerts::PersistentAlertFinished() { + MOZ_ASSERT(mPersistentAlertCount); + mPersistentAlertCount--; + + // Show next pending persistent alert if any. + if (!mPendingPersistentAlerts.IsEmpty()) { + ShowAlertWithIconURI(mPendingPersistentAlerts[0].mAlert, + mPendingPersistentAlerts[0].mListener, nullptr); + mPendingPersistentAlerts.RemoveElementAt(0); + } +} + +NS_IMETHODIMP +nsXULAlerts::ShowAlertNotification( + const nsAString& aImageUrl, const nsAString& aAlertTitle, + const nsAString& aAlertText, bool aAlertTextClickable, + const nsAString& aAlertCookie, nsIObserver* aAlertListener, + const nsAString& aAlertName, const nsAString& aBidi, const nsAString& aLang, + const nsAString& aData, nsIPrincipal* aPrincipal, bool aInPrivateBrowsing, + bool aRequireInteraction) { + nsCOMPtr<nsIAlertNotification> alert = + do_CreateInstance(ALERT_NOTIFICATION_CONTRACTID); + NS_ENSURE_TRUE(alert, NS_ERROR_FAILURE); + // vibrate is unused for now + nsTArray<uint32_t> vibrate; + nsresult rv = alert->Init(aAlertName, aImageUrl, aAlertTitle, aAlertText, + aAlertTextClickable, aAlertCookie, aBidi, aLang, + aData, aPrincipal, aInPrivateBrowsing, + aRequireInteraction, false, vibrate); + NS_ENSURE_SUCCESS(rv, rv); + return ShowAlert(alert, aAlertListener); +} + +NS_IMETHODIMP +nsXULAlerts::ShowPersistentNotification(const nsAString& aPersistentData, + nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) { + return ShowAlert(aAlert, aAlertListener); +} + +NS_IMETHODIMP +nsXULAlerts::ShowAlert(nsIAlertNotification* aAlert, + nsIObserver* aAlertListener) { + nsAutoString name; + nsresult rv = aAlert->GetName(name); + NS_ENSURE_SUCCESS(rv, rv); + + // If there is a pending alert with the same name in the list of + // pending alerts, replace it. + if (!mPendingPersistentAlerts.IsEmpty()) { + for (uint32_t i = 0; i < mPendingPersistentAlerts.Length(); i++) { + nsAutoString pendingAlertName; + nsCOMPtr<nsIAlertNotification> pendingAlert = + mPendingPersistentAlerts[i].mAlert; + rv = pendingAlert->GetName(pendingAlertName); + NS_ENSURE_SUCCESS(rv, rv); + + if (pendingAlertName.Equals(name)) { + nsAutoString cookie; + rv = pendingAlert->GetCookie(cookie); + NS_ENSURE_SUCCESS(rv, rv); + + if (mPendingPersistentAlerts[i].mListener) { + rv = mPendingPersistentAlerts[i].mListener->Observe( + nullptr, "alertfinished", cookie.get()); + NS_ENSURE_SUCCESS(rv, rv); + } + + mPendingPersistentAlerts[i].Init(aAlert, aAlertListener); + return NS_OK; + } + } + } + + bool requireInteraction; + rv = aAlert->GetRequireInteraction(&requireInteraction); + NS_ENSURE_SUCCESS(rv, rv); + + if (requireInteraction && !mNamedWindows.Contains(name) && + static_cast<int32_t>(mPersistentAlertCount) >= + Preferences::GetInt("dom.webnotifications.requireinteraction.count", + 0)) { + PendingAlert* pa = mPendingPersistentAlerts.AppendElement(); + pa->Init(aAlert, aAlertListener); + return NS_OK; + } + return ShowAlertWithIconURI(aAlert, aAlertListener, nullptr); +} + +NS_IMETHODIMP +nsXULAlerts::ShowAlertWithIconURI(nsIAlertNotification* aAlert, + nsIObserver* aAlertListener, + nsIURI* aIconURI) { + bool inPrivateBrowsing; + nsresult rv = aAlert->GetInPrivateBrowsing(&inPrivateBrowsing); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString cookie; + rv = aAlert->GetCookie(cookie); + NS_ENSURE_SUCCESS(rv, rv); + + if (mDoNotDisturb) { + if (aAlertListener) { + aAlertListener->Observe(nullptr, "alertfinished", cookie.get()); + } + return NS_OK; + } + + nsAutoString name; + rv = aAlert->GetName(name); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString imageUrl; + rv = aAlert->GetImageURL(imageUrl); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString title; + rv = aAlert->GetTitle(title); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString text; + rv = aAlert->GetText(text); + NS_ENSURE_SUCCESS(rv, rv); + + bool textClickable; + rv = aAlert->GetTextClickable(&textClickable); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString bidi; + rv = aAlert->GetDir(bidi); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString lang; + rv = aAlert->GetLang(lang); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString source; + rv = aAlert->GetSource(source); + NS_ENSURE_SUCCESS(rv, rv); + + bool requireInteraction; + rv = aAlert->GetRequireInteraction(&requireInteraction); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); + + nsCOMPtr<nsIMutableArray> argsArray = nsArray::Create(); + + // create scriptable versions of our strings that we can store in our + // nsIMutableArray.... + nsCOMPtr<nsISupportsString> scriptableImageUrl( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableImageUrl, NS_ERROR_FAILURE); + + scriptableImageUrl->SetData(imageUrl); + rv = argsArray->AppendElement(scriptableImageUrl); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsString> scriptableAlertTitle( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableAlertTitle, NS_ERROR_FAILURE); + + scriptableAlertTitle->SetData(title); + rv = argsArray->AppendElement(scriptableAlertTitle); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsString> scriptableAlertText( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableAlertText, NS_ERROR_FAILURE); + + scriptableAlertText->SetData(text); + rv = argsArray->AppendElement(scriptableAlertText); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsPRBool> scriptableIsClickable( + do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID)); + NS_ENSURE_TRUE(scriptableIsClickable, NS_ERROR_FAILURE); + + scriptableIsClickable->SetData(textClickable); + rv = argsArray->AppendElement(scriptableIsClickable); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsString> scriptableAlertCookie( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableAlertCookie, NS_ERROR_FAILURE); + + scriptableAlertCookie->SetData(cookie); + rv = argsArray->AppendElement(scriptableAlertCookie); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsPRInt32> scriptableOrigin( + do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID)); + NS_ENSURE_TRUE(scriptableOrigin, NS_ERROR_FAILURE); + + int32_t origin = + LookAndFeel::GetInt(LookAndFeel::IntID::AlertNotificationOrigin); + scriptableOrigin->SetData(origin); + + rv = argsArray->AppendElement(scriptableOrigin); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsString> scriptableBidi( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableBidi, NS_ERROR_FAILURE); + + scriptableBidi->SetData(bidi); + rv = argsArray->AppendElement(scriptableBidi); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsString> scriptableLang( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableLang, NS_ERROR_FAILURE); + + scriptableLang->SetData(lang); + rv = argsArray->AppendElement(scriptableLang); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsPRBool> scriptableRequireInteraction( + do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID)); + NS_ENSURE_TRUE(scriptableRequireInteraction, NS_ERROR_FAILURE); + + scriptableRequireInteraction->SetData(requireInteraction); + rv = argsArray->AppendElement(scriptableRequireInteraction); + NS_ENSURE_SUCCESS(rv, rv); + + // Alerts with the same name should replace the old alert in the same + // position. Provide the new alert window with a pointer to the replaced + // window so that it may take the same position. + nsCOMPtr<nsISupportsInterfacePointer> replacedWindow = + do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv); + NS_ENSURE_TRUE(replacedWindow, NS_ERROR_FAILURE); + mozIDOMWindowProxy* previousAlert = mNamedWindows.GetWeak(name); + replacedWindow->SetData(previousAlert); + replacedWindow->SetDataIID(&NS_GET_IID(mozIDOMWindowProxy)); + rv = argsArray->AppendElement(replacedWindow); + NS_ENSURE_SUCCESS(rv, rv); + + if (requireInteraction) { + mPersistentAlertCount++; + } + + // Add an observer (that wraps aAlertListener) to remove the window from + // mNamedWindows when it is closed. + nsCOMPtr<nsISupportsInterfacePointer> ifptr = + do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + RefPtr<nsXULAlertObserver> alertObserver = + new nsXULAlertObserver(this, name, aAlertListener, requireInteraction); + nsCOMPtr<nsISupports> iSupports(do_QueryInterface(alertObserver)); + ifptr->SetData(iSupports); + ifptr->SetDataIID(&NS_GET_IID(nsIObserver)); + rv = argsArray->AppendElement(ifptr); + NS_ENSURE_SUCCESS(rv, rv); + + // The source contains the host and port of the site that sent the + // notification. It is empty for system alerts. + nsCOMPtr<nsISupportsString> scriptableAlertSource( + do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableAlertSource, NS_ERROR_FAILURE); + scriptableAlertSource->SetData(source); + rv = argsArray->AppendElement(scriptableAlertSource); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISupportsCString> scriptableIconURL( + do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID)); + NS_ENSURE_TRUE(scriptableIconURL, NS_ERROR_FAILURE); + if (aIconURI) { + nsAutoCString iconURL; + rv = aIconURI->GetSpec(iconURL); + NS_ENSURE_SUCCESS(rv, rv); + scriptableIconURL->SetData(iconURL); + } + rv = argsArray->AppendElement(scriptableIconURL); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<mozIDOMWindowProxy> newWindow; + nsAutoCString features("chrome,dialog=yes,alert=yes,titlebar=no"); + if (inPrivateBrowsing) { + features.AppendLiteral(",private"); + } + rv = wwatch->OpenWindow( + nullptr, "chrome://global/content/alerts/alert.xhtml"_ns, "_blank"_ns, + features, argsArray, getter_AddRefs(newWindow)); + NS_ENSURE_SUCCESS(rv, rv); + + mNamedWindows.InsertOrUpdate(name, newWindow); + alertObserver->SetAlertWindow(newWindow); + + return NS_OK; +} + +NS_IMETHODIMP +nsXULAlerts::SetManualDoNotDisturb(bool aDoNotDisturb) { + mDoNotDisturb = aDoNotDisturb; + return NS_OK; +} + +NS_IMETHODIMP +nsXULAlerts::GetManualDoNotDisturb(bool* aRetVal) { + *aRetVal = mDoNotDisturb; + return NS_OK; +} + +NS_IMETHODIMP +nsXULAlerts::GetSuppressForScreenSharing(bool* aRetVal) { + NS_ENSURE_ARG(aRetVal); + *aRetVal = mSuppressForScreenSharing; + return NS_OK; +} + +NS_IMETHODIMP +nsXULAlerts::SetSuppressForScreenSharing(bool aSuppress) { + mSuppressForScreenSharing = aSuppress; + return NS_OK; +} + +NS_IMETHODIMP +nsXULAlerts::CloseAlert(const nsAString& aAlertName, bool aContextClosed) { + mozIDOMWindowProxy* alert = mNamedWindows.GetWeak(aAlertName); + if (nsCOMPtr<nsPIDOMWindowOuter> domWindow = + nsPIDOMWindowOuter::From(alert)) { + domWindow->DispatchCustomEvent(u"XULAlertClose"_ns, + ChromeOnlyDispatch::eYes); + } + return NS_OK; +} diff --git a/toolkit/components/alerts/nsXULAlerts.h b/toolkit/components/alerts/nsXULAlerts.h new file mode 100644 index 0000000000..62470ea7de --- /dev/null +++ b/toolkit/components/alerts/nsXULAlerts.h @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsXULAlerts_h__ +#define nsXULAlerts_h__ + +#include "nsCycleCollectionParticipant.h" +#include "nsHashKeys.h" +#include "nsInterfaceHashtable.h" + +#include "mozIDOMWindow.h" +#include "nsIAlertsService.h" +#include "nsIObserver.h" + +struct PendingAlert { + void Init(nsIAlertNotification* aAlert, nsIObserver* aListener) { + mAlert = aAlert; + mListener = aListener; + } + nsCOMPtr<nsIAlertNotification> mAlert; + nsCOMPtr<nsIObserver> mListener; +}; + +class nsXULAlerts : public nsIAlertsService, + public nsIAlertsDoNotDisturb, + public nsIAlertsIconURI { + friend class nsXULAlertObserver; + + public: + NS_DECL_NSIALERTSICONURI + NS_DECL_NSIALERTSDONOTDISTURB + NS_DECL_NSIALERTSSERVICE + NS_DECL_ISUPPORTS + + nsXULAlerts() = default; + + static already_AddRefed<nsXULAlerts> GetInstance(); + + protected: + virtual ~nsXULAlerts() = default; + void PersistentAlertFinished(); + + nsInterfaceHashtable<nsStringHashKey, mozIDOMWindowProxy> mNamedWindows; + uint32_t mPersistentAlertCount = 0; + nsTArray<PendingAlert> mPendingPersistentAlerts; + bool mDoNotDisturb = false; + + private: + bool mSuppressForScreenSharing = false; +}; + +/** + * This class wraps observers for alerts and watches + * for the "alertfinished" event in order to release + * the reference on the nsIDOMWindow of the XUL alert. + */ +class nsXULAlertObserver : public nsIObserver { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_CYCLE_COLLECTION_CLASS(nsXULAlertObserver) + + nsXULAlertObserver(nsXULAlerts* aXULAlerts, const nsAString& aAlertName, + nsIObserver* aObserver, bool aIsPersistent) + : mXULAlerts(aXULAlerts), + mAlertName(aAlertName), + mObserver(aObserver), + mIsPersistent(aIsPersistent) {} + + void SetAlertWindow(mozIDOMWindowProxy* aWindow) { mAlertWindow = aWindow; } + + protected: + virtual ~nsXULAlertObserver() = default; + + RefPtr<nsXULAlerts> mXULAlerts; + nsString mAlertName; + nsCOMPtr<mozIDOMWindowProxy> mAlertWindow; + nsCOMPtr<nsIObserver> mObserver; + bool mIsPersistent; +}; + +#endif /* nsXULAlerts_h__ */ diff --git a/toolkit/components/alerts/test/browser.toml b/toolkit/components/alerts/test/browser.toml new file mode 100644 index 0000000000..61724f2c12 --- /dev/null +++ b/toolkit/components/alerts/test/browser.toml @@ -0,0 +1,4 @@ +[DEFAULT] + +["browser_bug1682866.js"] +support-files = ["file_bug1682866.html"] diff --git a/toolkit/components/alerts/test/browser_bug1682866.js b/toolkit/components/alerts/test/browser_bug1682866.js new file mode 100644 index 0000000000..24b8b6f7b8 --- /dev/null +++ b/toolkit/components/alerts/test/browser_bug1682866.js @@ -0,0 +1,56 @@ +const baseURL = getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "http://example.com" +); + +const alertURL = `${baseURL}file_bug1682866.html`; + +add_task(async function testAlertForceClosed() { + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + alertURL, + true /* waitForLoad */ + ); + + // Open a second which is in the same process as tab + let secondTabIsLoaded = BrowserTestUtils.waitForNewTab( + gBrowser, + alertURL, + true, + false + ); + + let isSuspendedAfterAlert = await SpecialPowers.spawn( + tab.linkedBrowser.browsingContext, + [alertURL], + url => { + content.open(url); + var utils = SpecialPowers.getDOMWindowUtils(content); + return utils.isInputTaskManagerSuspended; + } + ); + + await secondTabIsLoaded; + + let secondTab = gBrowser.tabs[2]; + + is( + isSuspendedAfterAlert, + Services.prefs.getBoolPref("dom.input_events.canSuspendInBCG.enabled"), + "InputTaskManager should be suspended because alert is opened" + ); + + let alertClosed = BrowserTestUtils.waitForEvent( + tab.linkedBrowser, + "DOMModalDialogClosed" + ); + + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, "about:newtab"); + + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + await alertClosed; + + gBrowser.removeTab(tab); + gBrowser.removeTab(secondTab); +}); diff --git a/toolkit/components/alerts/test/file_bug1682866.html b/toolkit/components/alerts/test/file_bug1682866.html new file mode 100644 index 0000000000..328edcbac5 --- /dev/null +++ b/toolkit/components/alerts/test/file_bug1682866.html @@ -0,0 +1,9 @@ +<html> + <body> + <script> + window.onload = function() { + alert("This is an alert"); + } + </script> + </body> +</html> diff --git a/toolkit/components/alerts/test/image.gif b/toolkit/components/alerts/test/image.gif Binary files differnew file mode 100644 index 0000000000..053b4d9261 --- /dev/null +++ b/toolkit/components/alerts/test/image.gif diff --git a/toolkit/components/alerts/test/image.png b/toolkit/components/alerts/test/image.png Binary files differnew file mode 100644 index 0000000000..430c3c5e65 --- /dev/null +++ b/toolkit/components/alerts/test/image.png diff --git a/toolkit/components/alerts/test/image_server.sjs b/toolkit/components/alerts/test/image_server.sjs new file mode 100644 index 0000000000..4caa21ce27 --- /dev/null +++ b/toolkit/components/alerts/test/image_server.sjs @@ -0,0 +1,92 @@ +const CC = Components.Constructor; + +let { setTimeout } = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" +); + +const LocalFile = CC("@mozilla.org/file/local;1", "nsIFile", "initWithPath"); + +const FileInputStream = CC( + "@mozilla.org/network/file-input-stream;1", + "nsIFileInputStream", + "init" +); + +const BinaryInputStream = CC( + "@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream" +); + +function handleRequest(request, response) { + let params = parseQueryString(request.queryString); + + response.setStatusLine(request.httpVersion, 200, "OK"); + + // Compare and increment a cookie for this request. This is used to test + // private browsing mode; the cookie should not be set if the image is + // loaded anonymously. + if (params.has("c")) { + let expectedValue = parseInt(params.get("c"), 10); + let actualValue = !request.hasHeader("Cookie") + ? 0 + : parseInt( + request.getHeader("Cookie").replace(/^counter=(\d+)/, "$1"), + 10 + ); + if (actualValue != expectedValue) { + response.setStatusLine(request.httpVersion, 400, "Wrong counter value"); + return; + } + response.setHeader("Set-Cookie", `counter=${expectedValue + 1}`, false); + } + + // Wait to send the image if a timeout is given. + let timeout = parseInt(params.get("t"), 10); + if (timeout > 0) { + response.processAsync(); + setTimeout(() => { + respond(params, request, response); + response.finish(); + }, timeout * 1000); + return; + } + + respond(params, request, response); +} + +function parseQueryString(queryString) { + return queryString.split("&").reduce((params, param) => { + let [key, value] = param.split("=", 2); + params.set(key, value); + return params; + }, new Map()); +} + +function respond(params, request, response) { + if (params.has("s")) { + let statusCode = parseInt(params.get("s"), 10); + response.setStatusLine(request.httpVersion, statusCode, "Custom status"); + return; + } + var filename = params.get("f"); + writeFile(filename, response); +} + +function writeFile(name, response) { + var file = new LocalFile(getState("__LOCATION__")).parent; + file.append(name); + + let mimeType = Cc["@mozilla.org/uriloader/external-helper-app-service;1"] + .getService(Ci.nsIMIMEService) + .getTypeFromFile(file); + + let fileStream = new FileInputStream(file, 1, 0, false); + let binaryStream = new BinaryInputStream(fileStream); + + response.setHeader("Content-Type", mimeType, false); + response.bodyOutputStream.writeFrom(binaryStream, binaryStream.available()); + + binaryStream.close(); + fileStream.close(); +} diff --git a/toolkit/components/alerts/test/mochitest.toml b/toolkit/components/alerts/test/mochitest.toml new file mode 100644 index 0000000000..bb6da55f33 --- /dev/null +++ b/toolkit/components/alerts/test/mochitest.toml @@ -0,0 +1,28 @@ +[DEFAULT] +skip-if = ["os == 'android'"] # We don't use XUL alerts on Android +support-files = [ + "image.gif", + "image.png", + "image_server.sjs", +] + +# Synchronous tests like test_alerts.html must come before +# asynchronous tests like test_alerts_noobserve.html! + +["test_alerts.html"] + +["test_alerts_noobserve.html"] + +["test_alerts_requireinteraction.html"] +skip-if = ["verify && os == 'linux'"] + +["test_image.html"] +skip-if = ["verify"] + +["test_invalid_utf16.html"] +run-if = ["os == 'win'"] # Bug 1836526 + +["test_multiple_alerts.html"] + +["test_principal.html"] +skip-if = ["verify"] # Bug 1810860 diff --git a/toolkit/components/alerts/test/test_alerts.html b/toolkit/components/alerts/test/test_alerts.html new file mode 100644 index 0000000000..9c9371fc70 --- /dev/null +++ b/toolkit/components/alerts/test/test_alerts.html @@ -0,0 +1,88 @@ +<!DOCTYPE HTML> +<!-- Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ --> +<html> +<head> + <title>Test for Alerts Service</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> + +<body> +<p id="display"></p> + +<br>Alerts service, with observer "synchronous" case. +<br> +<br>Did a notification appear anywhere? +<br>If so, the test will finish once the notification disappears. + +<pre id="test"> +<script class="testbody" type="text/javascript"> + +var notifier; +var alertName = "fiorello"; + +var observer = { + alertShow: false, + observe(aSubject, aTopic, aData) { + is(aData, "foobarcookie", "Checking whether the alert cookie was passed correctly"); + if (aTopic == "alertclickcallback") { + todo(false, "Did someone click the notification while running mochitests? (Please don't.)"); + } else if (aTopic == "alertshow") { + ok(!this.alertShow, "Alert should not be shown more than once"); + this.alertShow = true; + + // Notifications are native on OS X 10.8 and later, GNOME Shell with + // libnotify (bug 1236036) and Windows >= 8. These notifications persist + // in the Notification Center, and only fire the `alertfinished` event + // when closed. For platforms where native notifications may be used, we + // need to close explicitly to avoid a hang. This also works for XUL + // notifications when running this test on OS X < 10.8, or a window + // manager like Ubuntu Unity with incomplete libnotify support. + notifier.closeAlert(alertName); + } else { + is(aTopic, "alertfinished", "Checking the topic for a finished notification"); + SimpleTest.finish(); + } + }, +}; + +function runTest() { + const Cc = SpecialPowers.Cc; + const Ci = SpecialPowers.Ci; + + if (!("@mozilla.org/alerts-service;1" in Cc)) { + todo(false, "Alerts service does not exist in this application"); + return; + } + + ok(true, "Alerts service exists in this application"); + + try { + notifier = Cc["@mozilla.org/alerts-service;1"]. + getService(Ci.nsIAlertsService); + ok(true, "Alerts service is available"); + } catch (ex) { + todo(false, + "Alerts service is not available.", ex); + return; + } + + try { + SimpleTest.waitForExplicitFinish(); + notifier.showAlertNotification(null, "Notification test", + "Surprise! I'm here to test notifications!", + false, "foobarcookie", observer, alertName); + ok(true, "showAlertNotification() succeeded. Waiting for notification..."); + } catch (ex) { + todo(false, "showAlertNotification() failed.", ex); + SimpleTest.finish(); + } +} + +runTest(); + +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/alerts/test/test_alerts_noobserve.html b/toolkit/components/alerts/test/test_alerts_noobserve.html new file mode 100644 index 0000000000..b6a7658e17 --- /dev/null +++ b/toolkit/components/alerts/test/test_alerts_noobserve.html @@ -0,0 +1,93 @@ +<!DOCTYPE HTML> +<!-- Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ --> +<html> +<head> + <title>Test for Alerts Service</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> + +<body> +<p id="display"></p> + +<br>Alerts service, without observer "asynchronous" case. +<br> +<br>A notification should soon appear somewhere. +<br>If there has been no crash when the notification (later) disappears, assume all is good. + +<pre id="test"> +<script class="testbody" type="text/javascript"> +const Cc = SpecialPowers.Cc; +const Ci = SpecialPowers.Ci; + +const chromeScript = SpecialPowers.loadChromeScript(_ => { + /* eslint-env mozilla/chrome-script */ + const {setTimeout} = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" + ); + + function anyXULAlertsVisible() { + var windows = Services.wm.getEnumerator("alert:alert"); + return windows.hasMoreElements(); + } + + addMessageListener("anyXULAlertsVisible", anyXULAlertsVisible); + + addMessageListener("waitForAlerts", function waitForAlerts() { + if (anyXULAlertsVisible()) { + setTimeout(waitForAlerts, 1000); + } else { + sendAsyncMessage("waitedForAlerts"); + } + }); +}); + +function waitForAlertsThenFinish() { + chromeScript.addMessageListener("waitedForAlerts", function waitedForAlerts() { + chromeScript.removeMessageListener("waitedForAlerts", waitedForAlerts); + ok(true, "Alert disappeared."); + SimpleTest.finish(); + }); + chromeScript.sendAsyncMessage("waitForAlerts"); +} + +async function runTest() { + var alertsVisible = await chromeScript.sendQuery("anyXULAlertsVisible"); + ok(!alertsVisible, "Alerts should not be present at the start of the test."); + + if (!("@mozilla.org/alerts-service;1" in Cc)) { + todo(false, "Alerts service does not exist in this application"); + } else { + ok(true, "Alerts service exists in this application"); + + var notifier; + try { + notifier = Cc["@mozilla.org/alerts-service;1"]. + getService(Ci.nsIAlertsService); + ok(true, "Alerts service is available"); + } catch (ex) { + todo(false, "Alerts service is not available.", ex); + } + + if (notifier) { + try { + notifier.showAlertNotification(null, "Notification test", + "This notification has no observer"); + ok(true, "showAlertNotification() succeeded"); + } catch (ex) { + todo(false, "showAlertNotification() failed.", ex); + } + } + } +} + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestFlakyTimeout("untriaged"); + +runTest(); +setTimeout(waitForAlertsThenFinish, 1000); +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/alerts/test/test_alerts_requireinteraction.html b/toolkit/components/alerts/test/test_alerts_requireinteraction.html new file mode 100644 index 0000000000..ca8fa1c9e3 --- /dev/null +++ b/toolkit/components/alerts/test/test_alerts_requireinteraction.html @@ -0,0 +1,164 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for alerts with requireInteraction</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> +const Cc = SpecialPowers.Cc; +const Ci = SpecialPowers.Ci; + +const chromeScript = SpecialPowers.loadChromeScript(_ => { + /* eslint-env mozilla/chrome-script */ + const {clearTimeout, setTimeout} = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" + ); + + addMessageListener("waitForXULAlert", function() { + var timer = setTimeout(function() { + Services.ww.unregisterNotification(windowObserver); + sendAsyncMessage("waitForXULAlert", false); + }, 2000); + + var windowObserver = function(win, aTopic, aData) { + if (aTopic != "domwindowopened") { + return; + } + + win.addEventListener("load", function() { + let windowType = win.document.documentElement.getAttribute("windowtype"); + if (windowType == "alert:alert") { + clearTimeout(timer); + Services.ww.unregisterNotification(windowObserver); + + sendAsyncMessage("waitForXULAlert", true); + } + }, {once: true}); + }; + + Services.ww.registerNotification(windowObserver); + }); +}); + +var cookie = 0; +function promiseCreateXULAlert(alertService, listener, name) { + return new Promise(resolve => { + chromeScript.addMessageListener("waitForXULAlert", function waitedForAlert(result) { + chromeScript.removeMessageListener("waitForXULAlert", waitedForAlert); + resolve(result); + }); + + chromeScript.sendAsyncMessage("waitForXULAlert"); + alertService.showAlertNotification(null, "title", "body", + true, cookie++, listener, name, null, null, null, + null, false, true); + }); +} + +add_task(async function test_require_interaction() { + if (!("@mozilla.org/alerts-service;1" in Cc)) { + todo(false, "Alerts service does not exist in this application."); + return; + } + + ok(true, "Alerts service exists in this application."); + + var alertService; + try { + alertService = Cc["@mozilla.org/alerts-service;1"].getService(Ci.nsIAlertsService); + ok(true, "Alerts service is available."); + } catch (ex) { + todo(false, "Alerts service is not available."); + return; + } + + await SpecialPowers.pushPrefEnv({"set": [ + [ "dom.webnotifications.requireinteraction.enabled", true ], + [ "dom.webnotifications.requireinteraction.count", 2 ], + ]}); + + var expectedSequence = [ + "first show", + "second show", + "second finished", + "second replacement show", + "third finished", + "first finished", + "third replacement show", + "second replacement finished", + "third replacement finished", + ]; + + var actualSequence = []; + + function createAlertListener(name, showCallback, finishCallback) { + return (subject, topic, data) => { + if (topic == "alertshow") { + actualSequence.push(name + " show"); + if (showCallback) { + showCallback(); + } + } else if (topic == "alertfinished") { + actualSequence.push(name + " finished"); + if (finishCallback) { + finishCallback(); + } + } + }; + } + + var xulAlertCreated = await promiseCreateXULAlert(alertService, + createAlertListener("first"), "first"); + if (!xulAlertCreated) { + ok(true, "Platform does not use XUL alerts."); + alertService.closeAlert("first"); + return; + } + + xulAlertCreated = await promiseCreateXULAlert(alertService, + createAlertListener("second"), "second"); + ok(xulAlertCreated, "Create XUL alert"); + + // Replace second alert + xulAlertCreated = await promiseCreateXULAlert(alertService, + createAlertListener("second replacement"), "second"); + ok(xulAlertCreated, "Create XUL alert"); + + var testFinishResolve; + var testFinishPromise = new Promise((resolve) => { testFinishResolve = resolve; }); + + xulAlertCreated = await promiseCreateXULAlert(alertService, + createAlertListener("third"), "third"); + ok(!xulAlertCreated, "XUL alert should not be visible"); + + // Replace the not-yet-visible third alert. + xulAlertCreated = await promiseCreateXULAlert(alertService, + createAlertListener("third replacement", + function showCallback() { + alertService.closeAlert("second"); + alertService.closeAlert("third"); + }, + function finishCallback() { + // Check actual sequence of alert events compared to expected sequence. + for (var i = 0; i < actualSequence.length; i++) { + is(actualSequence[i], expectedSequence[i], + "Alert callback at index " + i + " should be in expected order."); + } + + testFinishResolve(); + }), "third"); + + ok(!xulAlertCreated, "XUL alert should not be visible"); + + alertService.closeAlert("first"); + + await testFinishPromise; +}); + +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/alerts/test/test_image.html b/toolkit/components/alerts/test/test_image.html new file mode 100644 index 0000000000..3928529c13 --- /dev/null +++ b/toolkit/components/alerts/test/test_image.html @@ -0,0 +1,117 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Bug 1233086</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> + +<body> +<p id="display"></p> + +<pre id="test"> +<script class="testbody" type="text/javascript"> + +const Cc = SpecialPowers.Cc; +const Ci = SpecialPowers.Ci; +const Services = SpecialPowers.Services; + +const imageServerURL = "http://mochi.test:8888/tests/toolkit/components/alerts/test/image_server.sjs"; + +function makeAlert(...params) { + var alert = Cc["@mozilla.org/alert-notification;1"] + .createInstance(Ci.nsIAlertNotification); + alert.init(...params); + return alert; +} + +function promiseImage(alert, timeout = 0, userData = null) { + return new Promise(resolve => { + var isDone = false; + function done(value) { + ok(!isDone, "Should call the image listener once"); + isDone = true; + resolve(value); + } + alert.loadImage(timeout, SpecialPowers.wrapCallbackObject({ + onImageReady(aUserData, aRequest) { + done([true, aRequest, aUserData]); + }, + onImageMissing(aUserData) { + done([false, aUserData]); + }, + }), SpecialPowers.wrap(userData)); + }); +} + +add_task(async function testContext() { + var inUserData = Cc["@mozilla.org/supports-PRInt64;1"] + .createInstance(Ci.nsISupportsPRInt64); + inUserData.data = 123; + + var alert = makeAlert(null, imageServerURL + "?f=image.png"); + var [ready, , userData] = await promiseImage(alert, 0, inUserData); + ok(ready, "Should load requested image"); + is(userData.QueryInterface(Ci.nsISupportsPRInt64).data, 123, + "Should pass user data for loaded image"); + + alert = makeAlert(null, imageServerURL + "?s=404"); + [ready, userData] = await promiseImage(alert, 0, inUserData); + ok(!ready, "Should not load missing image"); + is(userData.QueryInterface(Ci.nsISupportsPRInt64).data, 123, + "Should pass user data for missing image"); +}); + +add_task(async function testTimeout() { + var alert = makeAlert(null, imageServerURL + "?f=image.png&t=3"); + var [ready] = await promiseImage(alert, 1000); + ok(!ready, "Should cancel request if timeout fires"); + + [ready] = await promiseImage(alert, 45000); + ok(ready, "Should load image if request finishes before timeout"); +}); + +add_task(async function testAnimatedGIF() { + var alert = makeAlert(null, imageServerURL + "?f=image.gif"); + var [ready, request] = await promiseImage(alert); + ok(ready, "Should load first animated GIF frame"); + is(request.mimeType, "image/gif", "Should report correct GIF MIME type"); + is(request.image.width, 256, "GIF width should be 256px"); + is(request.image.height, 256, "GIF height should be 256px"); +}); + +add_task(async function testCancel() { + var alert = makeAlert(null, imageServerURL + "?f=image.gif&t=180"); + await new Promise((resolve, reject) => { + var request = alert.loadImage(0, SpecialPowers.wrapCallbackObject({ + onImageReady() { + reject(new Error("Should not load cancelled request")); + }, + onImageMissing() { + resolve(); + }, + }), null); + request.cancel(SpecialPowers.Cr.NS_BINDING_ABORTED); + }); +}); + +add_task(async function testMixedContent() { + // Loading principal is HTTPS; image URL is HTTP. + var origin = "https://mochi.test:8888"; + var principal = Services.scriptSecurityManager + .createContentPrincipalFromOrigin(origin); + + var alert = makeAlert(null, imageServerURL + "?f=image.png", + null, null, false, null, null, null, + null, principal); + var [ready, request] = await promiseImage(alert); + ok(ready, "Should load cross-protocol image"); + is(request.mimeType, "image/png", "Should report correct MIME type"); + is(request.image.width, 32, "Width should be 32px"); + is(request.image.height, 32, "Height should be 32px"); +}); + +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/alerts/test/test_invalid_utf16.html b/toolkit/components/alerts/test/test_invalid_utf16.html new file mode 100644 index 0000000000..a4f862238c --- /dev/null +++ b/toolkit/components/alerts/test/test_invalid_utf16.html @@ -0,0 +1,160 @@ +<!DOCTYPE HTML> +<html> + +<head> + <meta charset="utf-8"> + <title>Test for stability when providing invalid UTF-16 strings</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" href="/tests/SimpleTest/test.css" /> + <script> + const Cc = SpecialPowers.Cc; + const Ci = SpecialPowers.Ci; + let notifier = Cc["@mozilla.org/alerts-service;1"].getService(Ci.nsIAlertsService);; + let notification = Cc["@mozilla.org/alert-notification;1"] + + function buildObserver(alertName) { + let resolve; + let reject; + let promise = new Promise((res, rej) => {resolve = res; reject = rej}); + + let success = false; + function observe(aSubject, aTopic, aData) { + if (aTopic == "alertshow") { + success = true; + notifier.closeAlert(alertName); + } else if (aTopic == "alertfinished") { + ok(true, "alertfinished"); + if (success) { + resolve(); + } else { + reject(); + } + } + } + + return { promise, observe }; + }; + + function buildAlert(options) { + let alert = notification.createInstance( + Ci.nsIAlertNotification + ); + alert.init( + options.name, + options.imageURL, + options.title, + options.text, + options.textClickable, + options.cookie, + options.dir, + options.lang, + options.data, + options.principal, + options.inPrivateBrowsing, + options.requireInteraction, + options.silent, + options.vibrate || [] + ); + if (options.actions) { + alert.actions = options.actions; + } + return alert; + } + + async function runTest(options) { + let alert = buildAlert(options) + const { promise, observe } = buildObserver(options.name); + notifier.showAlert(alert, observe); + await promise; + } + + let invalidUtf16 = String.fromCharCode(0xdfff); + + add_task(async function test_invalid_utf16_name() { + let name = invalidUtf16; + let alert = buildAlert({name}); + + // Extract the alert name to ensure it was not forced to be valid UTF-16. + ok(name == alert.name, "Notification name was not forced to be valid UTF-16"); + + const { promise, observe } = buildObserver(name); + notifier.showAlert(alert, observe); + await promise; + + ok(true, "Notification shown with invalid UTF-16 name"); + }); + + add_task(async function test_invalid_utf16_title() { + let name = "invalid title"; + let title = invalidUtf16; + await runTest({name, title}); + + ok(true, "Notification shown with invalid UTF-16 title"); + }); + + add_task(async function test_invalid_utf16_body() { + let name = "invalid body"; + let text = invalidUtf16; + await runTest({name, text}); + + ok(true, "Notification shown with invalid UTF-16 body"); + }); + + add_task(async function test_invalid_utf16_image_url() { + let name = "invalid image URL"; + let imageURL = invalidUtf16; + await runTest({name, imageURL}); + + ok(true, "Notification shown with invalid UTF-16 image url"); + }); + + add_task(async function test_invalid_utf16_data() { + let name = "invalid data"; + let data = invalidUtf16; + await runTest({name, data}); + + ok(true, "Notification shown with invalid UTF-16 data"); + }); + + // At time of writing, actions are a Windows only, privileged feature. + add_task(async function test_invalid_utf16_action_body() { + let name = "invalid action body"; + let actions = [ + { action: invalidUtf16 }, + ]; + await runTest({name, actions}); + + ok(true, "Notification shown with invalid UTF-16 action body"); + }); + + // At time of writing, actions are a Windows only, privileged feature. + add_task(async function test_invalid_utf16_action_title() { + let name = "invalid action title"; + let actions = [ + {title:invalidUtf16}, + ]; + await runTest({name, actions}); + + ok(true, "Notification shown with invalid UTF-16 action title"); + }); + + // At time of writing, actions are a Windows only, privileged feature. + add_task(async function test_invalid_utf16_action_image_url() { + let name = "invalid action image URL"; + let actions = [ + { iconURL: invalidUtf16 }, + ]; + await runTest({name, actions}); + + ok(true, "Notification shown with invalid UTF-16 action image URL"); + }); + </script> +</head> + +<body> + <p id="display"></p> + <div id="content" style="display: none"></div> + <pre id="test"></pre> +</body> + +</html> diff --git a/toolkit/components/alerts/test/test_multiple_alerts.html b/toolkit/components/alerts/test/test_multiple_alerts.html new file mode 100644 index 0000000000..95843b2e89 --- /dev/null +++ b/toolkit/components/alerts/test/test_multiple_alerts.html @@ -0,0 +1,99 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for multiple alerts</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<pre id="test"> +<script class="testbody" type="text/javascript"> +const Cc = SpecialPowers.Cc; +const Ci = SpecialPowers.Ci; + +const chromeScript = SpecialPowers.loadChromeScript(_ => { + /* eslint-env mozilla/chrome-script */ + const {clearTimeout, setTimeout} = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" + ); + + const alertService = Cc["@mozilla.org/alerts-service;1"] + .getService(Ci.nsIAlertsService); + + addMessageListener("waitForPosition", function() { + var timer = setTimeout(function() { + Services.ww.unregisterNotification(windowObserver); + sendAsyncMessage("waitedForPosition", null); + }, 2000); + + var windowObserver = function(win, aTopic, aData) { + if (aTopic != "domwindowopened") { + return; + } + + // Alerts are implemented using XUL. + clearTimeout(timer); + + Services.ww.unregisterNotification(windowObserver); + + win.addEventListener("pageshow", function() { + var x = win.screenX; + var y = win.screenY; + + win.addEventListener("pagehide", function() { + sendAsyncMessage("waitedForPosition", { x, y }); + }, {once: true}); + + alertService.closeAlert(); + }, {once: true}); + }; + + Services.ww.registerNotification(windowObserver); + }); +}); + +function promiseAlertPosition(alertService) { + return new Promise(resolve => { + chromeScript.addMessageListener("waitedForPosition", function waitedForPosition(result) { + chromeScript.removeMessageListener("waitedForPosition", waitedForPosition); + resolve(result); + }); + chromeScript.sendAsyncMessage("waitForPosition"); + + alertService.showAlertNotification(null, "title", "body"); + ok(true, "Alert shown."); + }); +} + +add_task(async function test_multiple_alerts() { + if (!("@mozilla.org/alerts-service;1" in Cc)) { + todo(false, "Alerts service does not exist in this application."); + return; + } + + ok(true, "Alerts service exists in this application."); + + var alertService; + try { + alertService = Cc["@mozilla.org/alerts-service;1"].getService(Ci.nsIAlertsService); + ok(true, "Alerts service is available."); + } catch (ex) { + todo(false, "Alerts service is not available."); + return; + } + + var firstAlertPosition = await promiseAlertPosition(alertService); + if (!firstAlertPosition) { + ok(true, "Platform does not use XUL alerts."); + return; + } + + var secondAlertPosition = await promiseAlertPosition(alertService); + is(secondAlertPosition.x, firstAlertPosition.x, "Second alert should be opened in the same position."); + is(secondAlertPosition.y, firstAlertPosition.y, "Second alert should be opened in the same position."); +}); + +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/alerts/test/test_principal.html b/toolkit/components/alerts/test/test_principal.html new file mode 100644 index 0000000000..5464d92977 --- /dev/null +++ b/toolkit/components/alerts/test/test_principal.html @@ -0,0 +1,123 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Bug 1202933</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> + +<body> +<p id="display"></p> + +<pre id="test"> +<script class="testbody" type="text/javascript"> +const Cc = SpecialPowers.Cc; +const Ci = SpecialPowers.Ci; +const Services = SpecialPowers.Services; + +const notifier = Cc["@mozilla.org/alerts-service;1"] + .getService(Ci.nsIAlertsService); + +const chromeScript = SpecialPowers.loadChromeScript(_ => { + /* eslint-env mozilla/chrome-script */ + addMessageListener("anyXULAlertsVisible", function() { + var windows = Services.wm.getEnumerator("alert:alert"); + return windows.hasMoreElements(); + }); + + addMessageListener("getAlertSource", function() { + var alertWindows = Services.wm.getEnumerator("alert:alert"); + if (!alertWindows) { + return null; + } + var alertWindow = alertWindows.getNext(); + return alertWindow.document.getElementById("alertSourceLabel").getAttribute("value"); + }); +}); + +function notify(alertName, principal) { + return new Promise((resolve, reject) => { + var source; + async function observe(subject, topic, data) { + if (topic == "alertclickcallback") { + reject(new Error("Alerts should not be clicked during test")); + } else if (topic == "alertshow") { + source = await chromeScript.sendQuery("getAlertSource"); + notifier.closeAlert(alertName); + } else { + is(topic, "alertfinished", "Should hide alert"); + resolve(source); + } + } + notifier.showAlertNotification(null, "Notification test", + "Surprise! I'm here to test notifications!", + false, alertName, observe, alertName, + null, null, null, principal); + if (SpecialPowers.Services.appinfo.OS == "Darwin") { + notifier.closeAlert(alertName); + } + }); +} + +async function testNoPrincipal() { + var source = await notify("noPrincipal", null); + ok(!source, "Should omit source without principal"); +} + +async function testSystemPrincipal() { + var principal = Services.scriptSecurityManager.getSystemPrincipal(); + var source = await notify("systemPrincipal", principal); + ok(!source, "Should omit source for system principal"); +} + +async function testNullPrincipal() { + var principal = Services.scriptSecurityManager.createNullPrincipal({}); + var source = await notify("nullPrincipal", principal); + ok(!source, "Should omit source for null principal"); +} + +async function testNodePrincipal() { + var principal = SpecialPowers.wrap(document).nodePrincipal; + var source = await notify("nodePrincipal", principal); + + var stringBundle = Services.strings.createBundle( + "chrome://alerts/locale/alert.properties" + ); + var localizedSource = stringBundle.formatStringFromName( + "source.label", [principal.hostPort]); + is(source, localizedSource, "Should include source for node principal"); +} + +function runTest() { + if (!("@mozilla.org/alerts-service;1" in Cc)) { + todo(false, "Alerts service does not exist in this application"); + return; + } + + ok(true, "Alerts service exists in this application"); + + add_setup(async () => { + // This test verifies behavior specific to XUL alerts. + await SpecialPowers.pushPrefEnv({ + set: [["alerts.useSystemBackend", false]], + }); + }); + + // sendSyncMessage returns an array of arrays. See the comments in + // test_alerts_noobserve.html and test_SpecialPowersLoadChromeScript.html. + add_task(async () => { + var alertsVisible = await chromeScript.sendQuery("anyXULAlertsVisible"); + ok(!alertsVisible, "Alerts should not be present at the start of the test."); + }); + + add_task(testNoPrincipal); + add_task(testSystemPrincipal); + add_task(testNullPrincipal); + add_task(testNodePrincipal); +} + +runTest(); +</script> +</pre> +</body> +</html> |
