diff options
Diffstat (limited to 'dom/midi')
76 files changed, 6737 insertions, 0 deletions
diff --git a/dom/midi/AlsaCompatibility.cpp b/dom/midi/AlsaCompatibility.cpp new file mode 100644 index 0000000000..9e219d4999 --- /dev/null +++ b/dom/midi/AlsaCompatibility.cpp @@ -0,0 +1,32 @@ +/* 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/Assertions.h" + +// The code in this file is a workaround for building with ALSA versions prior +// to 1.1. Various functions that the alsa crate (a dependency of the midir +// crate) use are missing from those versions. The functions are not actually +// used so we provide dummy implementations that return an error. This file +// can be safely removed when the Linux sysroot will be updated to Debian 9 +// (or higher) +#include <alsa/asoundlib.h> + +extern "C" { + +#define ALSA_DIVERT(func) \ + int func(void) { \ + MOZ_CRASH(#func "should never be called."); \ + return -1; \ + } + +#if (SND_LIB_MAJOR == 1) && (SND_LIB_MINOR == 0) && (SND_LIB_SUBMINOR < 29) +ALSA_DIVERT(snd_pcm_sw_params_set_tstamp_type) +ALSA_DIVERT(snd_pcm_sw_params_get_tstamp_type) +#endif + +#if (SND_LIB_MAJOR == 1) && (SND_LIB_MINOR < 1) +ALSA_DIVERT(snd_pcm_hw_params_supports_audio_ts_type) +ALSA_DIVERT(snd_pcm_status_set_audio_htstamp_config) +#endif +} diff --git a/dom/midi/MIDIAccess.cpp b/dom/midi/MIDIAccess.cpp new file mode 100644 index 0000000000..2ddb9b4694 --- /dev/null +++ b/dom/midi/MIDIAccess.cpp @@ -0,0 +1,248 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIAccess.h" +#include "mozilla/dom/MIDIAccessManager.h" +#include "mozilla/dom/MIDIPort.h" +#include "mozilla/dom/MIDIAccessBinding.h" +#include "mozilla/dom/MIDIConnectionEvent.h" +#include "mozilla/dom/MIDIOptionsBinding.h" +#include "mozilla/dom/MIDIOutputMapBinding.h" +#include "mozilla/dom/MIDIInputMapBinding.h" +#include "mozilla/dom/MIDIOutputMap.h" +#include "mozilla/dom/MIDIInputMap.h" +#include "mozilla/dom/MIDIOutput.h" +#include "mozilla/dom/MIDIInput.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/PContent.h" +#include "mozilla/dom/Document.h" +#include "nsPIDOMWindow.h" +#include "nsContentPermissionHelper.h" +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, MOZ_COUNT_DTOR +#include "ipc/IPCMessageUtils.h" +#include "MIDILog.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_CLASS(MIDIAccess) +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(MIDIAccess, DOMEventTargetHelper) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MIDIAccess, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInputMap) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOutputMap) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAccessPromise) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MIDIAccess, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mInputMap) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mOutputMap) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mAccessPromise) + tmp->Shutdown(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIAccess) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_ADDREF_INHERITED(MIDIAccess, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(MIDIAccess, DOMEventTargetHelper) + +MIDIAccess::MIDIAccess(nsPIDOMWindowInner* aWindow, bool aSysexEnabled, + Promise* aAccessPromise) + : DOMEventTargetHelper(aWindow), + mInputMap(new MIDIInputMap(aWindow)), + mOutputMap(new MIDIOutputMap(aWindow)), + mSysexEnabled(aSysexEnabled), + mAccessPromise(aAccessPromise), + mHasShutdown(false) { + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aAccessPromise); + KeepAliveIfHasListenersFor(nsGkAtoms::onstatechange); +} + +MIDIAccess::~MIDIAccess() { Shutdown(); } + +void MIDIAccess::Shutdown() { + LOG("MIDIAccess::Shutdown"); + if (mHasShutdown) { + return; + } + mDestructionObservers.Broadcast(void_t()); + if (MIDIAccessManager::IsRunning()) { + MIDIAccessManager::Get()->RemoveObserver(this); + } + mHasShutdown = true; +} + +void MIDIAccess::FireConnectionEvent(MIDIPort* aPort) { + MOZ_ASSERT(aPort); + MIDIConnectionEventInit init; + init.mPort = aPort; + nsAutoString id; + aPort->GetId(id); + ErrorResult rv; + if (aPort->State() == MIDIPortDeviceState::Disconnected) { + if (aPort->Type() == MIDIPortType::Input && mInputMap->Has(id)) { + MIDIInputMap_Binding::MaplikeHelpers::Delete(mInputMap, aPort->StableId(), + rv); + mInputMap->Remove(id); + } else if (aPort->Type() == MIDIPortType::Output && mOutputMap->Has(id)) { + MIDIOutputMap_Binding::MaplikeHelpers::Delete(mOutputMap, + aPort->StableId(), rv); + mOutputMap->Remove(id); + } + // Check to make sure Has()/Delete() calls haven't failed. + if (NS_WARN_IF(rv.Failed())) { + LOG("Inconsistency during FireConnectionEvent"); + return; + } + } else { + // If we receive an event from a port that is not in one of our port maps, + // this means a port that was disconnected has been reconnected, with the + // port owner holding the object during that time, and we should add that + // port object to our maps again. + if (aPort->Type() == MIDIPortType::Input && !mInputMap->Has(id)) { + if (NS_WARN_IF(rv.Failed())) { + LOG("Input port not found"); + return; + } + MIDIInputMap_Binding::MaplikeHelpers::Set( + mInputMap, aPort->StableId(), *(static_cast<MIDIInput*>(aPort)), rv); + if (NS_WARN_IF(rv.Failed())) { + LOG("Map Set failed for input port"); + return; + } + mInputMap->Insert(id, aPort); + } else if (aPort->Type() == MIDIPortType::Output && mOutputMap->Has(id)) { + if (NS_WARN_IF(rv.Failed())) { + LOG("Output port not found"); + return; + } + MIDIOutputMap_Binding::MaplikeHelpers::Set( + mOutputMap, aPort->StableId(), *(static_cast<MIDIOutput*>(aPort)), + rv); + if (NS_WARN_IF(rv.Failed())) { + LOG("Map set failed for output port"); + return; + } + mOutputMap->Insert(id, aPort); + } + } + RefPtr<MIDIConnectionEvent> event = + MIDIConnectionEvent::Constructor(this, u"statechange"_ns, init); + DispatchTrustedEvent(event); +} + +void MIDIAccess::MaybeCreateMIDIPort(const MIDIPortInfo& aInfo, + ErrorResult& aRv) { + nsAutoString id(aInfo.id()); + MIDIPortType type = static_cast<MIDIPortType>(aInfo.type()); + RefPtr<MIDIPort> port; + if (type == MIDIPortType::Input) { + if (mInputMap->Has(id) || NS_WARN_IF(aRv.Failed())) { + // We already have the port in our map. + return; + } + port = MIDIInput::Create(GetOwner(), this, aInfo, mSysexEnabled); + if (NS_WARN_IF(!port)) { + LOG("Couldn't create input port"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + MIDIInputMap_Binding::MaplikeHelpers::Set( + mInputMap, port->StableId(), *(static_cast<MIDIInput*>(port.get())), + aRv); + if (NS_WARN_IF(aRv.Failed())) { + LOG("Coudld't set input port in map"); + return; + } + mInputMap->Insert(id, port); + } else if (type == MIDIPortType::Output) { + if (mOutputMap->Has(id) || NS_WARN_IF(aRv.Failed())) { + // We already have the port in our map. + return; + } + port = MIDIOutput::Create(GetOwner(), this, aInfo, mSysexEnabled); + if (NS_WARN_IF(!port)) { + LOG("Couldn't create output port"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + MIDIOutputMap_Binding::MaplikeHelpers::Set( + mOutputMap, port->StableId(), *(static_cast<MIDIOutput*>(port.get())), + aRv); + if (NS_WARN_IF(aRv.Failed())) { + LOG("Coudld't set output port in map"); + return; + } + mOutputMap->Insert(id, port); + } else { + // If we hit this, then we have some port that is neither input nor output. + // That is bad. + MOZ_CRASH("We shouldn't be here!"); + } + // Set up port to listen for destruction of this access object. + mDestructionObservers.AddObserver(port); + + // If we haven't resolved the promise for handing the MIDIAccess object to + // content, this means we're still populating the list of already connected + // devices. Don't fire events yet. + if (!mAccessPromise) { + FireConnectionEvent(port); + } +} + +// For the MIDIAccess object, only worry about new connections, where we create +// MIDIPort objects. When a port is removed and the MIDIPortRemove event is +// received, that will be handled by the MIDIPort object itself, and it will +// request removal from MIDIAccess's maps. +void MIDIAccess::Notify(const MIDIPortList& aEvent) { + LOG("MIDIAcess::Notify"); + if (!GetOwner()) { + // Do nothing if we've already been disconnected from the document. + return; + } + + for (const auto& port : aEvent.ports()) { + // Something went very wrong. Warn and return. + ErrorResult rv; + MaybeCreateMIDIPort(port, rv); + if (rv.Failed()) { + if (!mAccessPromise) { + return; + } + mAccessPromise->MaybeReject(std::move(rv)); + mAccessPromise = nullptr; + } + } + if (!mAccessPromise) { + return; + } + mAccessPromise->MaybeResolve(this); + mAccessPromise = nullptr; +} + +JSObject* MIDIAccess::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return MIDIAccess_Binding::Wrap(aCx, this, aGivenProto); +} + +void MIDIAccess::RemovePortListener(MIDIAccessDestructionObserver* aObs) { + mDestructionObservers.RemoveObserver(aObs); +} + +void MIDIAccess::DisconnectFromOwner() { + IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onstatechange); + + DOMEventTargetHelper::DisconnectFromOwner(); + MIDIAccessManager::Get()->SendRefresh(); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIAccess.h b/dom/midi/MIDIAccess.h new file mode 100644 index 0000000000..9b3a860f02 --- /dev/null +++ b/dom/midi/MIDIAccess.h @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIAccess_h +#define mozilla_dom_MIDIAccess_h + +#include "mozilla/Attributes.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/Observer.h" +#include "nsCycleCollectionParticipant.h" +#include "nsWrapperCache.h" + +struct JSContext; + +namespace mozilla { +class ErrorResult; + +// Predeclare void_t here, as including IPCMessageUtils brings in windows.h and +// causes binding compilation problems. +struct void_t; + +namespace dom { + +class MIDIAccessManager; +class MIDIInputMap; +struct MIDIOptions; +class MIDIOutputMap; +class MIDIPermissionRequest; +class MIDIPort; +class MIDIPortChangeEvent; +class MIDIPortInfo; +class MIDIPortList; +class Promise; + +using MIDIAccessDestructionObserver = Observer<void_t>; + +/** + * MIDIAccess is the DOM object that is handed to the user upon MIDI permissions + * being successfully granted. It manages access to MIDI ports, and fires events + * for device connection and disconnection. + * + * New MIDIAccess objects are created every time RequestMIDIAccess is called. + * MIDIAccess objects are managed via MIDIAccessManager. + */ +class MIDIAccess final : public DOMEventTargetHelper, + public Observer<MIDIPortList> { + // Use the Permission Request class in MIDIAccessManager for creating + // MIDIAccess objects. + friend class MIDIPermissionRequest; + friend class MIDIAccessManager; + + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MIDIAccess, + DOMEventTargetHelper) + public: + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + // Return map of MIDI Input Ports + MIDIInputMap* Inputs() const { return mInputMap; } + + // Return map of MIDI Output Ports + MIDIOutputMap* Outputs() const { return mOutputMap; } + + // Returns true if sysex permissions were given + bool SysexEnabled() const { return mSysexEnabled; } + + // Observer implementation for receiving port connection updates + void Notify(const MIDIPortList& aEvent) override; + + // All MIDIPort objects observe destruction of the MIDIAccess object that + // created them, as the port object receives disconnection events which then + // must be passed up to the MIDIAccess object. If the Port object dies before + // the MIDIAccess object, it needs to be removed from the observer list. + void RemovePortListener(MIDIAccessDestructionObserver* aObs); + + // Fires DOM event on port connection/disconnection + void FireConnectionEvent(MIDIPort* aPort); + + // Notify all MIDIPorts that were created by this MIDIAccess and are still + // alive, and detach from the MIDIAccessManager. + void Shutdown(); + IMPL_EVENT_HANDLER(statechange); + + void DisconnectFromOwner() override; + + private: + MIDIAccess(nsPIDOMWindowInner* aWindow, bool aSysexEnabled, + Promise* aAccessPromise); + ~MIDIAccess(); + + // On receiving a connection event from MIDIAccessManager, create a + // corresponding MIDIPort object if we don't already have one. + void MaybeCreateMIDIPort(const MIDIPortInfo& aInfo, ErrorResult& aRv); + + // Stores all known MIDIInput Ports + RefPtr<MIDIInputMap> mInputMap; + // Stores all known MIDIOutput Ports + RefPtr<MIDIOutputMap> mOutputMap; + // List of MIDIPort observers that need to be updated on destruction. + ObserverList<void_t> mDestructionObservers; + // True if user gave permissions for sysex usage to this object. + bool mSysexEnabled; + // Promise created by RequestMIDIAccess call, to be resolved after port + // populating is finished. + RefPtr<Promise> mAccessPromise; + // True if shutdown process has started, so we don't try to add more ports. + bool mHasShutdown; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_MIDIAccess_h diff --git a/dom/midi/MIDIAccessManager.cpp b/dom/midi/MIDIAccessManager.cpp new file mode 100644 index 0000000000..c0556f1ffd --- /dev/null +++ b/dom/midi/MIDIAccessManager.cpp @@ -0,0 +1,176 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIAccessManager.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/MIDIAccess.h" +#include "mozilla/dom/MIDIManagerChild.h" +#include "mozilla/dom/MIDIPermissionRequest.h" +#include "mozilla/dom/FeaturePolicyUtils.h" +#include "mozilla/dom/Promise.h" +#include "nsIGlobalObject.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/ipc/Endpoint.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/StaticPrefs_midi.h" + +using namespace mozilla::ipc; + +namespace mozilla::dom { + +namespace { +// Singleton object for MIDIAccessManager +StaticRefPtr<MIDIAccessManager> gMIDIAccessManager; +} // namespace + +MIDIAccessManager::MIDIAccessManager() : mHasPortList(false), mChild(nullptr) {} + +MIDIAccessManager::~MIDIAccessManager() = default; + +// static +MIDIAccessManager* MIDIAccessManager::Get() { + if (!gMIDIAccessManager) { + gMIDIAccessManager = new MIDIAccessManager(); + ClearOnShutdown(&gMIDIAccessManager); + } + return gMIDIAccessManager; +} + +// static +bool MIDIAccessManager::IsRunning() { return !!gMIDIAccessManager; } + +already_AddRefed<Promise> MIDIAccessManager::RequestMIDIAccess( + nsPIDOMWindowInner* aWindow, const MIDIOptions& aOptions, + ErrorResult& aRv) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aWindow); + nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(aWindow); + RefPtr<Promise> p = Promise::Create(go, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + nsCOMPtr<Document> doc = aWindow->GetDoc(); + if (NS_WARN_IF(!doc)) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + +#ifndef MOZ_WEBMIDI_MIDIR_IMPL + if (!StaticPrefs::midi_testing()) { + // If we don't have a MIDI implementation and testing is disabled we can't + // allow accessing WebMIDI. However we don't want to return something + // different from a normal rejection because we don't want websites to use + // the error as a way to fingerprint users, so we throw a security error + // as if the request had been rejected by the user. + aRv.ThrowSecurityError("Access not allowed"); + return nullptr; + } +#endif + + if (!FeaturePolicyUtils::IsFeatureAllowed(doc, u"midi"_ns)) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + nsCOMPtr<nsIRunnable> permRunnable = + new MIDIPermissionRequest(aWindow, p, aOptions); + aRv = NS_DispatchToMainThread(permRunnable); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + return p.forget(); +} + +bool MIDIAccessManager::AddObserver(Observer<MIDIPortList>* aObserver) { + // Add observer before we start the service, otherwise we can end up with + // device lists being received before we have observers to send them to. + mChangeObservers.AddObserver(aObserver); + + if (!mChild) { + StartActor(); + } else { + mChild->SendRefresh(); + } + + return true; +} + +// Sets up the actor to talk to the parent. +// +// We Bootstrap the actor manually rather than using a constructor so that +// we can bind the parent endpoint to a dedicated task queue. +void MIDIAccessManager::StartActor() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!mChild); + + // Grab PBackground. + ::mozilla::ipc::PBackgroundChild* pBackground = + BackgroundChild::GetOrCreateForCurrentThread(); + + // Create the endpoints and bind the one on the child side. + Endpoint<PMIDIManagerParent> parentEndpoint; + Endpoint<PMIDIManagerChild> childEndpoint; + MOZ_ALWAYS_SUCCEEDS( + PMIDIManager::CreateEndpoints(&parentEndpoint, &childEndpoint)); + mChild = new MIDIManagerChild(); + MOZ_ALWAYS_TRUE(childEndpoint.Bind(mChild)); + + // Kick over to the parent to connect things over there. + pBackground->SendCreateMIDIManager(std::move(parentEndpoint)); +} + +void MIDIAccessManager::RemoveObserver(Observer<MIDIPortList>* aObserver) { + mChangeObservers.RemoveObserver(aObserver); + if (mChangeObservers.Length() == 0) { + // If we're out of listeners, go ahead and shut down. Make sure to cleanup + // the IPDL protocol also. + if (mChild) { + mChild->Shutdown(); + mChild = nullptr; + } + gMIDIAccessManager = nullptr; + } +} + +void MIDIAccessManager::SendRefresh() { + if (mChild) { + mChild->SendRefresh(); + } +} + +void MIDIAccessManager::CreateMIDIAccess(nsPIDOMWindowInner* aWindow, + bool aNeedsSysex, Promise* aPromise) { + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aPromise); + RefPtr<MIDIAccess> a(new MIDIAccess(aWindow, aNeedsSysex, aPromise)); + if (NS_WARN_IF(!AddObserver(a))) { + aPromise->MaybeReject(NS_ERROR_FAILURE); + return; + } + if (!mHasPortList) { + // Hold the access object until we get a connected device list. + mAccessHolder.AppendElement(a); + } else { + // If we already have a port list, just send it to the MIDIAccess object now + // so it can prepopulate its device list and resolve the promise. + a->Notify(mPortList); + } +} + +void MIDIAccessManager::Update(const MIDIPortList& aPortList) { + mPortList = aPortList; + mChangeObservers.Broadcast(aPortList); + if (!mHasPortList) { + mHasPortList = true; + // Now that we've broadcast the already-connected port list, content + // should manage the lifetime of the MIDIAccess object, so we can clear the + // keep-alive array. + mAccessHolder.Clear(); + } +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIAccessManager.h b/dom/midi/MIDIAccessManager.h new file mode 100644 index 0000000000..606c73d268 --- /dev/null +++ b/dom/midi/MIDIAccessManager.h @@ -0,0 +1,76 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIAccessManager_h +#define mozilla_dom_MIDIAccessManager_h + +#include "nsPIDOMWindow.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/Observer.h" + +namespace mozilla::dom { + +class MIDIAccess; +class MIDIManagerChild; +struct MIDIOptions; +class MIDIPortChangeEvent; +class MIDIPortInfo; +class Promise; + +/** + * MIDIAccessManager manages creation and lifetime of MIDIAccess objects for the + * process it lives in. It is in charge of dealing with permission requests, + * creating new MIDIAccess objects, and updating live MIDIAccess objects with + * new device listings. + * + * While a process/window can have many MIDIAccess objects, there is only one + * MIDIAccessManager for any one process. + */ +class MIDIAccessManager final { + public: + NS_INLINE_DECL_REFCOUNTING(MIDIAccessManager); + // Handles requests from Navigator for MIDI permissions and MIDIAccess + // creation. + already_AddRefed<Promise> RequestMIDIAccess(nsPIDOMWindowInner* aWindow, + const MIDIOptions& aOptions, + ErrorResult& aRv); + // Creates a new MIDIAccess object + void CreateMIDIAccess(nsPIDOMWindowInner* aWindow, bool aNeedsSysex, + Promise* aPromise); + // Getter for manager singleton + static MIDIAccessManager* Get(); + // True if manager singleton has been created + static bool IsRunning(); + // Send device connection updates to all known MIDIAccess objects. + void Update(const MIDIPortList& aPortList); + // Adds a device update observer (usually a MIDIAccess object) + bool AddObserver(Observer<MIDIPortList>* aObserver); + // Removes a device update observer (usually a MIDIAccess object) + void RemoveObserver(Observer<MIDIPortList>* aObserver); + // Requests the service to update the list of devices + void SendRefresh(); + + private: + MIDIAccessManager(); + ~MIDIAccessManager(); + void StartActor(); + // True if object has received a device list from the MIDI platform service. + bool mHasPortList; + // List of known ports for the system. + MIDIPortList mPortList; + // Holds MIDIAccess objects until we've received the first list of devices + // from the MIDI Service. + nsTArray<RefPtr<MIDIAccess>> mAccessHolder; + // Device state update observers (usually MIDIAccess objects) + ObserverList<MIDIPortList> mChangeObservers; + // IPC Object for MIDIManager. Created on first MIDIAccess object creation, + // destroyed on last MIDIAccess object destruction. + RefPtr<MIDIManagerChild> mChild; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIAccessManager_h diff --git a/dom/midi/MIDIInput.cpp b/dom/midi/MIDIInput.cpp new file mode 100644 index 0000000000..dbd46fa843 --- /dev/null +++ b/dom/midi/MIDIInput.cpp @@ -0,0 +1,102 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIInput.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/MIDIPortChild.h" +#include "mozilla/dom/MIDIInputBinding.h" +#include "mozilla/dom/MIDIMessageEvent.h" +#include "mozilla/dom/MIDIMessageEventBinding.h" +#include "nsDOMNavigationTiming.h" + +#include "MIDILog.h" + +namespace mozilla::dom { + +MIDIInput::MIDIInput(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent) + : MIDIPort(aWindow, aMIDIAccessParent), mKeepAlive(false) {} + +// static +MIDIInput* MIDIInput::Create(nsPIDOMWindowInner* aWindow, + MIDIAccess* aMIDIAccessParent, + const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled) { + MOZ_ASSERT(static_cast<MIDIPortType>(aPortInfo.type()) == + MIDIPortType::Input); + auto* port = new MIDIInput(aWindow, aMIDIAccessParent); + if (!port->Initialize(aPortInfo, aSysexEnabled)) { + return nullptr; + } + return port; +} + +JSObject* MIDIInput::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return MIDIInput_Binding::Wrap(aCx, this, aGivenProto); +} + +void MIDIInput::Receive(const nsTArray<MIDIMessage>& aMsgs) { + if (!GetOwner()) { + return; // Ignore messages once we've been disconnected from the owner + } + + nsCOMPtr<Document> doc = GetOwner()->GetDoc(); + if (!doc) { + NS_WARNING("No document available to send MIDIMessageEvent to!"); + return; + } + for (const auto& msg : aMsgs) { + RefPtr<MIDIMessageEvent> event( + MIDIMessageEvent::Constructor(this, msg.timestamp(), msg.data())); + DispatchTrustedEvent(event); + } +} + +void MIDIInput::StateChange() { + if (Port()->ConnectionState() == MIDIPortConnectionState::Open || + (Port()->DeviceState() == MIDIPortDeviceState::Connected && + Port()->ConnectionState() == MIDIPortConnectionState::Pending)) { + KeepAliveOnMidimessage(); + } else { + DontKeepAliveOnMidimessage(); + } +} + +void MIDIInput::EventListenerAdded(nsAtom* aType) { + if (aType == nsGkAtoms::onmidimessage) { + // HACK: the Web MIDI spec states that we should open a port only when + // setting the midimessage event handler but Chrome does it even when + // adding event listeners hence this. + if (Port()->ConnectionState() != MIDIPortConnectionState::Open) { + LOG("onmidimessage event listener added, sending implicit Open"); + Port()->SendOpen(); + } + } + + DOMEventTargetHelper::EventListenerAdded(aType); +} + +void MIDIInput::DisconnectFromOwner() { + DontKeepAliveOnMidimessage(); + + MIDIPort::DisconnectFromOwner(); +} + +void MIDIInput::KeepAliveOnMidimessage() { + if (!mKeepAlive) { + mKeepAlive = true; + KeepAliveIfHasListenersFor(nsGkAtoms::onmidimessage); + } +} + +void MIDIInput::DontKeepAliveOnMidimessage() { + if (mKeepAlive) { + IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onmidimessage); + mKeepAlive = false; + } +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIInput.h b/dom/midi/MIDIInput.h new file mode 100644 index 0000000000..724cd17af6 --- /dev/null +++ b/dom/midi/MIDIInput.h @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIInput_h +#define mozilla_dom_MIDIInput_h + +#include "mozilla/dom/MIDIPort.h" + +struct JSContext; + +namespace mozilla::dom { + +class MIDIPortInfo; + +/** + * Represents a MIDI Input Port, handles generating incoming message events. + * + */ +class MIDIInput final : public MIDIPort { + public: + static MIDIInput* Create(nsPIDOMWindowInner* aWindow, + MIDIAccess* aMIDIAccessParent, + const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled); + ~MIDIInput() = default; + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + IMPL_EVENT_HANDLER(midimessage); + + void StateChange() override; + void EventListenerAdded(nsAtom* aType) override; + void DisconnectFromOwner() override; + + private: + MIDIInput(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent); + // Takes an array of IPC MIDIMessage objects and turns them into + // MIDIMessageEvents, which it then fires. + void Receive(const nsTArray<MIDIMessage>& aMsgs) override; + + void KeepAliveOnMidimessage(); + void DontKeepAliveOnMidimessage(); + + // If true this object will be kept alive even without direct JS references + bool mKeepAlive; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIInput_h diff --git a/dom/midi/MIDIInputMap.cpp b/dom/midi/MIDIInputMap.cpp new file mode 100644 index 0000000000..aa4f57a7d3 --- /dev/null +++ b/dom/midi/MIDIInputMap.cpp @@ -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/. */ + +#include "mozilla/dom/MIDIInputMap.h" +#include "mozilla/dom/MIDIInputMapBinding.h" +#include "nsPIDOMWindow.h" +#include "mozilla/dom/BindingUtils.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(MIDIInputMap, mParent) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(MIDIInputMap) +NS_IMPL_CYCLE_COLLECTING_RELEASE(MIDIInputMap) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIInputMap) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +MIDIInputMap::MIDIInputMap(nsPIDOMWindowInner* aParent) : mParent(aParent) {} + +JSObject* MIDIInputMap::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return MIDIInputMap_Binding::Wrap(aCx, this, aGivenProto); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIInputMap.h b/dom/midi/MIDIInputMap.h new file mode 100644 index 0000000000..5826290dbc --- /dev/null +++ b/dom/midi/MIDIInputMap.h @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIInputMap_h +#define mozilla_dom_MIDIInputMap_h + +#include "mozilla/dom/MIDIPort.h" +#include "nsCOMPtr.h" +#include "nsTHashMap.h" +#include "nsWrapperCache.h" + +class nsPIDOMWindowInner; + +namespace mozilla::dom { + +/** + * Maplike DOM object that holds a list of all MIDI input ports available for + * access. Almost all functions are implemented automatically by WebIDL. + */ +class MIDIInputMap final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(MIDIInputMap) + nsPIDOMWindowInner* GetParentObject() const { return mParent; } + + explicit MIDIInputMap(nsPIDOMWindowInner* aParent); + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + bool Has(nsAString& aId) { return mPorts.Get(aId) != nullptr; } + void Insert(nsAString& aId, RefPtr<MIDIPort> aPort) { + mPorts.InsertOrUpdate(aId, aPort); + } + void Remove(nsAString& aId) { mPorts.Remove(aId); } + + private: + ~MIDIInputMap() = default; + nsTHashMap<nsString, RefPtr<MIDIPort>> mPorts; + nsCOMPtr<nsPIDOMWindowInner> mParent; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIInputMap_h diff --git a/dom/midi/MIDILog.cpp b/dom/midi/MIDILog.cpp new file mode 100644 index 0000000000..cc9945ed58 --- /dev/null +++ b/dom/midi/MIDILog.cpp @@ -0,0 +1,46 @@ +/* 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 "MIDILog.h" + +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/MIDIPortBinding.h" + +mozilla::LazyLogModule gWebMIDILog("WebMIDI"); + +void LogMIDIMessage(const mozilla::dom::MIDIMessage& aMessage, + const nsAString& aPortId, + mozilla::dom::MIDIPortType aDirection) { + if (MOZ_LOG_TEST(gWebMIDILog, mozilla::LogLevel::Debug)) { + if (MOZ_LOG_TEST(gWebMIDILog, mozilla::LogLevel::Verbose)) { + uint32_t byteCount = aMessage.data().Length(); + nsAutoCString logMessage; + // Log long messages inline with the timestamp and the length, log + // longer messages a bit like xxd + logMessage.AppendPrintf( + "%s %s length=%u", NS_ConvertUTF16toUTF8(aPortId).get(), + aDirection == mozilla::dom::MIDIPortType::Input ? "->" : "<-", + byteCount); + + if (byteCount <= 3) { + logMessage.AppendPrintf(" ["); + // Regular messages + for (uint32_t i = 0; i < byteCount - 1; i++) { + logMessage.AppendPrintf("%x ", aMessage.data()[i]); + } + logMessage.AppendPrintf("%x]", aMessage.data()[byteCount - 1]); + } else { + // Longer messages + for (uint32_t i = 0; i < byteCount; i++) { + if (!(i % 8)) { + logMessage.AppendPrintf("\n%08u:\t", i); + } + logMessage.AppendPrintf("%x ", aMessage.data()[i]); + } + } + MOZ_LOG(gWebMIDILog, mozilla::LogLevel::Verbose, + ("%s", logMessage.get())); + } + } +} diff --git a/dom/midi/MIDILog.h b/dom/midi/MIDILog.h new file mode 100644 index 0000000000..ee2cae3dfc --- /dev/null +++ b/dom/midi/MIDILog.h @@ -0,0 +1,26 @@ +/* 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_dom_MIDILog_h +#define mozilla_dom_MIDILog_h + +#include <mozilla/Logging.h> +#include <nsStringFwd.h> + +namespace mozilla::dom { +class MIDIMessage; +enum class MIDIPortType : uint8_t; +} // namespace mozilla::dom + +extern mozilla::LazyLogModule gWebMIDILog; + +#define LOG(...) MOZ_LOG(gWebMIDILog, mozilla::LogLevel::Debug, (__VA_ARGS__)); +#define LOGV(x, ...) \ + MOZ_LOG(gWebMIDILog, mozilla::LogLevel::Verbose, (__VA_ARGS__)); + +void LogMIDIMessage(const mozilla::dom::MIDIMessage& aMessage, + const nsAString& aPortId, + mozilla::dom::MIDIPortType aDirection); + +#endif // mozilla_dom_MIDILog_h diff --git a/dom/midi/MIDIManagerChild.cpp b/dom/midi/MIDIManagerChild.cpp new file mode 100644 index 0000000000..cb0dd6a793 --- /dev/null +++ b/dom/midi/MIDIManagerChild.cpp @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "MIDIManagerChild.h" +#include "mozilla/dom/MIDIAccessManager.h" + +using namespace mozilla::dom; + +MIDIManagerChild::MIDIManagerChild() : mShutdown(false) {} + +mozilla::ipc::IPCResult MIDIManagerChild::RecvMIDIPortListUpdate( + const MIDIPortList& aPortList) { + MOZ_ASSERT(NS_IsMainThread()); + if (mShutdown) { + return IPC_OK(); + } + MOZ_ASSERT(MIDIAccessManager::IsRunning()); + MIDIAccessManager::Get()->Update(aPortList); + return IPC_OK(); +} + +void MIDIManagerChild::Shutdown() { + MOZ_ASSERT(!mShutdown); + mShutdown = true; + SendShutdown(); +} diff --git a/dom/midi/MIDIManagerChild.h b/dom/midi/MIDIManagerChild.h new file mode 100644 index 0000000000..610105de9c --- /dev/null +++ b/dom/midi/MIDIManagerChild.h @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIManagerChild_h +#define mozilla_dom_MIDIManagerChild_h + +#include "mozilla/dom/PMIDIManagerChild.h" + +namespace mozilla::dom { + +/** + * Actor implementation for the Child side of MIDIManager (represented in DOM by + * MIDIAccess). Manages actor lifetime so that we know to shut down services + * when all MIDIManagers are gone. Also receives port list update on MIDIAccess + * object creation. + * + */ +class MIDIManagerChild final : public PMIDIManagerChild { + public: + NS_INLINE_DECL_REFCOUNTING(MIDIManagerChild) + + MIDIManagerChild(); + mozilla::ipc::IPCResult RecvMIDIPortListUpdate(const MIDIPortList& aPortList); + void Shutdown(); + + private: + ~MIDIManagerChild() = default; + bool mShutdown; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIManagerChild_h diff --git a/dom/midi/MIDIManagerParent.cpp b/dom/midi/MIDIManagerParent.cpp new file mode 100644 index 0000000000..ef574f5b04 --- /dev/null +++ b/dom/midi/MIDIManagerParent.cpp @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIManagerParent.h" +#include "mozilla/dom/MIDIPlatformService.h" + +namespace mozilla::dom { + +void MIDIManagerParent::ActorDestroy(ActorDestroyReason aWhy) { + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->RemoveManager(this); + } +} + +mozilla::ipc::IPCResult MIDIManagerParent::RecvRefresh() { + MIDIPlatformService::Get()->Refresh(); + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIManagerParent::RecvShutdown() { + // The two-step shutdown process here is the standard way to ensure that the + // child receives any messages sent by the server (since either sending or + // receiving __delete__ prevents any further messages from being received). + // This was necessary before bug 1547085 when discarded messages would + // trigger a crash, and is probably unnecessary now, but we leave it in place + // just in case. + Close(); + return IPC_OK(); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIManagerParent.h b/dom/midi/MIDIManagerParent.h new file mode 100644 index 0000000000..a8ff0648da --- /dev/null +++ b/dom/midi/MIDIManagerParent.h @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIManagerParent_h +#define mozilla_dom_MIDIManagerParent_h + +#include "mozilla/dom/PMIDIManagerParent.h" + +namespace mozilla::dom { + +/** + * Actor implementation for the Parent (PBackground thread) side of MIDIManager + * (represented in DOM by MIDIAccess). Manages actor lifetime so that we know + * to shut down services when all MIDIManagers are gone. + * + */ +class MIDIManagerParent final : public PMIDIManagerParent { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MIDIManagerParent, override) + MIDIManagerParent() = default; + mozilla::ipc::IPCResult RecvRefresh(); + mozilla::ipc::IPCResult RecvShutdown(); + void ActorDestroy(ActorDestroyReason aWhy) override; + + private: + ~MIDIManagerParent() = default; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIManagerParent_h diff --git a/dom/midi/MIDIMessageEvent.cpp b/dom/midi/MIDIMessageEvent.cpp new file mode 100644 index 0000000000..f539bf7c89 --- /dev/null +++ b/dom/midi/MIDIMessageEvent.cpp @@ -0,0 +1,96 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/EventBinding.h" +#include "mozilla/dom/MIDIMessageEvent.h" +#include "mozilla/dom/MIDIMessageEventBinding.h" +#include "js/GCAPI.h" +#include "jsfriendapi.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/HoldDropJSObjects.h" +#include "mozilla/dom/Nullable.h" +#include "mozilla/dom/PrimitiveConversions.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/dom/Performance.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED_WITH_JS_MEMBERS(MIDIMessageEvent, Event, (), + (mData)) + +NS_IMPL_ADDREF_INHERITED(MIDIMessageEvent, Event) +NS_IMPL_RELEASE_INHERITED(MIDIMessageEvent, Event) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIMessageEvent) +NS_INTERFACE_MAP_END_INHERITING(Event) + +MIDIMessageEvent::MIDIMessageEvent(mozilla::dom::EventTarget* aOwner) + : Event(aOwner, nullptr, nullptr) { + mozilla::HoldJSObjects(this); +} + +MIDIMessageEvent::~MIDIMessageEvent() { mozilla::DropJSObjects(this); } + +JSObject* MIDIMessageEvent::WrapObjectInternal( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return MIDIMessageEvent_Binding::Wrap(aCx, this, aGivenProto); +} + +MIDIMessageEvent* MIDIMessageEvent::AsMIDIMessageEvent() { return this; } + +already_AddRefed<MIDIMessageEvent> MIDIMessageEvent::Constructor( + EventTarget* aOwner, const class TimeStamp& aReceivedTime, + const nsTArray<uint8_t>& aData) { + MOZ_ASSERT(aOwner); + RefPtr<MIDIMessageEvent> e = new MIDIMessageEvent(aOwner); + e->InitEvent(u"midimessage"_ns, false, false); + e->mEvent->mTimeStamp = aReceivedTime; + e->mRawData = aData.Clone(); + e->SetTrusted(true); + return e.forget(); +} + +already_AddRefed<MIDIMessageEvent> MIDIMessageEvent::Constructor( + const GlobalObject& aGlobal, const nsAString& aType, + const MIDIMessageEventInit& aEventInitDict, ErrorResult& aRv) { + nsCOMPtr<EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports()); + RefPtr<MIDIMessageEvent> e = new MIDIMessageEvent(owner); + bool trusted = e->Init(owner); + e->InitEvent(aType, aEventInitDict.mBubbles, aEventInitDict.mCancelable); + // Set data for event. Timestamp will always be set to Now() (default for + // event) using this constructor. + if (aEventInitDict.mData.WasPassed()) { + const auto& a = aEventInitDict.mData.Value(); + a.ComputeState(); + e->mData = + Uint8Array::Create(aGlobal.Context(), owner, a.Length(), a.Data()); + if (NS_WARN_IF(!e->mData)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return nullptr; + } + } + + e->SetTrusted(trusted); + mozilla::HoldJSObjects(e.get()); + return e.forget(); +} + +void MIDIMessageEvent::GetData(JSContext* cx, + JS::MutableHandle<JSObject*> aData, + ErrorResult& aRv) { + if (!mData) { + mData = + Uint8Array::Create(cx, this, mRawData.Length(), mRawData.Elements()); + if (!mData) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + mRawData.Clear(); + } + aData.set(mData); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIMessageEvent.h b/dom/midi/MIDIMessageEvent.h new file mode 100644 index 0000000000..d5bc0b710a --- /dev/null +++ b/dom/midi/MIDIMessageEvent.h @@ -0,0 +1,62 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIMessageEvent_h +#define mozilla_dom_MIDIMessageEvent_h + +#include <cstdint> +#include "js/RootingAPI.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Assertions.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/Event.h" +#include "nsCycleCollectionParticipant.h" +#include "nsISupports.h" +#include "nsStringFwd.h" +#include "nsTArray.h" + +struct JSContext; +namespace mozilla::dom { +struct MIDIMessageEventInit; + +/** + * Event that fires whenever a MIDI message is received by the MIDIInput object. + * + */ +class MIDIMessageEvent final : public Event { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MIDIMessageEvent, + Event) + protected: + explicit MIDIMessageEvent(mozilla::dom::EventTarget* aOwner); + + JS::Heap<JSObject*> mData; + + public: + virtual MIDIMessageEvent* AsMIDIMessageEvent(); + virtual JSObject* WrapObjectInternal( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; + static already_AddRefed<MIDIMessageEvent> Constructor( + EventTarget* aOwner, const class TimeStamp& aReceivedTime, + const nsTArray<uint8_t>& aData); + + static already_AddRefed<MIDIMessageEvent> Constructor( + const GlobalObject& aGlobal, const nsAString& aType, + const MIDIMessageEventInit& aEventInitDict, ErrorResult& aRv); + + // Getter for message data + void GetData(JSContext* cx, JS::MutableHandle<JSObject*> aData, + ErrorResult& aRv); + + private: + ~MIDIMessageEvent(); + nsTArray<uint8_t> mRawData; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIMessageEvent_h diff --git a/dom/midi/MIDIMessageQueue.cpp b/dom/midi/MIDIMessageQueue.cpp new file mode 100644 index 0000000000..3006b225c0 --- /dev/null +++ b/dom/midi/MIDIMessageQueue.cpp @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "MIDIMessageQueue.h" +#include "mozilla/dom/MIDITypes.h" + +namespace mozilla::dom { + +MIDIMessageQueue::MIDIMessageQueue() : mMutex("MIDIMessageQueue::mMutex") {} + +class MIDIMessageTimestampComparator { + public: + bool Equals(const MIDIMessage& a, const MIDIMessage& b) const { + return a.timestamp() == b.timestamp(); + } + bool LessThan(const MIDIMessage& a, const MIDIMessage& b) const { + return a.timestamp() < b.timestamp(); + } +}; + +void MIDIMessageQueue::Add(nsTArray<MIDIMessage>& aMsg) { + MutexAutoLock lock(mMutex); + for (auto msg : aMsg) { + mMessageQueue.InsertElementSorted(msg, MIDIMessageTimestampComparator()); + } +} + +void MIDIMessageQueue::GetMessagesBefore(TimeStamp aTimestamp, + nsTArray<MIDIMessage>& aMsgQueue) { + MutexAutoLock lock(mMutex); + int i = 0; + for (auto msg : mMessageQueue) { + if (aTimestamp < msg.timestamp()) { + break; + } + aMsgQueue.AppendElement(msg); + i++; + } + if (i > 0) { + mMessageQueue.RemoveElementsAt(0, i); + } +} + +void MIDIMessageQueue::GetMessages(nsTArray<MIDIMessage>& aMsgQueue) { + MutexAutoLock lock(mMutex); + aMsgQueue.AppendElements(mMessageQueue); + mMessageQueue.Clear(); +} + +void MIDIMessageQueue::Clear() { + MutexAutoLock lock(mMutex); + mMessageQueue.Clear(); +} + +void MIDIMessageQueue::ClearAfterNow() { + MutexAutoLock lock(mMutex); + TimeStamp now = TimeStamp::Now(); + int i = 0; + for (auto msg : mMessageQueue) { + if (now < msg.timestamp()) { + break; + } + i++; + } + if (i > 0) { + mMessageQueue.RemoveElementsAt(0, i); + } +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIMessageQueue.h b/dom/midi/MIDIMessageQueue.h new file mode 100644 index 0000000000..cadfc1b249 --- /dev/null +++ b/dom/midi/MIDIMessageQueue.h @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIMessageQueue_h +#define mozilla_dom_MIDIMessageQueue_h + +#include "mozilla/Mutex.h" +#include "nsTArray.h" + +// XXX Avoid including this here by moving function implementations to the cpp +// file. +#include "mozilla/dom/MIDITypes.h" + +namespace mozilla { + +class TimeStamp; + +namespace dom { + +class MIDIMessage; + +/** + * Since some MIDI Messages can be scheduled to be sent in the future, the + * MIDIMessageQueue is responsible for making sure all MIDI messages are + * scheduled and sent in order. + */ +class MIDIMessageQueue { + public: + MIDIMessageQueue(); + ~MIDIMessageQueue() = default; + // Adds an array of possibly out-of-order messages to our queue. + void Add(nsTArray<MIDIMessage>& aMsg); + // Retrieve all pending messages before the time specified. + void GetMessagesBefore(TimeStamp aTimestamp, + nsTArray<MIDIMessage>& aMsgQueue); + // Get all pending messages. + void GetMessages(nsTArray<MIDIMessage>& aMsgQueue); + // Erase all pending messages. + void Clear(); + // Erase all pending messages that would be sent in the future. Useful for + // when ports are closed, as we must send all messages with timestamps in the + // past. + void ClearAfterNow(); + + private: + // Array of messages to be sent. + nsTArray<MIDIMessage> mMessageQueue; + // Mutex for coordinating cross thread array access. + Mutex mMutex MOZ_UNANNOTATED; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_MIDIMessageQueue_h diff --git a/dom/midi/MIDIOutput.cpp b/dom/midi/MIDIOutput.cpp new file mode 100644 index 0000000000..5421e0c880 --- /dev/null +++ b/dom/midi/MIDIOutput.cpp @@ -0,0 +1,103 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIOutput.h" +#include "mozilla/dom/MIDIPortChild.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/MIDIOutputBinding.h" +#include "mozilla/dom/MIDIUtils.h" +#include "nsDOMNavigationTiming.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Performance.h" + +using namespace mozilla; +using namespace mozilla::dom; + +MIDIOutput::MIDIOutput(nsPIDOMWindowInner* aWindow, + MIDIAccess* aMIDIAccessParent) + : MIDIPort(aWindow, aMIDIAccessParent) {} + +// static +MIDIOutput* MIDIOutput::Create(nsPIDOMWindowInner* aWindow, + MIDIAccess* aMIDIAccessParent, + const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled) { + MOZ_ASSERT(static_cast<MIDIPortType>(aPortInfo.type()) == + MIDIPortType::Output); + auto* port = new MIDIOutput(aWindow, aMIDIAccessParent); + if (NS_WARN_IF(!port->Initialize(aPortInfo, aSysexEnabled))) { + return nullptr; + } + return port; +} + +JSObject* MIDIOutput::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return MIDIOutput_Binding::Wrap(aCx, this, aGivenProto); +} + +void MIDIOutput::Send(const Sequence<uint8_t>& aData, + const Optional<double>& aTimestamp, ErrorResult& aRv) { + if (Port()->DeviceState() == MIDIPortDeviceState::Disconnected) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + // The timestamp passed to us is a DOMHighResTimestamp, which is in relation + // to the start of navigation timing. This needs to be turned into a + // TimeStamp before it hits the platform specific MIDI service. + // + // If timestamp is either not set or zero, set timestamp to now and send the + // message ASAP. + TimeStamp timestamp; + if (aTimestamp.WasPassed() && aTimestamp.Value() != 0) { + nsCOMPtr<Document> doc = GetOwner()->GetDoc(); + if (!doc) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + TimeDuration ts_diff = TimeDuration::FromMilliseconds(aTimestamp.Value()); + timestamp = GetOwner() + ->GetPerformance() + ->GetDOMTiming() + ->GetNavigationStartTimeStamp() + + ts_diff; + } else { + timestamp = TimeStamp::Now(); + } + + nsTArray<MIDIMessage> msgArray; + bool ret = MIDIUtils::ParseMessages(aData, timestamp, msgArray); + if (!ret) { + aRv.ThrowTypeError("Invalid MIDI message"); + return; + } + + if (msgArray.IsEmpty()) { + aRv.ThrowTypeError("Empty message array"); + return; + } + + // TODO Move this check back to parse message so we don't have to iterate + // twice. + if (!SysexEnabled()) { + for (auto& msg : msgArray) { + if (MIDIUtils::IsSysexMessage(msg)) { + aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR); + return; + } + } + } + Port()->SendSend(msgArray); +} + +void MIDIOutput::Clear() { + if (Port()->ConnectionState() == MIDIPortConnectionState::Closed) { + return; + } + Port()->SendClear(); +} diff --git a/dom/midi/MIDIOutput.h b/dom/midi/MIDIOutput.h new file mode 100644 index 0000000000..72d0efb55e --- /dev/null +++ b/dom/midi/MIDIOutput.h @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIOutput_h +#define mozilla_dom_MIDIOutput_h + +#include "mozilla/dom/MIDIPort.h" +#include "mozilla/Attributes.h" +#include "nsWrapperCache.h" + +struct JSContext; + +namespace mozilla { +class ErrorResult; + +namespace dom { + +class MIDIPortInfo; +class MIDIMessage; + +/** + * Represents a MIDI Output Port, handles sending message to devices. + * + */ +class MIDIOutput final : public MIDIPort { + public: + static MIDIOutput* Create(nsPIDOMWindowInner* aWindow, + MIDIAccess* aMIDIAccessParent, + const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled); + ~MIDIOutput() = default; + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + // Send a message to an output port + void Send(const Sequence<uint8_t>& aData, const Optional<double>& aTimestamp, + ErrorResult& aRv); + // Clear any partially sent messages from the send queue + void Clear(); + + private: + MIDIOutput(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent); +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_MIDIOutput_h diff --git a/dom/midi/MIDIOutputMap.cpp b/dom/midi/MIDIOutputMap.cpp new file mode 100644 index 0000000000..d7840827f2 --- /dev/null +++ b/dom/midi/MIDIOutputMap.cpp @@ -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/. */ + +#include "mozilla/dom/MIDIOutputMap.h" +#include "mozilla/dom/MIDIOutputMapBinding.h" +#include "nsPIDOMWindow.h" +#include "mozilla/dom/BindingUtils.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(MIDIOutputMap, mParent) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(MIDIOutputMap) +NS_IMPL_CYCLE_COLLECTING_RELEASE(MIDIOutputMap) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIOutputMap) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +MIDIOutputMap::MIDIOutputMap(nsPIDOMWindowInner* aParent) : mParent(aParent) {} + +JSObject* MIDIOutputMap::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return MIDIOutputMap_Binding::Wrap(aCx, this, aGivenProto); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIOutputMap.h b/dom/midi/MIDIOutputMap.h new file mode 100644 index 0000000000..2e33e8b2a7 --- /dev/null +++ b/dom/midi/MIDIOutputMap.h @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIOutputMap_h +#define mozilla_dom_MIDIOutputMap_h + +#include "mozilla/dom/MIDIPort.h" +#include "nsCOMPtr.h" +#include "nsTHashMap.h" +#include "nsWrapperCache.h" + +class nsPIDOMWindowInner; + +namespace mozilla::dom { + +/** + * Maplike DOM object that holds a list of all MIDI output ports available for + * access. Almost all functions are implemented automatically by WebIDL. + * + */ +class MIDIOutputMap final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(MIDIOutputMap) + + explicit MIDIOutputMap(nsPIDOMWindowInner* aParent); + + nsPIDOMWindowInner* GetParentObject() const { return mParent; } + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + bool Has(nsAString& aId) { return mPorts.Get(aId) != nullptr; } + void Insert(nsAString& aId, RefPtr<MIDIPort> aPort) { + mPorts.InsertOrUpdate(aId, aPort); + } + void Remove(nsAString& aId) { mPorts.Remove(aId); } + + private: + ~MIDIOutputMap() = default; + nsTHashMap<nsString, RefPtr<MIDIPort>> mPorts; + nsCOMPtr<nsPIDOMWindowInner> mParent; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIOutputMap_h diff --git a/dom/midi/MIDIPermissionRequest.cpp b/dom/midi/MIDIPermissionRequest.cpp new file mode 100644 index 0000000000..1eed95f177 --- /dev/null +++ b/dom/midi/MIDIPermissionRequest.cpp @@ -0,0 +1,202 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPermissionRequest.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/MIDIAccessManager.h" +#include "mozilla/dom/MIDIOptionsBinding.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/RandomNum.h" +#include "mozilla/StaticPrefs_dom.h" +#include "nsIGlobalObject.h" +#include "mozilla/Preferences.h" +#include "nsContentUtils.h" + +//------------------------------------------------- +// MIDI Permission Requests +//------------------------------------------------- + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_INHERITED(MIDIPermissionRequest, + ContentPermissionRequestBase, mPromise) + +NS_IMPL_QUERY_INTERFACE_CYCLE_COLLECTION_INHERITED(MIDIPermissionRequest, + ContentPermissionRequestBase, + nsIRunnable) + +NS_IMPL_ADDREF_INHERITED(MIDIPermissionRequest, ContentPermissionRequestBase) +NS_IMPL_RELEASE_INHERITED(MIDIPermissionRequest, ContentPermissionRequestBase) + +MIDIPermissionRequest::MIDIPermissionRequest(nsPIDOMWindowInner* aWindow, + Promise* aPromise, + const MIDIOptions& aOptions) + : ContentPermissionRequestBase( + aWindow->GetDoc()->NodePrincipal(), aWindow, + ""_ns, // We check prefs in a custom way here + "midi"_ns), + mPromise(aPromise), + mNeedsSysex(aOptions.mSysex) { + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aPromise, "aPromise should not be null!"); + MOZ_ASSERT(aWindow->GetDoc()); + mPrincipal = aWindow->GetDoc()->NodePrincipal(); + MOZ_ASSERT(mPrincipal); +} + +NS_IMETHODIMP +MIDIPermissionRequest::GetTypes(nsIArray** aTypes) { + NS_ENSURE_ARG_POINTER(aTypes); + nsTArray<nsString> options; + + // The previous implementation made no differences between midi and + // midi-sysex. The check on the SitePermsAddonProvider pref should be removed + // at the same time as the old implementation. + if (mNeedsSysex || !StaticPrefs::dom_sitepermsaddon_provider_enabled()) { + options.AppendElement(u"sysex"_ns); + } + return nsContentPermissionUtils::CreatePermissionArray(mType, options, + aTypes); +} + +NS_IMETHODIMP +MIDIPermissionRequest::Cancel() { + mCancelTimer = nullptr; + + if (StaticPrefs::dom_sitepermsaddon_provider_enabled()) { + mPromise->MaybeRejectWithSecurityError( + "WebMIDI requires a site permission add-on to activate"); + } else { + // This message is used for the initial XPIProvider-based implementation + // of Site Permissions. + // It should be removed as part of Bug 1789718. + mPromise->MaybeRejectWithSecurityError( + "WebMIDI requires a site permission add-on to activate — see " + "https://extensionworkshop.com/documentation/publish/" + "site-permission-add-on/ for details."); + } + return NS_OK; +} + +NS_IMETHODIMP +MIDIPermissionRequest::Allow(JS::Handle<JS::Value> aChoices) { + MOZ_ASSERT(aChoices.isUndefined()); + MIDIAccessManager* mgr = MIDIAccessManager::Get(); + mgr->CreateMIDIAccess(mWindow, mNeedsSysex, mPromise); + return NS_OK; +} + +NS_IMETHODIMP +MIDIPermissionRequest::Run() { + // If the testing flag is true, skip dialog + if (Preferences::GetBool("midi.prompt.testing", false)) { + bool allow = + Preferences::GetBool("media.navigator.permission.disabled", false); + if (allow) { + Allow(JS::UndefinedHandleValue); + } else { + Cancel(); + } + return NS_OK; + } + + nsCString permName = "midi"_ns; + // The previous implementation made no differences between midi and + // midi-sysex. The check on the SitePermsAddonProvider pref should be removed + // at the same time as the old implementation. + if (mNeedsSysex || !StaticPrefs::dom_sitepermsaddon_provider_enabled()) { + permName.Append("-sysex"); + } + + // First, check for an explicit allow/deny. Note that we want to support + // granting a permission on the base domain and then using it on a subdomain, + // which is why we use the non-"Exact" variants of these APIs. See bug + // 1757218. + if (nsContentUtils::IsSitePermAllow(mPrincipal, permName)) { + Allow(JS::UndefinedHandleValue); + return NS_OK; + } + + if (nsContentUtils::IsSitePermDeny(mPrincipal, permName)) { + CancelWithRandomizedDelay(); + return NS_OK; + } + + // If the add-on is not installed, and sitepermsaddon provider not enabled, + // auto-deny (except for localhost). + if (StaticPrefs::dom_webmidi_gated() && + !StaticPrefs::dom_sitepermsaddon_provider_enabled() && + !nsContentUtils::HasSitePerm(mPrincipal, permName) && + !mPrincipal->GetIsLoopbackHost()) { + CancelWithRandomizedDelay(); + return NS_OK; + } + + // If sitepermsaddon provider is enabled and user denied install, + // auto-deny (except for localhost, where we use a regular permission flow). + if (StaticPrefs::dom_sitepermsaddon_provider_enabled() && + nsContentUtils::IsSitePermDeny(mPrincipal, "install"_ns) && + !mPrincipal->GetIsLoopbackHost()) { + CancelWithRandomizedDelay(); + return NS_OK; + } + + // Before we bother the user with a prompt, see if they have any devices. If + // they don't, just report denial. + MOZ_ASSERT(NS_IsMainThread()); + mozilla::ipc::PBackgroundChild* actor = + mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread(); + if (NS_WARN_IF(!actor)) { + return NS_ERROR_FAILURE; + } + RefPtr<MIDIPermissionRequest> self = this; + actor->SendHasMIDIDevice( + [=](bool aHasDevices) { + MOZ_ASSERT(NS_IsMainThread()); + + if (aHasDevices) { + self->DoPrompt(); + } else { + nsContentUtils::ReportToConsoleNonLocalized( + u"Silently denying site request for MIDI access because no devices were detected. You may need to restart your browser after connecting a new device."_ns, + nsIScriptError::infoFlag, "WebMIDI"_ns, mWindow->GetDoc()); + self->CancelWithRandomizedDelay(); + } + }, + [=](auto) { self->CancelWithRandomizedDelay(); }); + + return NS_OK; +} + +// If the user has no MIDI devices, we automatically deny the request. To +// prevent sites from using timing attack to discern the existence of MIDI +// devices, we instrument silent denials with a randomized delay between 3 +// and 13 seconds, which is intended to model the time the user might spend +// considering a prompt before denying it. +// +// Note that we set the random component of the delay to zero in automation +// to avoid unnecessarily increasing test end-to-end time. +void MIDIPermissionRequest::CancelWithRandomizedDelay() { + MOZ_ASSERT(NS_IsMainThread()); + uint32_t baseDelayMS = 3 * 1000; + uint32_t randomDelayMS = + xpc::IsInAutomation() ? 0 : RandomUint64OrDie() % (10 * 1000); + auto delay = TimeDuration::FromMilliseconds(baseDelayMS + randomDelayMS); + RefPtr<MIDIPermissionRequest> self = this; + NS_NewTimerWithCallback( + getter_AddRefs(mCancelTimer), [=](auto) { self->Cancel(); }, delay, + nsITimer::TYPE_ONE_SHOT, __func__); +} + +nsresult MIDIPermissionRequest::DoPrompt() { + if (NS_FAILED(nsContentPermissionUtils::AskPermission(this, mWindow))) { + Cancel(); + return NS_ERROR_FAILURE; + } + return NS_OK; +} diff --git a/dom/midi/MIDIPermissionRequest.h b/dom/midi/MIDIPermissionRequest.h new file mode 100644 index 0000000000..935abf580a --- /dev/null +++ b/dom/midi/MIDIPermissionRequest.h @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPermissionRequest_h +#define mozilla_dom_MIDIPermissionRequest_h + +#include "mozilla/dom/Promise.h" +#include "nsContentPermissionHelper.h" + +namespace mozilla::dom { + +struct MIDIOptions; + +/** + * Handles permission dialog management when requesting MIDI permissions. + */ +class MIDIPermissionRequest final : public ContentPermissionRequestBase, + public nsIRunnable { + public: + MIDIPermissionRequest(nsPIDOMWindowInner* aWindow, Promise* aPromise, + const MIDIOptions& aOptions); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIRUNNABLE + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MIDIPermissionRequest, + ContentPermissionRequestBase) + // nsIContentPermissionRequest + NS_IMETHOD Cancel(void) override; + NS_IMETHOD Allow(JS::Handle<JS::Value> choices) override; + NS_IMETHOD GetTypes(nsIArray** aTypes) override; + + private: + ~MIDIPermissionRequest() = default; + nsresult DoPrompt(); + void CancelWithRandomizedDelay(); + + // If we're canceling on a timer, we need to hold a strong ref while it's + // outstanding. + nsCOMPtr<nsITimer> mCancelTimer; + + // Promise for returning MIDIAccess on request success + RefPtr<Promise> mPromise; + // True if sysex permissions should be requested + bool mNeedsSysex; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIPermissionRequest_h diff --git a/dom/midi/MIDIPlatformRunnables.cpp b/dom/midi/MIDIPlatformRunnables.cpp new file mode 100644 index 0000000000..355f90b9f3 --- /dev/null +++ b/dom/midi/MIDIPlatformRunnables.cpp @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPlatformRunnables.h" +#include "mozilla/dom/MIDIPlatformService.h" +#include "mozilla/dom/MIDIPortParent.h" +#include "mozilla/ipc/BackgroundParent.h" + +namespace mozilla::dom { + +NS_IMETHODIMP +MIDIBackgroundRunnable::Run() { + MIDIPlatformService::AssertThread(); + if (!MIDIPlatformService::IsRunning()) { + return NS_OK; + } + RunInternal(); + return NS_OK; +} + +void ReceiveRunnable::RunInternal() { + MIDIPlatformService::Get()->CheckAndReceive(mPortId, mMsgs); +} + +void AddPortRunnable::RunInternal() { + MIDIPlatformService::Get()->AddPortInfo(mPortInfo); +} + +void RemovePortRunnable::RunInternal() { + MIDIPlatformService::Get()->RemovePortInfo(mPortInfo); +} + +void SetStatusRunnable::RunInternal() { + MIDIPlatformService::Get()->UpdateStatus(mPort, mState, mConnection); +} + +void SendPortListRunnable::RunInternal() { + // Unlike other runnables, SendPortListRunnable should just exit quietly if + // the service has died. + if (!MIDIPlatformService::IsRunning()) { + return; + } + MIDIPlatformService::Get()->SendPortList(); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIPlatformRunnables.h b/dom/midi/MIDIPlatformRunnables.h new file mode 100644 index 0000000000..15727a99cc --- /dev/null +++ b/dom/midi/MIDIPlatformRunnables.h @@ -0,0 +1,125 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPlatformRunnables_h +#define mozilla_dom_MIDIPlatformRunnables_h + +#include "mozilla/dom/MIDITypes.h" + +namespace mozilla::dom { + +enum class MIDIPortConnectionState : uint8_t; +enum class MIDIPortDeviceState : uint8_t; + +class MIDIPortParent; +class MIDIMessage; +class MIDIPortInfo; + +/** + * Base class for runnables to be fired to the platform-specific MIDI service + * thread in PBackground. + */ +class MIDIBackgroundRunnable : public Runnable { + public: + MIDIBackgroundRunnable(const char* aName) : Runnable(aName) {} + virtual ~MIDIBackgroundRunnable() = default; + NS_IMETHOD Run() override; + virtual void RunInternal() = 0; +}; + +/** + * Runnable fired from platform-specific MIDI service thread to PBackground + * Thread whenever messages need to be sent to a MIDI device. + * + */ +class ReceiveRunnable final : public MIDIBackgroundRunnable { + public: + ReceiveRunnable(const nsAString& aPortId, const nsTArray<MIDIMessage>& aMsgs) + : MIDIBackgroundRunnable("ReceiveRunnable"), + mMsgs(aMsgs.Clone()), + mPortId(aPortId) {} + // Used in tests + ReceiveRunnable(const nsAString& aPortId, const MIDIMessage& aMsgs) + : MIDIBackgroundRunnable("ReceiveRunnable"), mPortId(aPortId) { + mMsgs.AppendElement(aMsgs); + } + ~ReceiveRunnable() = default; + void RunInternal() override; + + private: + nsTArray<MIDIMessage> mMsgs; + nsString mPortId; +}; + +/** + * Runnable fired from platform-specific MIDI service thread to PBackground + * Thread whenever a device is connected. + * + */ +class AddPortRunnable final : public MIDIBackgroundRunnable { + public: + explicit AddPortRunnable(const MIDIPortInfo& aPortInfo) + : MIDIBackgroundRunnable("AddPortRunnable"), mPortInfo(aPortInfo) {} + ~AddPortRunnable() = default; + void RunInternal() override; + + private: + MIDIPortInfo mPortInfo; +}; + +/** + * Runnable fired from platform-specific MIDI service thread to PBackground + * Thread whenever a device is disconnected. + * + */ +class RemovePortRunnable final : public MIDIBackgroundRunnable { + public: + explicit RemovePortRunnable(const MIDIPortInfo& aPortInfo) + : MIDIBackgroundRunnable("RemovePortRunnable"), mPortInfo(aPortInfo) {} + ~RemovePortRunnable() = default; + void RunInternal() override; + + private: + MIDIPortInfo mPortInfo; +}; + +/** + * Runnable used to delay calls to SendPortList, which is requires to make sure + * MIDIManager actor initialization happens correctly. Also used for testing. + * + */ +class SendPortListRunnable final : public MIDIBackgroundRunnable { + public: + SendPortListRunnable() : MIDIBackgroundRunnable("SendPortListRunnable") {} + ~SendPortListRunnable() = default; + void RunInternal() override; +}; + +/** + * Runnable fired from platform-specific MIDI service thread to PBackground + * Thread whenever a device is disconnected. + * + */ +class SetStatusRunnable final : public MIDIBackgroundRunnable { + public: + SetStatusRunnable(MIDIPortParent* aPort, MIDIPortDeviceState aState, + MIDIPortConnectionState aConnection) + : MIDIBackgroundRunnable("SetStatusRunnable"), + mPort(aPort), + mState(aState), + mConnection(aConnection) {} + ~SetStatusRunnable() = default; + void RunInternal() override; + + private: + RefPtr<MIDIPortParent> mPort; + MIDIPortDeviceState mState; + MIDIPortConnectionState mConnection; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIPlatformRunnables_h diff --git a/dom/midi/MIDIPlatformService.cpp b/dom/midi/MIDIPlatformService.cpp new file mode 100644 index 0000000000..a3ef5911a7 --- /dev/null +++ b/dom/midi/MIDIPlatformService.cpp @@ -0,0 +1,279 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "MIDIPlatformService.h" +#include "MIDIMessageQueue.h" +#include "TestMIDIPlatformService.h" +#ifdef MOZ_WEBMIDI_MIDIR_IMPL +# include "midirMIDIPlatformService.h" +#endif // MOZ_WEBMIDI_MIDIR_IMPL +#include "mozilla/ErrorResult.h" +#include "mozilla/StaticPrefs_midi.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/MIDIManagerParent.h" +#include "mozilla/dom/MIDIPlatformRunnables.h" +#include "mozilla/dom/MIDIUtils.h" +#include "mozilla/dom/PMIDIManagerParent.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/dom/MIDIPortParent.h" + +using namespace mozilla; +using namespace mozilla::dom; + +MIDIPlatformService::MIDIPlatformService() + : mHasSentPortList(false), + mMessageQueueMutex("MIDIPlatformServce::mMessageQueueMutex") {} + +MIDIPlatformService::~MIDIPlatformService() = default; + +void MIDIPlatformService::CheckAndReceive(const nsAString& aPortId, + const nsTArray<MIDIMessage>& aMsgs) { + AssertThread(); + for (auto& port : mPorts) { + // TODO Clean this up when we split input/output port arrays + if (port->MIDIPortInterface::Id() != aPortId || + port->Type() != MIDIPortType::Input || + port->ConnectionState() != MIDIPortConnectionState::Open) { + continue; + } + if (!port->SysexEnabled()) { + nsTArray<MIDIMessage> msgs; + for (const auto& msg : aMsgs) { + if (!MIDIUtils::IsSysexMessage(msg)) { + msgs.AppendElement(msg); + } + } + Unused << port->SendReceive(msgs); + } else { + Unused << port->SendReceive(aMsgs); + } + } +} + +void MIDIPlatformService::AddPort(MIDIPortParent* aPort) { + MOZ_ASSERT(aPort); + AssertThread(); + mPorts.AppendElement(aPort); +} + +void MIDIPlatformService::RemovePort(MIDIPortParent* aPort) { + // This should only be called from the background thread, when a MIDIPort + // actor has been destroyed. + AssertThread(); + MOZ_ASSERT(aPort); + mPorts.RemoveElement(aPort); + MaybeStop(); +} + +void MIDIPlatformService::BroadcastState(const MIDIPortInfo& aPortInfo, + const MIDIPortDeviceState& aState) { + AssertThread(); + for (auto& p : mPorts) { + if (p->MIDIPortInterface::Id() == aPortInfo.id() && + p->DeviceState() != aState) { + p->SendUpdateStatus(aState, p->ConnectionState()); + } + } +} + +void MIDIPlatformService::QueueMessages(const nsAString& aId, + nsTArray<MIDIMessage>& aMsgs) { + AssertThread(); + { + MutexAutoLock lock(mMessageQueueMutex); + MIDIMessageQueue* msgQueue = mMessageQueues.GetOrInsertNew(aId); + msgQueue->Add(aMsgs); + } + + ScheduleSend(aId); +} + +void MIDIPlatformService::SendPortList() { + AssertThread(); + mHasSentPortList = true; + MIDIPortList l; + for (auto& el : mPortInfo) { + l.ports().AppendElement(el); + } + for (auto& mgr : mManagers) { + Unused << mgr->SendMIDIPortListUpdate(l); + } +} + +void MIDIPlatformService::Clear(MIDIPortParent* aPort) { + AssertThread(); + MOZ_ASSERT(aPort); + { + MutexAutoLock lock(mMessageQueueMutex); + MIDIMessageQueue* msgQueue = + mMessageQueues.Get(aPort->MIDIPortInterface::Id()); + if (msgQueue) { + msgQueue->Clear(); + } + } +} + +void MIDIPlatformService::AddPortInfo(MIDIPortInfo& aPortInfo) { + AssertThread(); + MOZ_ASSERT(XRE_IsParentProcess()); + + mPortInfo.AppendElement(aPortInfo); + + // ORDER MATTERS HERE. + // + // When MIDI hardware is disconnected, all open MIDIPort objects revert to a + // "pending" state, and they are removed from the port maps of MIDIAccess + // objects. We need to send connection updates to all living ports first, THEN + // we can send port list updates to all of the live MIDIAccess objects. We + // have to go in this order because if a port object is still held live but is + // disconnected, it needs to readd itself to its originating MIDIAccess + // object. Running SendPortList first would cause MIDIAccess to create a new + // MIDIPort object, which would conflict (i.e. old disconnected object != new + // object in port map, which is against spec). + for (auto& port : mPorts) { + if (port->MIDIPortInterface::Id() == aPortInfo.id()) { + port->SendUpdateStatus(MIDIPortDeviceState::Connected, + port->ConnectionState()); + } + } + if (mHasSentPortList) { + SendPortList(); + } +} + +void MIDIPlatformService::RemovePortInfo(MIDIPortInfo& aPortInfo) { + AssertThread(); + mPortInfo.RemoveElement(aPortInfo); + BroadcastState(aPortInfo, MIDIPortDeviceState::Disconnected); + if (mHasSentPortList) { + SendPortList(); + } +} + +StaticRefPtr<nsISerialEventTarget> gMIDITaskQueue; + +// static +void MIDIPlatformService::InitStatics() { + nsCOMPtr<nsISerialEventTarget> queue; + MOZ_ALWAYS_SUCCEEDS( + NS_CreateBackgroundTaskQueue("MIDITaskQueue", getter_AddRefs(queue))); + gMIDITaskQueue = queue.forget(); + ClearOnShutdown(&gMIDITaskQueue); +} + +// static +nsISerialEventTarget* MIDIPlatformService::OwnerThread() { + return gMIDITaskQueue; +} + +StaticRefPtr<MIDIPlatformService> gMIDIPlatformService; + +// static +bool MIDIPlatformService::IsRunning() { + return gMIDIPlatformService != nullptr; +} + +void MIDIPlatformService::Close(mozilla::dom::MIDIPortParent* aPort) { + AssertThread(); + { + MutexAutoLock lock(mMessageQueueMutex); + MIDIMessageQueue* msgQueue = + mMessageQueues.Get(aPort->MIDIPortInterface::Id()); + if (msgQueue) { + msgQueue->ClearAfterNow(); + } + } + // Send all messages before sending a close request + ScheduleSend(aPort->MIDIPortInterface::Id()); + // TODO We should probably have the send function schedule closing + ScheduleClose(aPort); +} + +// static +MIDIPlatformService* MIDIPlatformService::Get() { + // We should never touch the platform service in a child process. + MOZ_ASSERT(XRE_IsParentProcess()); + AssertThread(); + if (!IsRunning()) { + if (StaticPrefs::midi_testing()) { + gMIDIPlatformService = new TestMIDIPlatformService(); + } +#ifdef MOZ_WEBMIDI_MIDIR_IMPL + else { + gMIDIPlatformService = new midirMIDIPlatformService(); + } +#endif // MOZ_WEBMIDI_MIDIR_IMPL + gMIDIPlatformService->Init(); + } + return gMIDIPlatformService; +} + +void MIDIPlatformService::MaybeStop() { + AssertThread(); + if (!IsRunning()) { + // Service already stopped or never started. Exit. + return; + } + // If we have any ports or managers left, we should still be alive. + if (!mPorts.IsEmpty() || !mManagers.IsEmpty()) { + return; + } + Stop(); + gMIDIPlatformService = nullptr; +} + +void MIDIPlatformService::AddManager(MIDIManagerParent* aManager) { + AssertThread(); + mManagers.AppendElement(aManager); + // Managers add themselves during construction. We have to wait for the + // protocol construction to finish before we send them a port list. The + // runnable calls SendPortList, which iterates through the live manager list, + // so this saves us from having to worry about Manager pointer validity at + // time of runnable execution. + nsCOMPtr<nsIRunnable> r(new SendPortListRunnable()); + OwnerThread()->Dispatch(r.forget()); +} + +void MIDIPlatformService::RemoveManager(MIDIManagerParent* aManager) { + AssertThread(); + mManagers.RemoveElement(aManager); + MaybeStop(); +} + +void MIDIPlatformService::UpdateStatus( + MIDIPortParent* aPort, const MIDIPortDeviceState& aDeviceState, + const MIDIPortConnectionState& aConnectionState) { + AssertThread(); + aPort->SendUpdateStatus(aDeviceState, aConnectionState); +} + +void MIDIPlatformService::GetMessages(const nsAString& aPortId, + nsTArray<MIDIMessage>& aMsgs) { + // Can run on either background thread or platform specific IO Thread. + { + MutexAutoLock lock(mMessageQueueMutex); + MIDIMessageQueue* msgQueue; + if (!mMessageQueues.Get(aPortId, &msgQueue)) { + return; + } + msgQueue->GetMessages(aMsgs); + } +} + +void MIDIPlatformService::GetMessagesBefore(const nsAString& aPortId, + const TimeStamp& aTimeStamp, + nsTArray<MIDIMessage>& aMsgs) { + // Can run on either background thread or platform specific IO Thread. + { + MutexAutoLock lock(mMessageQueueMutex); + MIDIMessageQueue* msgQueue; + if (!mMessageQueues.Get(aPortId, &msgQueue)) { + return; + } + msgQueue->GetMessagesBefore(aTimeStamp, aMsgs); + } +} diff --git a/dom/midi/MIDIPlatformService.h b/dom/midi/MIDIPlatformService.h new file mode 100644 index 0000000000..36a1ea1296 --- /dev/null +++ b/dom/midi/MIDIPlatformService.h @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPlatformService_h +#define mozilla_dom_MIDIPlatformService_h + +#include "nsClassHashtable.h" +#include "mozilla/Mutex.h" +#include "mozilla/dom/MIDIPortBinding.h" +#include "nsHashKeys.h" + +// XXX Avoid including this here by moving function implementations to the cpp +// file. +#include "mozilla/dom/MIDIMessageQueue.h" + +namespace mozilla::dom { + +class MIDIManagerParent; +class MIDIPortParent; +class MIDIMessage; +class MIDIMessageQueue; +class MIDIPortInfo; + +/** + * Base class for platform specific MIDI implementations. Handles aggregation of + * IPC service objects, as well as sending/receiving updates about port + * connection events and messages. + * + */ +class MIDIPlatformService { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MIDIPlatformService); + // Adds info about MIDI Port that has been connected. + void AddPortInfo(MIDIPortInfo& aPortInfo); + + // Removes info of MIDI Port that has been disconnected. + void RemovePortInfo(MIDIPortInfo& aPortInfo); + + // Adds a newly created manager protocol object to manager array. + void AddManager(MIDIManagerParent* aManager); + + // Removes a deleted manager protocol object from manager array. + void RemoveManager(MIDIManagerParent* aManager); + + // Adds a newly created port protocol object to port array. + void AddPort(MIDIPortParent* aPort); + + // Removes a deleted port protocol object from port array. + void RemovePort(MIDIPortParent* aPort); + + // Platform specific init function. + virtual void Init() = 0; + + // Forces the implementation to refresh the port list. + virtual void Refresh() = 0; + + // Platform specific MIDI port opening function. + virtual void Open(MIDIPortParent* aPort) = 0; + + // Clears all queued MIDI messages for a port. + void Clear(MIDIPortParent* aPort); + + // Puts in a request to destroy the singleton MIDIPlatformService object. + // Object will only be destroyed if there are no more MIDIManager and MIDIPort + // protocols left to communicate with. + void MaybeStop(); + + // Initializes statics on startup. + static void InitStatics(); + + // Returns the MIDI Task Queue. + static nsISerialEventTarget* OwnerThread(); + + // Asserts that we're on the above task queue. + static void AssertThread() { + MOZ_DIAGNOSTIC_ASSERT(OwnerThread()->IsOnCurrentThread()); + } + + // True if service is live. + static bool IsRunning(); + + // Returns a pointer to the MIDIPlatformService object, creating it and + // starting the platform specific service if it is not currently running. + static MIDIPlatformService* Get(); + + // Sends a list of all currently connected ports in order to populate a new + // MIDIAccess object. + void SendPortList(); + + // Receives a new set of messages from an MIDI Input Port, and checks their + // validity. + void CheckAndReceive(const nsAString& aPortID, + const nsTArray<MIDIMessage>& aMsgs); + + // Sends connection/disconnect/open/closed/etc status updates about a MIDI + // Port to all port listeners. + void UpdateStatus(MIDIPortParent* aPort, + const MIDIPortDeviceState& aDeviceState, + const MIDIPortConnectionState& aConnectionState); + + // Adds outgoing messages to the sorted message queue, for sending later. + void QueueMessages(const nsAString& aId, nsTArray<MIDIMessage>& aMsgs); + + // Clears all messages later than now, sends all outgoing message scheduled + // before/at now, and schedules MIDI Port connection closing. + void Close(MIDIPortParent* aPort); + + // Returns whether there are currently any MIDI devices. + bool HasDevice() { return !mPortInfo.IsEmpty(); } + + protected: + MIDIPlatformService(); + virtual ~MIDIPlatformService(); + // Platform specific MIDI service shutdown method. + virtual void Stop() = 0; + + // When device state of a MIDI Port changes, broadcast to all IPC port + // objects. + void BroadcastState(const MIDIPortInfo& aPortInfo, + const MIDIPortDeviceState& aState); + + // Platform specific MIDI port closing function. Named "Schedule" due to the + // fact that it needs to happen in the context of the I/O thread for the + // platform MIDI implementation, and therefore will happen async. + virtual void ScheduleClose(MIDIPortParent* aPort) = 0; + + // Platform specific MIDI message sending function. Named "Schedule" due to + // the fact that it needs to happen in the context of the I/O thread for the + // platform MIDI implementation, and therefore will happen async. + virtual void ScheduleSend(const nsAString& aPortId) = 0; + + // Allows platform specific IO Threads to retrieve all messages to be sent. + // Handles mutex locking. + void GetMessages(const nsAString& aPortId, nsTArray<MIDIMessage>& aMsgs); + + // Allows platform specific IO Threads to retrieve all messages to be sent + // before a certain timestamp. Handles mutex locking. + void GetMessagesBefore(const nsAString& aPortId, const TimeStamp& aTimeStamp, + nsTArray<MIDIMessage>& aMsgs); + + private: + // When the MIDIPlatformService is created, we need to know whether or not the + // corresponding IPC MIDIManager objects have received the MIDIPort list after + // it is populated. This is set to True when that is done, so we don't + // constantly spam MIDIManagers with port lists. + bool mHasSentPortList; + + // Array of MIDIManager IPC objects. This array manages the lifetime of + // MIDIManager objects in the parent process, and IPC will call + // RemoveManager() end lifetime when IPC channel is destroyed. + nsTArray<RefPtr<MIDIManagerParent>> mManagers; + + // Array of information for currently connected Ports + nsTArray<MIDIPortInfo> mPortInfo; + + // Array of MIDIPort IPC objects. May contain ports not listed in mPortInfo, + // as we can hold port objects even after they are disconnected. + // + // TODO Split this into input and output ports. Will make life easier. + nsTArray<RefPtr<MIDIPortParent>> mPorts; + + // Per-port message queue hashtable. Handles scheduling messages for sending. + nsClassHashtable<nsStringHashKey, MIDIMessageQueue> mMessageQueues; + + // Mutex for managing access to message queue objects. + Mutex mMessageQueueMutex MOZ_UNANNOTATED; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIPlatformService_h diff --git a/dom/midi/MIDIPort.cpp b/dom/midi/MIDIPort.cpp new file mode 100644 index 0000000000..7bdfd94343 --- /dev/null +++ b/dom/midi/MIDIPort.cpp @@ -0,0 +1,270 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPort.h" +#include "mozilla/dom/MIDIConnectionEvent.h" +#include "mozilla/dom/MIDIPortChild.h" +#include "mozilla/dom/MIDIAccess.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/ipc/Endpoint.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/Unused.h" +#include "nsContentUtils.h" +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, MOZ_COUNT_DTOR +#include "MIDILog.h" + +using namespace mozilla::ipc; + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(MIDIPort, DOMEventTargetHelper, + mOpeningPromise, mClosingPromise) + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(MIDIPort, DOMEventTargetHelper) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIPort) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_ADDREF_INHERITED(MIDIPort, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(MIDIPort, DOMEventTargetHelper) + +MIDIPort::MIDIPort(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent) + : DOMEventTargetHelper(aWindow), + mMIDIAccessParent(aMIDIAccessParent), + mKeepAlive(false) { + MOZ_ASSERT(aWindow); + MOZ_ASSERT(aMIDIAccessParent); + + Document* aDoc = GetOwner()->GetExtantDoc(); + if (aDoc) { + aDoc->DisallowBFCaching(); + } +} + +MIDIPort::~MIDIPort() { + if (mMIDIAccessParent) { + mMIDIAccessParent->RemovePortListener(this); + mMIDIAccessParent = nullptr; + } + if (Port()) { + // If the IPC port channel is still alive at this point, it means we're + // probably CC'ing this port object. Send the shutdown message to also clean + // up the IPC channel. + Port()->SendShutdown(); + } +} + +bool MIDIPort::Initialize(const MIDIPortInfo& aPortInfo, bool aSysexEnabled) { + nsIURI* uri = GetDocumentIfCurrent()->GetDocumentURI(); + nsAutoCString origin; + nsresult rv = nsContentUtils::GetASCIIOrigin(uri, origin); + if (NS_FAILED(rv)) { + return false; + } + RefPtr<MIDIPortChild> port = + new MIDIPortChild(aPortInfo, aSysexEnabled, this); + if (NS_FAILED(port->GenerateStableId(origin))) { + return false; + } + PBackgroundChild* b = BackgroundChild::GetForCurrentThread(); + MOZ_ASSERT(b, + "Should always have a valid BackgroundChild when creating a port " + "object!"); + + // Create the endpoints and bind the one on the child side. + Endpoint<PMIDIPortParent> parentEndpoint; + Endpoint<PMIDIPortChild> childEndpoint; + MOZ_ALWAYS_SUCCEEDS( + PMIDIPort::CreateEndpoints(&parentEndpoint, &childEndpoint)); + MOZ_ALWAYS_TRUE(childEndpoint.Bind(port)); + + if (!b->SendCreateMIDIPort(std::move(parentEndpoint), aPortInfo, + aSysexEnabled)) { + return false; + } + mPortHolder.Init(port.forget()); + LOG("MIDIPort::Initialize (%s, %s)", + NS_ConvertUTF16toUTF8(Port()->Name()).get(), + MIDIPortTypeValues::strings[uint32_t(Port()->Type())].value); + return true; +} + +void MIDIPort::UnsetIPCPort() { + LOG("MIDIPort::UnsetIPCPort (%s, %s)", + NS_ConvertUTF16toUTF8(Port()->Name()).get(), + MIDIPortTypeValues::strings[uint32_t(Port()->Type())].value); + mPortHolder.Clear(); +} + +void MIDIPort::GetId(nsString& aRetVal) const { + MOZ_ASSERT(Port()); + aRetVal = Port()->StableId(); +} + +void MIDIPort::GetManufacturer(nsString& aRetVal) const { + MOZ_ASSERT(Port()); + aRetVal = Port()->Manufacturer(); +} + +void MIDIPort::GetName(nsString& aRetVal) const { + MOZ_ASSERT(Port()); + aRetVal = Port()->Name(); +} + +void MIDIPort::GetVersion(nsString& aRetVal) const { + MOZ_ASSERT(Port()); + aRetVal = Port()->Version(); +} + +MIDIPortType MIDIPort::Type() const { + MOZ_ASSERT(Port()); + return Port()->Type(); +} + +MIDIPortConnectionState MIDIPort::Connection() const { + MOZ_ASSERT(Port()); + return Port()->ConnectionState(); +} + +MIDIPortDeviceState MIDIPort::State() const { + MOZ_ASSERT(Port()); + return Port()->DeviceState(); +} + +bool MIDIPort::SysexEnabled() const { + MOZ_ASSERT(Port()); + return Port()->SysexEnabled(); +} + +already_AddRefed<Promise> MIDIPort::Open(ErrorResult& aError) { + LOG("MIDIPort::Open"); + MOZ_ASSERT(Port()); + RefPtr<Promise> p; + if (mOpeningPromise) { + p = mOpeningPromise; + return p.forget(); + } + nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner()); + p = Promise::Create(go, aError); + if (aError.Failed()) { + return nullptr; + } + mOpeningPromise = p; + Port()->SendOpen(); + return p.forget(); +} + +already_AddRefed<Promise> MIDIPort::Close(ErrorResult& aError) { + LOG("MIDIPort::Close"); + MOZ_ASSERT(Port()); + RefPtr<Promise> p; + if (mClosingPromise) { + p = mClosingPromise; + return p.forget(); + } + nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner()); + p = Promise::Create(go, aError); + if (aError.Failed()) { + return nullptr; + } + mClosingPromise = p; + Port()->SendClose(); + return p.forget(); +} + +void MIDIPort::Notify(const void_t& aVoid) { + LOG("MIDIPort::notify MIDIAccess shutting down, dropping reference."); + // If we're getting notified, it means the MIDIAccess parent object is dead. + // Nullify our copy. + mMIDIAccessParent = nullptr; +} + +void MIDIPort::FireStateChangeEvent() { + if (!GetOwner()) { + return; // Ignore changes once we've been disconnected from the owner + } + + StateChange(); + + MOZ_ASSERT(Port()); + if (Port()->ConnectionState() == MIDIPortConnectionState::Open || + Port()->ConnectionState() == MIDIPortConnectionState::Pending) { + if (mOpeningPromise) { + mOpeningPromise->MaybeResolve(this); + mOpeningPromise = nullptr; + } + } else if (Port()->ConnectionState() == MIDIPortConnectionState::Closed) { + if (mOpeningPromise) { + mOpeningPromise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR); + mOpeningPromise = nullptr; + } + if (mClosingPromise) { + mClosingPromise->MaybeResolve(this); + mClosingPromise = nullptr; + } + } + + if (Port()->DeviceState() == MIDIPortDeviceState::Connected && + Port()->ConnectionState() == MIDIPortConnectionState::Pending) { + Port()->SendOpen(); + } + + if (Port()->ConnectionState() == MIDIPortConnectionState::Open || + (Port()->DeviceState() == MIDIPortDeviceState::Connected && + Port()->ConnectionState() == MIDIPortConnectionState::Pending)) { + KeepAliveOnStatechange(); + } else { + DontKeepAliveOnStatechange(); + } + + // Fire MIDIAccess events first so that the port is no longer in the port + // maps. + if (mMIDIAccessParent) { + mMIDIAccessParent->FireConnectionEvent(this); + } + + MIDIConnectionEventInit init; + init.mPort = this; + RefPtr<MIDIConnectionEvent> event( + MIDIConnectionEvent::Constructor(this, u"statechange"_ns, init)); + DispatchTrustedEvent(event); +} + +void MIDIPort::StateChange() {} + +void MIDIPort::Receive(const nsTArray<MIDIMessage>& aMsg) { + MOZ_CRASH("We should never get here!"); +} + +void MIDIPort::DisconnectFromOwner() { + DontKeepAliveOnStatechange(); + Port()->SendClose(); + + DOMEventTargetHelper::DisconnectFromOwner(); +} + +void MIDIPort::KeepAliveOnStatechange() { + if (!mKeepAlive) { + mKeepAlive = true; + KeepAliveIfHasListenersFor(nsGkAtoms::onstatechange); + } +} + +void MIDIPort::DontKeepAliveOnStatechange() { + if (mKeepAlive) { + IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onstatechange); + mKeepAlive = false; + } +} + +const nsString& MIDIPort::StableId() { return Port()->StableId(); } + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIPort.h b/dom/midi/MIDIPort.h new file mode 100644 index 0000000000..68a3aa0f34 --- /dev/null +++ b/dom/midi/MIDIPort.h @@ -0,0 +1,128 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPort_h +#define mozilla_dom_MIDIPort_h + +#include "nsWrapperCache.h" +#include "mozilla/Attributes.h" +#include "mozilla/Observer.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/dom/MIDIAccess.h" +#include "mozilla/dom/MIDIPortChild.h" +#include "mozilla/dom/MIDIPortInterface.h" + +struct JSContext; + +namespace mozilla::dom { + +class Promise; +class MIDIPortInfo; +class MIDIAccess; +class MIDIPortChangeEvent; +class MIDIPortChild; +class MIDIMessage; + +/** + * Implementation of WebIDL DOM MIDIPort class. Handles all port representation + * and communication. + * + */ +class MIDIPort : public DOMEventTargetHelper, + public MIDIAccessDestructionObserver { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MIDIPort, + DOMEventTargetHelper) + protected: + MIDIPort(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent); + bool Initialize(const MIDIPortInfo& aPortInfo, bool aSysexEnabled); + virtual ~MIDIPort(); + + public: + nsPIDOMWindowInner* GetParentObject() const { return GetOwner(); } + + // Getters + void GetId(nsString& aRetVal) const; + void GetManufacturer(nsString& aRetVal) const; + void GetName(nsString& aRetVal) const; + void GetVersion(nsString& aRetVal) const; + MIDIPortType Type() const; + MIDIPortConnectionState Connection() const; + MIDIPortDeviceState State() const; + bool SysexEnabled() const; + + already_AddRefed<Promise> Open(ErrorResult& aError); + already_AddRefed<Promise> Close(ErrorResult& aError); + + // MIDIPorts observe the death of their parent MIDIAccess object, and delete + // their reference accordingly. + virtual void Notify(const void_t& aVoid) override; + + void FireStateChangeEvent(); + + virtual void StateChange(); + virtual void Receive(const nsTArray<MIDIMessage>& aMsg); + + // This object holds a pointer to its corresponding IPC MIDIPortChild actor. + // If the IPC actor is deleted, it cleans itself up via this method. + void UnsetIPCPort(); + + IMPL_EVENT_HANDLER(statechange) + + void DisconnectFromOwner() override; + const nsString& StableId(); + + protected: + // Helper class to ensure we always call DetachOwner when we drop the + // reference to the the port. + class PortHolder { + public: + void Init(already_AddRefed<MIDIPortChild> aArg) { + MOZ_ASSERT(!mInner); + mInner = aArg; + } + void Clear() { + if (mInner) { + mInner->DetachOwner(); + mInner = nullptr; + } + } + ~PortHolder() { Clear(); } + MIDIPortChild* Get() const { return mInner; } + + private: + RefPtr<MIDIPortChild> mInner; + }; + + // IPC Actor corresponding to this class. + PortHolder mPortHolder; + MIDIPortChild* Port() const { return mPortHolder.Get(); } + + private: + void KeepAliveOnStatechange(); + void DontKeepAliveOnStatechange(); + + // MIDIAccess object that created this MIDIPort object, which we need for + // firing port connection events. There is a chance this MIDIPort object can + // outlive its parent MIDIAccess object, so this is a weak reference that must + // be handled properly. It is set on construction of the MIDIPort object, and + // set to null when the parent MIDIAccess object is destroyed, which fires an + // notification we observe. + MIDIAccess* mMIDIAccessParent; + // Promise object generated on Open() call, that needs to be resolved once the + // platform specific Open() function has completed. + RefPtr<Promise> mOpeningPromise; + // Promise object generated on Close() call, that needs to be resolved once + // the platform specific Close() function has completed. + RefPtr<Promise> mClosingPromise; + // If true this object will be kept alive even without direct JS references + bool mKeepAlive; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIPort_h diff --git a/dom/midi/MIDIPortChild.cpp b/dom/midi/MIDIPortChild.cpp new file mode 100644 index 0000000000..d649d5540e --- /dev/null +++ b/dom/midi/MIDIPortChild.cpp @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPortChild.h" +#include "mozilla/dom/MIDIPort.h" +#include "mozilla/dom/MIDIPortInterface.h" +#include "nsContentUtils.h" + +using namespace mozilla; +using namespace mozilla::dom; + +MIDIPortChild::MIDIPortChild(const MIDIPortInfo& aPortInfo, bool aSysexEnabled, + MIDIPort* aPort) + : MIDIPortInterface(aPortInfo, aSysexEnabled), mDOMPort(aPort) {} + +void MIDIPortChild::ActorDestroy(ActorDestroyReason aWhy) { + if (mDOMPort) { + mDOMPort->UnsetIPCPort(); + MOZ_ASSERT(!mDOMPort); + } + MIDIPortInterface::Shutdown(); +} + +mozilla::ipc::IPCResult MIDIPortChild::RecvReceive( + nsTArray<MIDIMessage>&& aMsgs) { + if (mDOMPort) { + mDOMPort->Receive(aMsgs); + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIPortChild::RecvUpdateStatus( + const uint32_t& aDeviceState, const uint32_t& aConnectionState) { + // Either a device is connected, and can have any connection state, or a + // device is disconnected, and can only be closed or pending. + MOZ_ASSERT(mDeviceState == MIDIPortDeviceState::Connected || + (mConnectionState == MIDIPortConnectionState::Closed || + mConnectionState == MIDIPortConnectionState::Pending)); + mDeviceState = static_cast<MIDIPortDeviceState>(aDeviceState); + mConnectionState = static_cast<MIDIPortConnectionState>(aConnectionState); + if (mDOMPort) { + mDOMPort->FireStateChangeEvent(); + } + return IPC_OK(); +} + +nsresult MIDIPortChild::GenerateStableId(const nsACString& aOrigin) { + const size_t kIdLength = 64; + mStableId.SetCapacity(kIdLength); + mStableId.Append(Name()); + mStableId.Append(Manufacturer()); + mStableId.Append(Version()); + nsContentUtils::AnonymizeId(mStableId, aOrigin, + nsContentUtils::OriginFormat::Plain); + return NS_OK; +} diff --git a/dom/midi/MIDIPortChild.h b/dom/midi/MIDIPortChild.h new file mode 100644 index 0000000000..2ef1059c78 --- /dev/null +++ b/dom/midi/MIDIPortChild.h @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPortChild_h +#define mozilla_dom_MIDIPortChild_h + +#include "mozilla/dom/MIDIPortInterface.h" +#include "mozilla/dom/PMIDIPortChild.h" + +namespace mozilla::dom { + +class MIDIPort; +class MIDIPortInfo; + +/** + * Child actor for a MIDIPort object. Each MIDIPort DOM object in JS has a its + * own child actor. The lifetime of the actor object is dependent on the + * lifetime of the JS object. + * + */ +class MIDIPortChild final : public PMIDIPortChild, public MIDIPortInterface { + public: + NS_INLINE_DECL_REFCOUNTING(MIDIPortChild, override); + mozilla::ipc::IPCResult RecvReceive(nsTArray<MIDIMessage>&& aMsgs); + + virtual void ActorDestroy(ActorDestroyReason aWhy) override; + + mozilla::ipc::IPCResult RecvUpdateStatus(const uint32_t& aDeviceState, + const uint32_t& aConnectionState); + + MIDIPortChild(const MIDIPortInfo& aPortInfo, bool aSysexEnabled, + MIDIPort* aPort); + nsresult GenerateStableId(const nsACString& aOrigin); + const nsString& StableId() { return mStableId; }; + + void DetachOwner() { mDOMPort = nullptr; } + + private: + ~MIDIPortChild() = default; + // Pointer to the DOM object this actor represents. The actor cannot outlive + // the DOM object. + MIDIPort* mDOMPort; + nsString mStableId; +}; +} // namespace mozilla::dom + +#endif diff --git a/dom/midi/MIDIPortInterface.cpp b/dom/midi/MIDIPortInterface.cpp new file mode 100644 index 0000000000..9d186fa3f4 --- /dev/null +++ b/dom/midi/MIDIPortInterface.cpp @@ -0,0 +1,26 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPortInterface.h" +#include "mozilla/dom/MIDIPlatformService.h" +#include "mozilla/dom/MIDITypes.h" + +mozilla::dom::MIDIPortInterface::MIDIPortInterface( + const MIDIPortInfo& aPortInfo, bool aSysexEnabled) + : mId(aPortInfo.id()), + mName(aPortInfo.name()), + mManufacturer(aPortInfo.manufacturer()), + mVersion(aPortInfo.version()), + mSysexEnabled(aSysexEnabled), + mType((MIDIPortType)aPortInfo.type()), + // We'll never initialize a port object that's not connected + mDeviceState(MIDIPortDeviceState::Connected), + mConnectionState(MIDIPortConnectionState::Closed), + mShuttingDown(false) {} + +mozilla::dom::MIDIPortInterface::~MIDIPortInterface() { Shutdown(); } + +void mozilla::dom::MIDIPortInterface::Shutdown() { mShuttingDown = true; } diff --git a/dom/midi/MIDIPortInterface.h b/dom/midi/MIDIPortInterface.h new file mode 100644 index 0000000000..360750e6e5 --- /dev/null +++ b/dom/midi/MIDIPortInterface.h @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPortInterface_h +#define mozilla_dom_MIDIPortInterface_h + +#include "mozilla/dom/MIDIPortBinding.h" + +namespace mozilla::dom { +class MIDIPortInfo; +/** + * Base class for MIDIPort Parent/Child Actors. Makes sure both sides of the + * MIDIPort IPC connection need to a synchronized set of info/state. + * + */ +class MIDIPortInterface { + public: + MIDIPortInterface(const MIDIPortInfo& aPortInfo, bool aSysexEnabled); + const nsString& Id() const { return mId; } + const nsString& Name() const { return mName; } + const nsString& Manufacturer() const { return mManufacturer; } + const nsString& Version() const { return mVersion; } + bool SysexEnabled() const { return mSysexEnabled; } + MIDIPortType Type() const { return mType; } + MIDIPortDeviceState DeviceState() const { return mDeviceState; } + MIDIPortConnectionState ConnectionState() const { return mConnectionState; } + bool IsShutdown() const { return mShuttingDown; } + virtual void Shutdown(); + + protected: + virtual ~MIDIPortInterface(); + nsString mId; + nsString mName; + nsString mManufacturer; + nsString mVersion; + bool mSysexEnabled; + MIDIPortType mType; + MIDIPortDeviceState mDeviceState; + MIDIPortConnectionState mConnectionState; + bool mShuttingDown; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_MIDIPortInterface_h diff --git a/dom/midi/MIDIPortParent.cpp b/dom/midi/MIDIPortParent.cpp new file mode 100644 index 0000000000..0a01784945 --- /dev/null +++ b/dom/midi/MIDIPortParent.cpp @@ -0,0 +1,106 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDIPortParent.h" +#include "mozilla/dom/MIDIPlatformService.h" +#include "nsContentUtils.h" + +// C++ file contents +namespace mozilla::dom { + +// Keep an internal ID that we can use for passing information about specific +// MIDI ports back and forth to the Rust libraries. +static uint32_t gId = 0; + +mozilla::ipc::IPCResult MIDIPortParent::RecvSend( + nsTArray<MIDIMessage>&& aMsgs) { + if (mConnectionState != MIDIPortConnectionState::Open) { + mMessageQueue.AppendElements(aMsgs); + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->Open(this); + } + return IPC_OK(); + } + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->QueueMessages(MIDIPortInterface::mId, aMsgs); + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIPortParent::RecvOpen() { + if (MIDIPlatformService::IsRunning() && + mConnectionState == MIDIPortConnectionState::Closed) { + MIDIPlatformService::Get()->Open(this); + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIPortParent::RecvClose() { + if (mConnectionState != MIDIPortConnectionState::Closed) { + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->Close(this); + } + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIPortParent::RecvClear() { + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->Clear(this); + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult MIDIPortParent::RecvShutdown() { + if (mShuttingDown) { + return IPC_OK(); + } + Close(); + return IPC_OK(); +} + +void MIDIPortParent::ActorDestroy(ActorDestroyReason) { + mMessageQueue.Clear(); + MIDIPortInterface::Shutdown(); + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->RemovePort(this); + } +} + +bool MIDIPortParent::SendUpdateStatus( + const MIDIPortDeviceState& aDeviceState, + const MIDIPortConnectionState& aConnectionState) { + if (mShuttingDown) { + return true; + } + mDeviceState = aDeviceState; + mConnectionState = aConnectionState; + if (aConnectionState == MIDIPortConnectionState::Open && + aDeviceState == MIDIPortDeviceState::Disconnected) { + mConnectionState = MIDIPortConnectionState::Pending; + } else if (aConnectionState == MIDIPortConnectionState::Open && + aDeviceState == MIDIPortDeviceState::Connected && + !mMessageQueue.IsEmpty()) { + if (MIDIPlatformService::IsRunning()) { + MIDIPlatformService::Get()->QueueMessages(MIDIPortInterface::mId, + mMessageQueue); + } + mMessageQueue.Clear(); + } + return PMIDIPortParent::SendUpdateStatus( + static_cast<uint32_t>(mDeviceState), + static_cast<uint32_t>(mConnectionState)); +} + +MIDIPortParent::MIDIPortParent(const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled) + : MIDIPortInterface(aPortInfo, aSysexEnabled), mInternalId(++gId) { + MOZ_ASSERT(MIDIPlatformService::IsRunning(), + "Shouldn't be able to add MIDI port without MIDI service!"); + MIDIPlatformService::Get()->AddPort(this); +} + +} // namespace mozilla::dom diff --git a/dom/midi/MIDIPortParent.h b/dom/midi/MIDIPortParent.h new file mode 100644 index 0000000000..527abddd00 --- /dev/null +++ b/dom/midi/MIDIPortParent.h @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_MIDIPortParent_h +#define mozilla_dom_MIDIPortParent_h + +#include "mozilla/dom/PMIDIPortParent.h" +#include "mozilla/dom/MIDIPortBinding.h" +#include "mozilla/dom/MIDIPortInterface.h" + +// Header file contents +namespace mozilla::dom { + +/** + * Actor representing the parent (PBackground thread) side of a MIDIPort object. + * + */ +class MIDIPortParent final : public PMIDIPortParent, public MIDIPortInterface { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MIDIPortParent, override); + void ActorDestroy(ActorDestroyReason) override; + mozilla::ipc::IPCResult RecvSend(nsTArray<MIDIMessage>&& aMsg); + mozilla::ipc::IPCResult RecvOpen(); + mozilla::ipc::IPCResult RecvClose(); + mozilla::ipc::IPCResult RecvClear(); + mozilla::ipc::IPCResult RecvShutdown(); + MOZ_IMPLICIT MIDIPortParent(const MIDIPortInfo& aPortInfo, + const bool aSysexEnabled); + // Sends the current port status to the child actor. May also send message + // buffer if required. + bool SendUpdateStatus(const MIDIPortDeviceState& aDeviceState, + const MIDIPortConnectionState& aConnectionState); + uint32_t GetInternalId() const { return mInternalId; } + + protected: + ~MIDIPortParent() = default; + // Queue of messages that needs to be sent. Since sending a message on a + // closed port opens it, we sometimes have to buffer messages from the time + // Send() is called until the time we get a device state change to Opened. + nsTArray<MIDIMessage> mMessageQueue; + const uint32_t mInternalId; +}; + +} // namespace mozilla::dom + +#endif diff --git a/dom/midi/MIDITypes.ipdlh b/dom/midi/MIDITypes.ipdlh new file mode 100644 index 0000000000..0508f171a8 --- /dev/null +++ b/dom/midi/MIDITypes.ipdlh @@ -0,0 +1,31 @@ +/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ +/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */ +/* 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/. */ + +using mozilla::TimeStamp from "mozilla/TimeStamp.h"; + +namespace mozilla { +namespace dom { + +[Comparable] struct MIDIPortInfo { + nsString id; + nsString name; + nsString manufacturer; + nsString version; + //Actually a MIDIPortType enum + uint32_t type; +}; + +struct MIDIMessage { + uint8_t[] data; + TimeStamp timestamp; +}; + +struct MIDIPortList { + MIDIPortInfo[] ports; +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/midi/MIDIUtils.cpp b/dom/midi/MIDIUtils.cpp new file mode 100644 index 0000000000..645889a167 --- /dev/null +++ b/dom/midi/MIDIUtils.cpp @@ -0,0 +1,172 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/MIDITypes.h" +#include "mozilla/dom/MIDIUtils.h" +#include "mozilla/UniquePtr.h" + +// Taken from MIDI IMPLEMENTATION CHART INSTRUCTIONS, MIDI Spec v1.0, Pg. 97 +static const uint8_t kCommandByte = 0x80; +static const uint8_t kSysexMessageStart = 0xF0; +static const uint8_t kSystemMessage = 0xF0; +static const uint8_t kSysexMessageEnd = 0xF7; +static const uint8_t kSystemRealtimeMessage = 0xF8; +// Represents the length of all possible command messages. +// Taken from MIDI Spec, Pg. 101v 1.0, Table 2 +static const uint8_t kCommandLengths[] = {3, 3, 3, 3, 2, 2, 3}; +// Represents the length of all possible system messages. The length of sysex +// messages is variable, so we just put zero since it won't be checked anyways. +// Taken from MIDI Spec v1.0, Pg. 105, Table 5 +static const uint8_t kSystemLengths[] = {0, 2, 3, 2, 1, 1, 1, 1}; +static const uint8_t kReservedStatuses[] = {0xf4, 0xf5, 0xf9, 0xfd}; + +namespace mozilla::dom::MIDIUtils { + +static bool IsSystemRealtimeMessage(uint8_t aByte) { + return (aByte & kSystemRealtimeMessage) == kSystemRealtimeMessage; +} + +static bool IsCommandByte(uint8_t aByte) { + return (aByte & kCommandByte) == kCommandByte; +} + +static bool IsReservedStatus(uint8_t aByte) { + for (const auto& msg : kReservedStatuses) { + if (aByte == msg) { + return true; + } + } + + return false; +} + +// Checks validity of MIDIMessage passed to it. Throws debug warnings and +// returns false if message is not valid. +bool IsValidMessage(const MIDIMessage* aMsg) { + if (aMsg->data().Length() == 0) { + return false; + } + + uint8_t cmd = aMsg->data()[0]; + // If first byte isn't a command, something is definitely wrong. + if (!IsCommandByte(cmd)) { + NS_WARNING("Constructed a MIDI packet where first byte is not command!"); + return false; + } + + if (IsReservedStatus(cmd)) { + NS_WARNING("Using a reserved message"); + return false; + } + + if (cmd == kSysexMessageStart) { + // All we can do with sysex is make sure it starts and ends with the + // correct command bytes and that it does not contain other command bytes. + if (aMsg->data()[aMsg->data().Length() - 1] != kSysexMessageEnd) { + NS_WARNING("Last byte of Sysex Message not 0xF7!"); + return false; + } + + for (size_t i = 1; i < aMsg->data().Length() - 2; i++) { + if (IsCommandByte(aMsg->data()[i])) { + return false; + } + } + + return true; + } + // For system realtime messages, the length should always be 1. + if (IsSystemRealtimeMessage(cmd)) { + return aMsg->data().Length() == 1; + } + // Otherwise, just use the correct array for testing lengths. We can't tell + // much about message validity other than that. + if ((cmd & kSystemMessage) == kSystemMessage) { + if (cmd - kSystemMessage >= + static_cast<uint8_t>(ArrayLength(kSystemLengths))) { + NS_WARNING("System Message Command byte not valid!"); + return false; + } + return aMsg->data().Length() == kSystemLengths[cmd - kSystemMessage]; + } + // For non system commands, we only care about differences in the high nibble + // of the first byte. Shift this down to give the index of the expected packet + // length. + uint8_t cmdIndex = (cmd - kCommandByte) >> 4; + if (cmdIndex >= ArrayLength(kCommandLengths)) { + // If our index is bigger than our array length, command byte is unknown; + NS_WARNING("Unknown MIDI command!"); + return false; + } + return aMsg->data().Length() == kCommandLengths[cmdIndex]; +} + +bool ParseMessages(const nsTArray<uint8_t>& aByteBuffer, + const TimeStamp& aTimestamp, + nsTArray<MIDIMessage>& aMsgArray) { + bool inSysexMessage = false; + UniquePtr<MIDIMessage> currentMsg = nullptr; + for (const auto& byte : aByteBuffer) { + if (IsSystemRealtimeMessage(byte)) { + MIDIMessage rt_msg; + rt_msg.data().AppendElement(byte); + rt_msg.timestamp() = aTimestamp; + if (!IsValidMessage(&rt_msg)) { + return false; + } + aMsgArray.AppendElement(rt_msg); + continue; + } + + if (byte == kSysexMessageEnd) { + if (!inSysexMessage) { + NS_WARNING( + "Got sysex message end with no sysex message being processed!"); + return false; + } + inSysexMessage = false; + } else if (IsCommandByte(byte)) { + if (currentMsg) { + if (!IsValidMessage(currentMsg.get())) { + return false; + } + + aMsgArray.AppendElement(*currentMsg); + } + + currentMsg = MakeUnique<MIDIMessage>(); + currentMsg->timestamp() = aTimestamp; + } + + if (!currentMsg) { + NS_WARNING("No command byte has been encountered yet!"); + return false; + } + + currentMsg->data().AppendElement(byte); + + if (byte == kSysexMessageStart) { + inSysexMessage = true; + } + } + + if (currentMsg) { + if (!IsValidMessage(currentMsg.get())) { + return false; + } + aMsgArray.AppendElement(*currentMsg); + } + + return true; +} + +bool IsSysexMessage(const MIDIMessage& aMsg) { + if (aMsg.data().Length() == 0) { + return false; + } + return aMsg.data()[0] == kSysexMessageStart; +} +} // namespace mozilla::dom::MIDIUtils diff --git a/dom/midi/MIDIUtils.h b/dom/midi/MIDIUtils.h new file mode 100644 index 0000000000..c5559dce7e --- /dev/null +++ b/dom/midi/MIDIUtils.h @@ -0,0 +1,27 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "nsTArray.h" +#include "mozilla/TimeStamp.h" + +namespace mozilla::dom { +class MIDIMessage; + +/** + * Set of utility functions for dealing with MIDI Messages. + * + */ +namespace MIDIUtils { + +// Takes a nsTArray of bytes and parses it into zero or more MIDI messages. +// Returns true if no errors were encountered, false otherwise. +bool ParseMessages(const nsTArray<uint8_t>& aByteBuffer, + const TimeStamp& aTimestamp, + nsTArray<MIDIMessage>& aMsgArray); +// Returns true if a message is a sysex message. +bool IsSysexMessage(const MIDIMessage& a); +} // namespace MIDIUtils +} // namespace mozilla::dom diff --git a/dom/midi/PMIDIManager.ipdl b/dom/midi/PMIDIManager.ipdl new file mode 100644 index 0000000000..75d0cb32ea --- /dev/null +++ b/dom/midi/PMIDIManager.ipdl @@ -0,0 +1,23 @@ +/* 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 MIDITypes; + +namespace mozilla { +namespace dom { + +async protocol PMIDIManager +{ +parent: + async Refresh(); + async Shutdown(); +child: + /* + * Send an updated list of MIDI ports to the child + */ + async MIDIPortListUpdate(MIDIPortList aPortList); +}; + +} // namespace ipc +} // namespace mozilla diff --git a/dom/midi/PMIDIPort.ipdl b/dom/midi/PMIDIPort.ipdl new file mode 100644 index 0000000000..fc8369a1b1 --- /dev/null +++ b/dom/midi/PMIDIPort.ipdl @@ -0,0 +1,28 @@ +/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */ +/* vim: set ts=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 MIDITypes; + +namespace mozilla { +namespace dom { + +async protocol PMIDIPort +{ +parent: + async Shutdown(); + async Send(MIDIMessage[] msg); + async Open(); + async Close(); + async Clear(); +child: + async Receive(MIDIMessage[] msg); + // Actually takes a MIDIDeviceConnectionState and MIDIPortConnectionState + // respectively. + async UpdateStatus(uint32_t deviceState, uint32_t connectionState); +}; + +} +} diff --git a/dom/midi/TestMIDIPlatformService.cpp b/dom/midi/TestMIDIPlatformService.cpp new file mode 100644 index 0000000000..cbc11a7474 --- /dev/null +++ b/dom/midi/TestMIDIPlatformService.cpp @@ -0,0 +1,258 @@ +/* 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 "TestMIDIPlatformService.h" +#include "mozilla/dom/MIDIPort.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/MIDIPortInterface.h" +#include "mozilla/dom/MIDIPortParent.h" +#include "mozilla/dom/MIDIPlatformRunnables.h" +#include "mozilla/dom/MIDIUtils.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/Unused.h" +#include "nsIThread.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +/** + * Runnable used for making sure ProcessMessages only happens on the IO thread. + * + */ +class ProcessMessagesRunnable : public mozilla::Runnable { + public: + explicit ProcessMessagesRunnable(const nsAString& aPortID) + : Runnable("ProcessMessagesRunnable"), mPortID(aPortID) {} + ~ProcessMessagesRunnable() = default; + NS_IMETHOD Run() override { + // If service is no longer running, just exist without processing. + if (!MIDIPlatformService::IsRunning()) { + return NS_OK; + } + TestMIDIPlatformService* srv = + static_cast<TestMIDIPlatformService*>(MIDIPlatformService::Get()); + srv->ProcessMessages(mPortID); + return NS_OK; + } + + private: + nsString mPortID; +}; + +/** + * Runnable used for allowing IO thread to queue more messages for processing, + * since it can't access the service object directly. + * + */ +class QueueMessagesRunnable : public MIDIBackgroundRunnable { + public: + QueueMessagesRunnable(const nsAString& aPortID, + const nsTArray<MIDIMessage>& aMsgs) + : MIDIBackgroundRunnable("QueueMessagesRunnable"), + mPortID(aPortID), + mMsgs(aMsgs.Clone()) {} + ~QueueMessagesRunnable() = default; + virtual void RunInternal() { + MIDIPlatformService::AssertThread(); + MIDIPlatformService::Get()->QueueMessages(mPortID, mMsgs); + } + + private: + nsString mPortID; + nsTArray<MIDIMessage> mMsgs; +}; + +TestMIDIPlatformService::TestMIDIPlatformService() + : mControlInputPort(u"b744eebe-f7d8-499b-872b-958f63c8f522"_ns, + u"Test Control MIDI Device Input Port"_ns, + u"Test Manufacturer"_ns, u"1.0.0"_ns, + static_cast<uint32_t>(MIDIPortType::Input)), + mControlOutputPort(u"ab8e7fe8-c4de-436a-a960-30898a7c9a3d"_ns, + u"Test Control MIDI Device Output Port"_ns, + u"Test Manufacturer"_ns, u"1.0.0"_ns, + static_cast<uint32_t>(MIDIPortType::Output)), + mStateTestInputPort(u"a9329677-8588-4460-a091-9d4a7f629a48"_ns, + u"Test State MIDI Device Input Port"_ns, + u"Test Manufacturer"_ns, u"1.0.0"_ns, + static_cast<uint32_t>(MIDIPortType::Input)), + mStateTestOutputPort(u"478fa225-b5fc-4fa6-a543-d32d9cb651e7"_ns, + u"Test State MIDI Device Output Port"_ns, + u"Test Manufacturer"_ns, u"1.0.0"_ns, + static_cast<uint32_t>(MIDIPortType::Output)), + mAlwaysClosedTestOutputPort(u"f87d0c76-3c68-49a9-a44f-700f1125c07a"_ns, + u"Always Closed MIDI Device Output Port"_ns, + u"Test Manufacturer"_ns, u"1.0.0"_ns, + static_cast<uint32_t>(MIDIPortType::Output)), + mDoRefresh(false), + mIsInitialized(false) { + MIDIPlatformService::AssertThread(); +} + +TestMIDIPlatformService::~TestMIDIPlatformService() { + MIDIPlatformService::AssertThread(); +} + +void TestMIDIPlatformService::Init() { + MIDIPlatformService::AssertThread(); + + if (mIsInitialized) { + return; + } + mIsInitialized = true; + + // Treat all of our special ports as always connected. When the service comes + // up, prepopulate the port list with them. + MIDIPlatformService::Get()->AddPortInfo(mControlInputPort); + MIDIPlatformService::Get()->AddPortInfo(mControlOutputPort); + MIDIPlatformService::Get()->AddPortInfo(mAlwaysClosedTestOutputPort); + MIDIPlatformService::Get()->AddPortInfo(mStateTestOutputPort); + nsCOMPtr<nsIRunnable> r(new SendPortListRunnable()); + + // Start the IO Thread. + OwnerThread()->Dispatch(r.forget()); +} + +void TestMIDIPlatformService::Refresh() { + if (mDoRefresh) { + AddPortInfo(mStateTestInputPort); + mDoRefresh = false; + } +} + +void TestMIDIPlatformService::Open(MIDIPortParent* aPort) { + MOZ_ASSERT(aPort); + MIDIPortConnectionState s = MIDIPortConnectionState::Open; + if (aPort->MIDIPortInterface::Id() == mAlwaysClosedTestOutputPort.id()) { + // If it's the always closed testing port, act like it's already opened + // exclusively elsewhere. + s = MIDIPortConnectionState::Closed; + } + // Connection events are just simulated on the background thread, no need to + // push to IO thread. + nsCOMPtr<nsIRunnable> r( + new SetStatusRunnable(aPort, aPort->DeviceState(), s)); + OwnerThread()->Dispatch(r.forget()); +} + +void TestMIDIPlatformService::ScheduleClose(MIDIPortParent* aPort) { + AssertThread(); + MOZ_ASSERT(aPort); + if (aPort->ConnectionState() == MIDIPortConnectionState::Open) { + // Connection events are just simulated on the background thread, no need to + // push to IO thread. + nsCOMPtr<nsIRunnable> r(new SetStatusRunnable( + aPort, aPort->DeviceState(), MIDIPortConnectionState::Closed)); + OwnerThread()->Dispatch(r.forget()); + } +} + +void TestMIDIPlatformService::Stop() { MIDIPlatformService::AssertThread(); } + +void TestMIDIPlatformService::ScheduleSend(const nsAString& aPortId) { + AssertThread(); + nsCOMPtr<nsIRunnable> r(new ProcessMessagesRunnable(aPortId)); + OwnerThread()->Dispatch(r.forget()); +} + +void TestMIDIPlatformService::ProcessMessages(const nsAString& aPortId) { + nsTArray<MIDIMessage> msgs; + GetMessagesBefore(aPortId, TimeStamp::Now(), msgs); + + for (MIDIMessage msg : msgs) { + // receiving message from test control port + if (aPortId == mControlOutputPort.id()) { + switch (msg.data()[0]) { + // Hit a note, get a test! + case 0x90: + switch (msg.data()[1]) { + // Echo data/timestamp back through output port + case 0x00: { + nsCOMPtr<nsIRunnable> r( + new ReceiveRunnable(mControlInputPort.id(), msg)); + OwnerThread()->Dispatch(r, NS_DISPATCH_NORMAL); + break; + } + // Cause control test ports to connect + case 0x01: { + nsCOMPtr<nsIRunnable> r1( + new AddPortRunnable(mStateTestInputPort)); + OwnerThread()->Dispatch(r1, NS_DISPATCH_NORMAL); + break; + } + // Cause control test ports to disconnect + case 0x02: { + nsCOMPtr<nsIRunnable> r1( + new RemovePortRunnable(mStateTestInputPort)); + OwnerThread()->Dispatch(r1, NS_DISPATCH_NORMAL); + break; + } + // Test for packet timing + case 0x03: { + // Append a few echo command packets in reverse timing order, + // should come out in correct order on other end. + nsTArray<MIDIMessage> newMsgs; + nsTArray<uint8_t> msg; + msg.AppendElement(0x90); + msg.AppendElement(0x00); + msg.AppendElement(0x00); + // PR_Now() returns nanosecods, and we need a double with + // fractional milliseconds. + TimeStamp currentTime = TimeStamp::Now(); + for (int i = 0; i <= 5; ++i) { + // Insert messages with timestamps in reverse order, to make + // sure we're sorting correctly. + newMsgs.AppendElement(MIDIMessage( + msg, currentTime - TimeDuration::FromMilliseconds(i * 2))); + } + nsCOMPtr<nsIRunnable> r( + new QueueMessagesRunnable(aPortId, newMsgs)); + OwnerThread()->Dispatch(r, NS_DISPATCH_NORMAL); + break; + } + // Causes the next refresh to add new ports to the list + case 0x04: { + mDoRefresh = true; + break; + } + default: + NS_WARNING("Unknown Test MIDI message received!"); + } + break; + // Sysex tests + case 0xF0: + switch (msg.data()[1]) { + // Echo data/timestamp back through output port + case 0x00: { + nsCOMPtr<nsIRunnable> r( + new ReceiveRunnable(mControlInputPort.id(), msg)); + OwnerThread()->Dispatch(r, NS_DISPATCH_NORMAL); + break; + } + // Test for system real time messages in the middle of sysex + // messages. + case 0x01: { + nsTArray<uint8_t> msgs; + const uint8_t msg[] = {0xF0, 0x01, 0xFA, 0x02, 0x03, + 0x04, 0xF8, 0x05, 0xF7}; + // Can't use AppendElements on an array here, so just do range + // based loading. + for (const auto& s : msg) { + msgs.AppendElement(s); + } + nsTArray<MIDIMessage> newMsgs; + MIDIUtils::ParseMessages(msgs, TimeStamp::Now(), newMsgs); + nsCOMPtr<nsIRunnable> r( + new ReceiveRunnable(mControlInputPort.id(), newMsgs)); + OwnerThread()->Dispatch(r, NS_DISPATCH_NORMAL); + break; + } + default: + NS_WARNING("Unknown Test Sysex MIDI message received!"); + } + break; + } + } + } +} diff --git a/dom/midi/TestMIDIPlatformService.h b/dom/midi/TestMIDIPlatformService.h new file mode 100644 index 0000000000..29423a02a4 --- /dev/null +++ b/dom/midi/TestMIDIPlatformService.h @@ -0,0 +1,61 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_TestMIDIPlatformService_h +#define mozilla_dom_TestMIDIPlatformService_h + +#include "mozilla/dom/MIDIPlatformService.h" +#include "mozilla/dom/MIDITypes.h" + +class nsIThread; + +namespace mozilla::dom { + +class MIDIPortInterface; + +/** + * Platform service implementation used for mochitests. Emulates what a real + * platform service should look like, including using an internal IO thread for + * message IO. + * + */ +class TestMIDIPlatformService : public MIDIPlatformService { + public: + TestMIDIPlatformService(); + virtual void Init() override; + virtual void Refresh() override; + virtual void Open(MIDIPortParent* aPort) override; + virtual void Stop() override; + virtual void ScheduleSend(const nsAString& aPort) override; + virtual void ScheduleClose(MIDIPortParent* aPort) override; + // MIDI Service simulation function. Can take specially formed sysex messages + // in order to trigger device connection events and state changes, + // interrupting messages for high priority sysex sends, etc... + void ProcessMessages(const nsAString& aPort); + + private: + virtual ~TestMIDIPlatformService(); + // Port that takes test control messages + MIDIPortInfo mControlInputPort; + // Port that returns test status messages + MIDIPortInfo mControlOutputPort; + // Used for testing input connection/disconnection + MIDIPortInfo mStateTestInputPort; + // Used for testing output connection/disconnection + MIDIPortInfo mStateTestOutputPort; + // Used for testing open() call failures + MIDIPortInfo mAlwaysClosedTestOutputPort; + // IO Simulation thread. Runs all instances of ProcessMessages(). + nsCOMPtr<nsIThread> mClientThread; + // When true calling Refresh() will add new ports. + bool mDoRefresh; + // True if server has been brought up already. + bool mIsInitialized; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_TestMIDIPlatformService_h diff --git a/dom/midi/midirMIDIPlatformService.cpp b/dom/midi/midirMIDIPlatformService.cpp new file mode 100644 index 0000000000..842eb51dcd --- /dev/null +++ b/dom/midi/midirMIDIPlatformService.cpp @@ -0,0 +1,193 @@ +/* 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 "midirMIDIPlatformService.h" +#include "mozilla/StaticMutex.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/MIDIPort.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/MIDIPortInterface.h" +#include "mozilla/dom/MIDIPortParent.h" +#include "mozilla/dom/MIDIPlatformRunnables.h" +#include "mozilla/dom/MIDIUtils.h" +#include "mozilla/dom/midi/midir_impl_ffi_generated.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/Unused.h" +#include "nsIThread.h" +#include "mozilla/Logging.h" +#include "MIDILog.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +static_assert(sizeof(TimeStamp) == sizeof(GeckoTimeStamp)); + +/** + * Runnable used for to send messages asynchronously on the I/O thread. + */ +class SendRunnable : public MIDIBackgroundRunnable { + public: + explicit SendRunnable(const nsAString& aPortID, const MIDIMessage& aMessage) + : MIDIBackgroundRunnable("SendRunnable"), + mPortID(aPortID), + mMessage(aMessage) {} + ~SendRunnable() = default; + virtual void RunInternal() { + MIDIPlatformService::AssertThread(); + if (!MIDIPlatformService::IsRunning()) { + // Some send operations might outlive the service, bail out and do nothing + return; + } + midirMIDIPlatformService* srv = + static_cast<midirMIDIPlatformService*>(MIDIPlatformService::Get()); + srv->SendMessage(mPortID, mMessage); + } + + private: + nsString mPortID; + MIDIMessage mMessage; +}; + +// static +StaticMutex midirMIDIPlatformService::gOwnerThreadMutex; + +// static +nsCOMPtr<nsISerialEventTarget> midirMIDIPlatformService::gOwnerThread; + +midirMIDIPlatformService::midirMIDIPlatformService() + : mImplementation(nullptr) { + StaticMutexAutoLock lock(gOwnerThreadMutex); + gOwnerThread = OwnerThread(); +} + +midirMIDIPlatformService::~midirMIDIPlatformService() { + LOG("midir_impl_shutdown"); + if (mImplementation) { + midir_impl_shutdown(mImplementation); + } + StaticMutexAutoLock lock(gOwnerThreadMutex); + gOwnerThread = nullptr; +} + +// static +void midirMIDIPlatformService::AddPort(const nsString* aId, + const nsString* aName, bool aInput) { + MIDIPortType type = aInput ? MIDIPortType::Input : MIDIPortType::Output; + MIDIPortInfo port(*aId, *aName, u""_ns, u""_ns, static_cast<uint32_t>(type)); + MIDIPlatformService::Get()->AddPortInfo(port); +} + +// static +void midirMIDIPlatformService::RemovePort(const nsString* aId, + const nsString* aName, bool aInput) { + MIDIPortType type = aInput ? MIDIPortType::Input : MIDIPortType::Output; + MIDIPortInfo port(*aId, *aName, u""_ns, u""_ns, static_cast<uint32_t>(type)); + MIDIPlatformService::Get()->RemovePortInfo(port); +} + +void midirMIDIPlatformService::Init() { + if (mImplementation) { + return; + } + + mImplementation = midir_impl_init(AddPort); + + if (mImplementation) { + MIDIPlatformService::Get()->SendPortList(); + } else { + LOG("midir_impl_init failure"); + } +} + +// static +void midirMIDIPlatformService::CheckAndReceive(const nsString* aId, + const uint8_t* aData, + size_t aLength, + const GeckoTimeStamp* aTimeStamp, + uint64_t aMicros) { + nsTArray<uint8_t> data; + data.AppendElements(aData, aLength); + const TimeStamp* openTime = reinterpret_cast<const TimeStamp*>(aTimeStamp); + TimeStamp timestamp = + *openTime + TimeDuration::FromMicroseconds(static_cast<double>(aMicros)); + MIDIMessage message(data, timestamp); + LogMIDIMessage(message, *aId, MIDIPortType::Input); + nsTArray<MIDIMessage> messages; + messages.AppendElement(message); + + nsCOMPtr<nsIRunnable> r(new ReceiveRunnable(*aId, messages)); + StaticMutexAutoLock lock(gOwnerThreadMutex); + if (gOwnerThread) { + gOwnerThread->Dispatch(r, NS_DISPATCH_NORMAL); + } +} + +void midirMIDIPlatformService::Refresh() { + midir_impl_refresh(mImplementation, AddPort, RemovePort); +} + +void midirMIDIPlatformService::Open(MIDIPortParent* aPort) { + AssertThread(); + MOZ_ASSERT(aPort); + nsString id = aPort->MIDIPortInterface::Id(); + TimeStamp openTimeStamp = TimeStamp::Now(); + if (midir_impl_open_port(mImplementation, &id, + reinterpret_cast<GeckoTimeStamp*>(&openTimeStamp), + CheckAndReceive)) { + LOG("MIDI port open: %s at t=%lf", NS_ConvertUTF16toUTF8(id).get(), + (openTimeStamp - TimeStamp::ProcessCreation()).ToSeconds()); + nsCOMPtr<nsIRunnable> r(new SetStatusRunnable( + aPort, aPort->DeviceState(), MIDIPortConnectionState::Open)); + OwnerThread()->Dispatch(r.forget()); + } else { + LOG("MIDI port open failed: %s", NS_ConvertUTF16toUTF8(id).get()); + } +} + +void midirMIDIPlatformService::Stop() { + // Nothing to do here AFAIK +} + +void midirMIDIPlatformService::ScheduleSend(const nsAString& aPortId) { + AssertThread(); + LOG("MIDI port schedule send %s", NS_ConvertUTF16toUTF8(aPortId).get()); + nsTArray<MIDIMessage> messages; + GetMessages(aPortId, messages); + TimeStamp now = TimeStamp::Now(); + for (const auto& message : messages) { + if (message.timestamp().IsNull()) { + SendMessage(aPortId, message); + } else { + double delay = (message.timestamp() - now).ToMilliseconds(); + if (delay < 1.0) { + SendMessage(aPortId, message); + } else { + nsCOMPtr<nsIRunnable> r(new SendRunnable(aPortId, message)); + OwnerThread()->DelayedDispatch(r.forget(), + static_cast<uint32_t>(delay)); + } + } + } +} + +void midirMIDIPlatformService::ScheduleClose(MIDIPortParent* aPort) { + AssertThread(); + MOZ_ASSERT(aPort); + nsString id = aPort->MIDIPortInterface::Id(); + LOG("MIDI port schedule close %s", NS_ConvertUTF16toUTF8(id).get()); + if (aPort->ConnectionState() == MIDIPortConnectionState::Open) { + midir_impl_close_port(mImplementation, &id); + nsCOMPtr<nsIRunnable> r(new SetStatusRunnable( + aPort, aPort->DeviceState(), MIDIPortConnectionState::Closed)); + OwnerThread()->Dispatch(r.forget()); + } +} + +void midirMIDIPlatformService::SendMessage(const nsAString& aPortId, + const MIDIMessage& aMessage) { + LOG("MIDI send message on %s", NS_ConvertUTF16toUTF8(aPortId).get()); + LogMIDIMessage(aMessage, aPortId, MIDIPortType::Output); + midir_impl_send(mImplementation, &aPortId, &aMessage.data()); +} diff --git a/dom/midi/midirMIDIPlatformService.h b/dom/midi/midirMIDIPlatformService.h new file mode 100644 index 0000000000..e204b5576a --- /dev/null +++ b/dom/midi/midirMIDIPlatformService.h @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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_dom_midirMIDIPlatformService_h +#define mozilla_dom_midirMIDIPlatformService_h + +#include "mozilla/StaticMutex.h" +#include "mozilla/dom/MIDIPlatformService.h" +#include "mozilla/dom/MIDITypes.h" +#include "mozilla/dom/midi/midir_impl_ffi_generated.h" + +class nsIThread; +struct MidirWrapper; + +namespace mozilla::dom { + +class MIDIPortInterface; + +/** + * Platform service implementation using the midir crate. + */ +class midirMIDIPlatformService : public MIDIPlatformService { + public: + midirMIDIPlatformService(); + virtual void Init() override; + virtual void Refresh() override; + virtual void Open(MIDIPortParent* aPort) override; + virtual void Stop() override; + virtual void ScheduleSend(const nsAString& aPort) override; + virtual void ScheduleClose(MIDIPortParent* aPort) override; + + void SendMessage(const nsAString& aPort, const MIDIMessage& aMessage); + + private: + virtual ~midirMIDIPlatformService(); + + static void AddPort(const nsString* aId, const nsString* aName, bool aInput); + static void RemovePort(const nsString* aId, const nsString* aName, + bool aInput); + static void CheckAndReceive(const nsString* aId, const uint8_t* aData, + size_t aLength, const GeckoTimeStamp* aTimeStamp, + uint64_t aMicros); + + // Wrapper around the midir Rust implementation. + MidirWrapper* mImplementation; + + // The midir backends can invoke CheckAndReceive on arbitrary background + // threads, and so we dispatch events from there to the owner task queue. + // It's a little ambiguous whether midir can ever invoke CheckAndReceive + // on one of its platform-specific background threads after we've dropped + // the main instance. Just in case, we use a static mutex to avoid a potential + // race with dropping the primary reference to the task queue via + // ClearOnShutdown. + static StaticMutex gOwnerThreadMutex; + static nsCOMPtr<nsISerialEventTarget> gOwnerThread + MOZ_GUARDED_BY(gOwnerThreadMutex); +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_midirMIDIPlatformService_h diff --git a/dom/midi/midir_impl/Cargo.toml b/dom/midi/midir_impl/Cargo.toml new file mode 100644 index 0000000000..1e6d4030bf --- /dev/null +++ b/dom/midi/midir_impl/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "midir_impl" +version = "0.1.0" +authors = ["Gabriele Svelto"] +edition = "2018" +license = "MPL-2.0" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +midir = "0.7.0" +nsstring = { path = "../../../xpcom/rust/nsstring/" } +uuid = { version = "1.0", features = ["v4"] } +thin-vec = { version = "0.2.1", features = ["gecko-ffi"] } diff --git a/dom/midi/midir_impl/cbindgen.toml b/dom/midi/midir_impl/cbindgen.toml new file mode 100644 index 0000000000..1b80a85e45 --- /dev/null +++ b/dom/midi/midir_impl/cbindgen.toml @@ -0,0 +1,18 @@ +header = """/* 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/. */""" +autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen. See RunCbindgen.py */ +""" +include_version = true +braces = "SameLine" +line_length = 100 +tab_width = 2 +language = "C++" +include_guard = "midir_impl_ffi_generated_h" +includes = ["nsStringFwd.h", "nsTArrayForwardDeclare.h"] + +[defines] +"target_os = windows" = "XP_WIN" + +[export.rename] +"ThinVec" = "nsTArray" diff --git a/dom/midi/midir_impl/moz.build b/dom/midi/midir_impl/moz.build new file mode 100644 index 0000000000..f079022906 --- /dev/null +++ b/dom/midi/midir_impl/moz.build @@ -0,0 +1,17 @@ +# -*- 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/. + +if CONFIG["COMPILE_ENVIRONMENT"]: + # This tells mach to run cbindgen and that this header-file should be created + CbindgenHeader( + "midir_impl_ffi_generated.h", + inputs=["/dom/midi/midir_impl"], + ) + + # This tells mach to copy that generated file to obj/dist/includes/mozilla/dom/midi + EXPORTS.mozilla.dom.midi += [ + "!midir_impl_ffi_generated.h", + ] diff --git a/dom/midi/midir_impl/src/lib.rs b/dom/midi/midir_impl/src/lib.rs new file mode 100644 index 0000000000..de47fbeb11 --- /dev/null +++ b/dom/midi/midir_impl/src/lib.rs @@ -0,0 +1,418 @@ +extern crate thin_vec; + +use midir::{ + InitError, MidiInput, MidiInputConnection, MidiInputPort, MidiOutput, MidiOutputConnection, + MidiOutputPort, +}; +use nsstring::{nsAString, nsString}; +use std::boxed::Box; +use std::ptr; +use thin_vec::ThinVec; +use uuid::Uuid; + +/* 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/. */ +extern crate midir; + +#[cfg(target_os = "windows")] +#[repr(C)] +#[derive(Clone, Copy)] +pub struct GeckoTimeStamp { + gtc: u64, + qpc: u64, + + is_null: u8, + has_qpc: u8, +} + +#[cfg(not(target_os = "windows"))] +#[repr(C)] +#[derive(Clone, Copy)] +pub struct GeckoTimeStamp { + value: u64, +} + +enum MidiConnection { + Input(MidiInputConnection<CallbackData>), + Output(MidiOutputConnection), +} + +struct MidiConnectionWrapper { + id: String, + connection: MidiConnection, +} + +enum MidiPort { + Input(MidiInputPort), + Output(MidiOutputPort), +} + +struct MidiPortWrapper { + id: String, + name: String, + port: MidiPort, + open_count: u32, +} + +impl MidiPortWrapper { + fn input(self: &MidiPortWrapper) -> bool { + match self.port { + MidiPort::Input(_) => true, + MidiPort::Output(_) => false, + } + } +} + +pub struct MidirWrapper { + ports: Vec<MidiPortWrapper>, + connections: Vec<MidiConnectionWrapper>, +} + +struct CallbackData { + nsid: nsString, + open_timestamp: GeckoTimeStamp, +} + +type AddCallback = unsafe extern "C" fn(id: &nsString, name: &nsString, input: bool); +type RemoveCallback = AddCallback; + +impl MidirWrapper { + fn refresh( + self: &mut MidirWrapper, + add_callback: AddCallback, + remove_callback: Option<RemoveCallback>, + ) { + if let Ok(ports) = collect_ports() { + if let Some(remove_callback) = remove_callback { + self.remove_missing_ports(&ports, remove_callback); + } + + self.add_new_ports(ports, add_callback); + } + } + + fn remove_missing_ports( + self: &mut MidirWrapper, + ports: &Vec<MidiPortWrapper>, + remove_callback: RemoveCallback, + ) { + let old_ports = &mut self.ports; + let mut i = 0; + while i < old_ports.len() { + if !ports + .iter() + .any(|p| p.name == old_ports[i].name && p.input() == old_ports[i].input()) + { + let port = old_ports.remove(i); + let id = nsString::from(&port.id); + let name = nsString::from(&port.name); + unsafe { remove_callback(&id, &name, port.input()) }; + } else { + i += 1; + } + } + } + + fn add_new_ports( + self: &mut MidirWrapper, + ports: Vec<MidiPortWrapper>, + add_callback: AddCallback, + ) { + for port in ports { + if !self.is_port_present(&port) && !Self::is_microsoft_synth_output(&port) { + let id = nsString::from(&port.id); + let name = nsString::from(&port.name); + unsafe { add_callback(&id, &name, port.input()) }; + self.ports.push(port); + } + } + } + + fn is_port_present(self: &MidirWrapper, port: &MidiPortWrapper) -> bool { + self.ports + .iter() + .any(|p| p.name == port.name && p.input() == port.input()) + } + + // We explicitly disable Microsoft's soft synthesizer, see bug 1798097 + fn is_microsoft_synth_output(port: &MidiPortWrapper) -> bool { + (port.input() == false) && (port.name == "Microsoft GS Wavetable Synth") + } + + fn open_port( + self: &mut MidirWrapper, + nsid: &nsString, + timestamp: GeckoTimeStamp, + callback: unsafe extern "C" fn( + id: &nsString, + data: *const u8, + length: usize, + timestamp: &GeckoTimeStamp, + micros: u64, + ), + ) -> Result<(), ()> { + let id = nsid.to_string(); + let connections = &mut self.connections; + let port = self.ports.iter_mut().find(|e| e.id.eq(&id)); + if let Some(port) = port { + if port.open_count == 0 { + let connection = match &port.port { + MidiPort::Input(port) => { + let input = MidiInput::new("WebMIDI input").map_err(|_err| ())?; + let data = CallbackData { + nsid: nsid.clone(), + open_timestamp: timestamp, + }; + let connection = input + .connect( + port, + "Input connection", + move |stamp, message, data| unsafe { + callback( + &data.nsid, + message.as_ptr(), + message.len(), + &data.open_timestamp, + stamp, + ); + }, + data, + ) + .map_err(|_err| ())?; + MidiConnectionWrapper { + id: id.clone(), + connection: MidiConnection::Input(connection), + } + } + MidiPort::Output(port) => { + let output = MidiOutput::new("WebMIDI output").map_err(|_err| ())?; + let connection = output + .connect(port, "Output connection") + .map_err(|_err| ())?; + MidiConnectionWrapper { + connection: MidiConnection::Output(connection), + id: id.clone(), + } + } + }; + + connections.push(connection); + } + + port.open_count += 1; + return Ok(()); + } + + Err(()) + } + + fn close_port(self: &mut MidirWrapper, id: &str) { + let port = self.ports.iter_mut().find(|e| e.id.eq(&id)).unwrap(); + port.open_count -= 1; + + if port.open_count > 0 { + return; + } + + let connections = &mut self.connections; + let index = connections.iter().position(|e| e.id.eq(id)).unwrap(); + let connection_wrapper = connections.remove(index); + + match connection_wrapper.connection { + MidiConnection::Input(connection) => { + connection.close(); + } + MidiConnection::Output(connection) => { + connection.close(); + } + } + } + + fn send(self: &mut MidirWrapper, id: &str, data: &[u8]) -> Result<(), ()> { + let connections = &mut self.connections; + let index = connections.iter().position(|e| e.id.eq(id)).ok_or(())?; + let connection_wrapper = connections.get_mut(index).unwrap(); + + match &mut connection_wrapper.connection { + MidiConnection::Output(connection) => { + connection.send(data).map_err(|_err| ())?; + } + _ => { + panic!("Sending on an input port!"); + } + } + + Ok(()) + } +} + +fn collect_ports() -> Result<Vec<MidiPortWrapper>, InitError> { + let input = MidiInput::new("WebMIDI input")?; + let output = MidiOutput::new("WebMIDI output")?; + let mut ports = Vec::<MidiPortWrapper>::new(); + collect_input_ports(&input, &mut ports); + collect_output_ports(&output, &mut ports); + Ok(ports) +} + +impl MidirWrapper { + fn new() -> Result<MidirWrapper, InitError> { + let ports = Vec::new(); + let connections: Vec<MidiConnectionWrapper> = Vec::new(); + Ok(MidirWrapper { ports, connections }) + } +} + +/// Create the C++ wrapper that will be used to talk with midir. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// This function deliberately leaks the wrapper because ownership is +/// transfered to the C++ code. Use [midir_impl_shutdown()] to free it. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_init(callback: AddCallback) -> *mut MidirWrapper { + if let Ok(mut midir_impl) = MidirWrapper::new() { + midir_impl.refresh(callback, None); + + // Gecko invokes this initialization on a separate thread from all the + // other operations, so make it clear to Rust this needs to be Send. + fn assert_send<T: Send>(_: &T) {} + assert_send(&midir_impl); + + let midir_box = Box::new(midir_impl); + // Leak the object as it will be owned by the C++ code from now on + Box::leak(midir_box) as *mut _ + } else { + ptr::null_mut() + } +} + +/// Refresh the list of ports. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// `wrapper` must be the pointer returned by [midir_impl_init()]. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_refresh( + wrapper: *mut MidirWrapper, + add_callback: AddCallback, + remove_callback: RemoveCallback, +) { + (*wrapper).refresh(add_callback, Some(remove_callback)) +} + +/// Shutdown midir and free the C++ wrapper. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// `wrapper` must be the pointer returned by [midir_impl_init()]. After this +/// has been called the wrapper object will be destoyed and cannot be accessed +/// anymore. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_shutdown(wrapper: *mut MidirWrapper) { + // The MidirImpl object will be automatically destroyed when the contents + // of this box are automatically dropped at the end of the function + let _midir_box = Box::from_raw(wrapper); +} + +/// Open a MIDI port. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// `wrapper` must be the pointer returned by [midir_impl_init()]. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_open_port( + wrapper: *mut MidirWrapper, + nsid: *mut nsString, + timestamp: *mut GeckoTimeStamp, + callback: unsafe extern "C" fn( + id: &nsString, + data: *const u8, + length: usize, + timestamp: &GeckoTimeStamp, + micros: u64, + ), +) -> bool { + (*wrapper) + .open_port(nsid.as_ref().unwrap(), *timestamp, callback) + .is_ok() +} + +/// Close a MIDI port. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// `wrapper` must be the pointer returned by [midir_impl_init()]. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_close_port(wrapper: *mut MidirWrapper, id: *mut nsString) { + (*wrapper).close_port(&(*id).to_string()); +} + +/// Send a message over a MIDI output port. +/// +/// This function will be exposed to C++ +/// +/// # Safety +/// +/// `wrapper` must be the pointer returned by [midir_impl_init()]. +#[no_mangle] +pub unsafe extern "C" fn midir_impl_send( + wrapper: *mut MidirWrapper, + id: *const nsAString, + data: *const ThinVec<u8>, +) -> bool { + (*wrapper) + .send(&(*id).to_string(), (*data).as_slice()) + .is_ok() +} + +fn collect_input_ports(input: &MidiInput, wrappers: &mut Vec<MidiPortWrapper>) { + let ports = input.ports(); + for port in ports { + let id = Uuid::new_v4() + .as_hyphenated() + .encode_lower(&mut Uuid::encode_buffer()) + .to_owned(); + let name = input + .port_name(&port) + .unwrap_or_else(|_| "unknown input port".to_string()); + let port = MidiPortWrapper { + id, + name, + port: MidiPort::Input(port), + open_count: 0, + }; + wrappers.push(port); + } +} + +fn collect_output_ports(output: &MidiOutput, wrappers: &mut Vec<MidiPortWrapper>) { + let ports = output.ports(); + for port in ports { + let id = Uuid::new_v4() + .as_hyphenated() + .encode_lower(&mut Uuid::encode_buffer()) + .to_owned(); + let name = output + .port_name(&port) + .unwrap_or_else(|_| "unknown input port".to_string()); + let port = MidiPortWrapper { + id, + name, + port: MidiPort::Output(port), + open_count: 0, + }; + wrappers.push(port); + } +} diff --git a/dom/midi/moz.build b/dom/midi/moz.build new file mode 100644 index 0000000000..81c484d290 --- /dev/null +++ b/dom/midi/moz.build @@ -0,0 +1,76 @@ +# -*- Mode: python; c-basic-offset: 4; 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/. + +IPDL_SOURCES += [ + "MIDITypes.ipdlh", + "PMIDIManager.ipdl", + "PMIDIPort.ipdl", +] + +EXPORTS.mozilla.dom += [ + "MIDIAccess.h", + "MIDIAccessManager.h", + "MIDIInput.h", + "MIDIInputMap.h", + "MIDIManagerChild.h", + "MIDIManagerParent.h", + "MIDIMessageEvent.h", + "MIDIMessageQueue.h", + "MIDIOutput.h", + "MIDIOutputMap.h", + "MIDIPermissionRequest.h", + "MIDIPlatformRunnables.h", + "MIDIPlatformService.h", + "MIDIPort.h", + "MIDIPortChild.h", + "MIDIPortInterface.h", + "MIDIPortParent.h", + "MIDIUtils.h", +] + +UNIFIED_SOURCES += [ + "MIDIAccess.cpp", + "MIDIAccessManager.cpp", + "MIDIInput.cpp", + "MIDIInputMap.cpp", + "MIDILog.cpp", + "MIDIManagerChild.cpp", + "MIDIManagerParent.cpp", + "MIDIMessageEvent.cpp", + "MIDIMessageQueue.cpp", + "MIDIOutput.cpp", + "MIDIOutputMap.cpp", + "MIDIPermissionRequest.cpp", + "MIDIPlatformRunnables.cpp", + "MIDIPlatformService.cpp", + "MIDIPort.cpp", + "MIDIPortChild.cpp", + "MIDIPortInterface.cpp", + "MIDIPortParent.cpp", + "MIDIUtils.cpp", + "TestMIDIPlatformService.cpp", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +if CONFIG["MOZ_WEBMIDI_MIDIR_IMPL"]: + DEFINES["MOZ_WEBMIDI_MIDIR_IMPL"] = True + DIRS += ["midir_impl"] + UNIFIED_SOURCES += [ + "midirMIDIPlatformService.cpp", + ] + + if CONFIG["OS_TARGET"] == "Linux": + OS_LIBS += ["asound"] # Required by midir + UNIFIED_SOURCES += ["AlsaCompatibility.cpp"] + +FINAL_LIBRARY = "xul" +LOCAL_INCLUDES += [ + "/dom/base", +] + +MOCHITEST_MANIFESTS += ["tests/mochitest.ini"] +BROWSER_CHROME_MANIFESTS += ["tests/browser.ini"] diff --git a/dom/midi/tests/MIDITestUtils.js b/dom/midi/tests/MIDITestUtils.js new file mode 100644 index 0000000000..779a961991 --- /dev/null +++ b/dom/midi/tests/MIDITestUtils.js @@ -0,0 +1,94 @@ +var MIDITestUtils = { + permissionSetup: allow => { + let permPromiseRes; + let permPromise = new Promise((res, rej) => { + permPromiseRes = res; + }); + SpecialPowers.pushPrefEnv( + { + set: [ + ["dom.webmidi.enabled", true], + ["midi.testing", true], + ["midi.prompt.testing", true], + ["media.navigator.permission.disabled", allow], + ], + }, + () => { + permPromiseRes(); + } + ); + return permPromise; + }, + // This list needs to stay synced with the ports in + // dom/midi/TestMIDIPlatformService. + inputInfo: { + get id() { + return MIDITestUtils.stableId(this); + }, + name: "Test Control MIDI Device Input Port", + manufacturer: "Test Manufacturer", + version: "1.0.0", + }, + outputInfo: { + get id() { + return MIDITestUtils.stableId(this); + }, + name: "Test Control MIDI Device Output Port", + manufacturer: "Test Manufacturer", + version: "1.0.0", + }, + stateTestInputInfo: { + get id() { + return MIDITestUtils.stableId(this); + }, + name: "Test State MIDI Device Input Port", + manufacturer: "Test Manufacturer", + version: "1.0.0", + }, + stateTestOutputInfo: { + get id() { + return MIDITestUtils.stableId(this); + }, + name: "Test State MIDI Device Output Port", + manufacturer: "Test Manufacturer", + version: "1.0.0", + }, + alwaysClosedTestOutputInfo: { + get id() { + return MIDITestUtils.stableId(this); + }, + name: "Always Closed MIDI Device Output Port", + manufacturer: "Test Manufacturer", + version: "1.0.0", + }, + checkPacket: (expected, actual) => { + if (expected.length != actual.length) { + ok(false, "Packet " + expected + " length not same as packet " + actual); + } + for (var i = 0; i < expected.length; ++i) { + is(expected[i], actual[i], "Packet value " + expected[i] + " matches."); + } + }, + stableId: async info => { + // This computes the stable ID of a MIDI port according to the logic we + // use in the Web MIDI implementation. See MIDIPortChild::GenerateStableId() + // and nsContentUtils::AnonymizeId(). + const id = info.name + info.manufacturer + info.version; + const encoder = new TextEncoder(); + const data = encoder.encode(id); + const keyBytes = encoder.encode(self.origin); + const key = await crypto.subtle.importKey( + "raw", + keyBytes, + { name: "HMAC", hash: "SHA-256" }, + false, + ["sign"] + ); + const result = new Uint8Array(await crypto.subtle.sign("HMAC", key, data)); + let resultString = ""; + for (let i = 0; i < result.length; i++) { + resultString += String.fromCharCode(result[i]); + } + return btoa(resultString); + }, +}; diff --git a/dom/midi/tests/blank.html b/dom/midi/tests/blank.html new file mode 100644 index 0000000000..7fdd0621f6 --- /dev/null +++ b/dom/midi/tests/blank.html @@ -0,0 +1,5 @@ +<!DOCTYPE html> +<meta charset="utf8"> +<html> +<body></body> +</html> diff --git a/dom/midi/tests/browser.ini b/dom/midi/tests/browser.ini new file mode 100644 index 0000000000..f971c4fec6 --- /dev/null +++ b/dom/midi/tests/browser.ini @@ -0,0 +1,24 @@ +[DEFAULT] +prefs = + dom.webmidi.enabled=true + midi.testing=true + midi.prompt.testing=true + media.navigator.permission.disabled=true + dom.sitepermsaddon-provider.enabled=true + +[browser_midi_permission_gated.js] +skip-if = + os == "win" && os_version == "6.1" # Skip on Azure - frequent failure +support-files = + blank.html + +[browser_stable_midi_port_ids.js] +run-if = (os != 'android') +support-files = + port_ids_page_1.html + port_ids_page_2.html + +[browser_refresh_port_list.js] +run-if = (os != 'android') +support-files = + refresh_port_list.html diff --git a/dom/midi/tests/browser_midi_permission_gated.js b/dom/midi/tests/browser_midi_permission_gated.js new file mode 100644 index 0000000000..35efd30fc7 --- /dev/null +++ b/dom/midi/tests/browser_midi_permission_gated.js @@ -0,0 +1,827 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const EXAMPLE_COM_URL = + "https://example.com/document-builder.sjs?html=<h1>Test midi permission with synthetic site permission addon</h1>"; +const PAGE_WITH_IFRAMES_URL = `https://example.org/document-builder.sjs?html= + <h1>Test midi permission with synthetic site permission addon in iframes</h1> + <iframe id=sameOrigin src="${encodeURIComponent( + 'https://example.org/document-builder.sjs?html=SameOrigin"' + )}"></iframe> + <iframe id=crossOrigin src="${encodeURIComponent( + 'https://example.net/document-builder.sjs?html=CrossOrigin"' + )}"></iframe>`; + +const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js"); +ChromeUtils.defineModuleGetter( + this, + "AddonTestUtils", + "resource://testing-common/AddonTestUtils.jsm" +); + +add_setup(async function() { + await SpecialPowers.pushPrefEnv({ + set: [["midi.prompt.testing", false]], + }); + + AddonTestUtils.initMochitest(this); + AddonTestUtils.hookAMTelemetryEvents(); + + // Once the addon is installed, a dialog is displayed as a confirmation. + // This could interfere with tests running after this one, so we set up a listener + // that will always accept post install dialogs so we don't have to deal with them in + // the test. + alwaysAcceptAddonPostInstallDialogs(); + + registerCleanupFunction(async () => { + // Remove the permission. + await SpecialPowers.removePermission("midi-sysex", { + url: EXAMPLE_COM_URL, + }); + await SpecialPowers.removePermission("midi-sysex", { + url: PAGE_WITH_IFRAMES_URL, + }); + await SpecialPowers.removePermission("midi", { + url: EXAMPLE_COM_URL, + }); + await SpecialPowers.removePermission("midi", { + url: PAGE_WITH_IFRAMES_URL, + }); + await SpecialPowers.removePermission("install", { + url: EXAMPLE_COM_URL, + }); + + while (gBrowser.tabs.length > 1) { + BrowserTestUtils.removeTab(gBrowser.selectedTab); + } + }); +}); + +add_task(async function testRequestMIDIAccess() { + gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, EXAMPLE_COM_URL); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + const testPageHost = gBrowser.selectedTab.linkedBrowser.documentURI.host; + + info("Check that midi-sysex isn't set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + { url: EXAMPLE_COM_URL } + ), + "midi-sysex value should have UNKNOWN permission" + ); + + info("Request midi-sysex access"); + let onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + + info("Deny site permission addon install in first popup"); + let addonInstallPanel = await onAddonInstallBlockedNotification; + const [ + installPopupHeader, + installPopupMessage, + ] = addonInstallPanel.querySelectorAll( + "description.popup-notification-description" + ); + is( + installPopupHeader.textContent, + gNavigatorBundle.getString("sitePermissionInstallFirstPrompt.header"), + "First popup has expected header text" + ); + is( + installPopupMessage.textContent, + gNavigatorBundle.getString("sitePermissionInstallFirstPrompt.message"), + "First popup has expected message" + ); + + let notification = addonInstallPanel.childNodes[0]; + // secondaryButton is the "Don't allow" button + notification.secondaryButton.click(); + + let rejectionMessage = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + let errorMessage; + try { + await content.midiAccessRequestPromise; + } catch (e) { + errorMessage = `${e.name}: ${e.message}`; + } + + delete content.midiAccessRequestPromise; + return errorMessage; + } + ); + is( + rejectionMessage, + "SecurityError: WebMIDI requires a site permission add-on to activate" + ); + + assertSitePermissionInstallTelemetryEvents(["site_warning", "cancelled"]); + + info("Deny site permission addon install in second popup"); + onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + addonInstallPanel = await onAddonInstallBlockedNotification; + notification = addonInstallPanel.childNodes[0]; + let dialogPromise = waitForInstallDialog(); + notification.button.click(); + let installDialog = await dialogPromise; + is( + installDialog.querySelector(".popup-notification-description").textContent, + gNavigatorBundle.getFormattedString( + "webextSitePerms.headerWithGatedPerms.midi-sysex", + [testPageHost] + ), + "Install dialog has expected header text" + ); + is( + installDialog.querySelector("popupnotificationcontent description") + .textContent, + gNavigatorBundle.getFormattedString( + "webextSitePerms.descriptionGatedPerms", + [testPageHost] + ), + "Install dialog has expected description" + ); + + // secondaryButton is the "Cancel" button + installDialog.secondaryButton.click(); + + rejectionMessage = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + let errorMessage; + try { + await content.midiAccessRequestPromise; + } catch (e) { + errorMessage = `${e.name}: ${e.message}`; + } + + delete content.midiAccessRequestPromise; + return errorMessage; + } + ); + is( + rejectionMessage, + "SecurityError: WebMIDI requires a site permission add-on to activate" + ); + + assertSitePermissionInstallTelemetryEvents([ + "site_warning", + "permissions_prompt", + "cancelled", + ]); + + info("Request midi-sysex access again"); + onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + + info("Accept site permission addon install"); + addonInstallPanel = await onAddonInstallBlockedNotification; + notification = addonInstallPanel.childNodes[0]; + dialogPromise = waitForInstallDialog(); + notification.button.click(); + installDialog = await dialogPromise; + installDialog.button.click(); + + info("Wait for the midi-sysex access request promise to resolve"); + let accessGranted = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + try { + await content.midiAccessRequestPromise; + return true; + } catch (e) {} + + delete content.midiAccessRequestPromise; + return false; + } + ); + ok(accessGranted, "requestMIDIAccess resolved"); + + info("Check that midi-sysex is now set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.ALLOW_ACTION, + { url: EXAMPLE_COM_URL } + ), + "midi-sysex value should have ALLOW permission" + ); + ok( + await SpecialPowers.testPermission( + "midi", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + { url: EXAMPLE_COM_URL } + ), + "but midi should have UNKNOWN permission" + ); + + info("Check that we don't prompt user again once they installed the addon"); + const accessPromiseState = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + return content.navigator + .requestMIDIAccess({ sysex: true }) + .then(() => "resolved"); + } + ); + is( + accessPromiseState, + "resolved", + "requestMIDIAccess resolved without user prompt" + ); + + assertSitePermissionInstallTelemetryEvents([ + "site_warning", + "permissions_prompt", + "completed", + ]); + + info("Request midi access without sysex"); + onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiNoSysexAccessRequestPromise = content.navigator.requestMIDIAccess(); + }); + + info("Accept site permission addon install"); + addonInstallPanel = await onAddonInstallBlockedNotification; + notification = addonInstallPanel.childNodes[0]; + + is( + notification + .querySelector("#addon-install-blocked-info") + .getAttribute("href"), + Services.urlFormatter.formatURLPref("app.support.baseURL") + + "site-permission-addons", + "Got the expected SUMO page as a learn more link in the addon-install-blocked panel" + ); + + dialogPromise = waitForInstallDialog(); + notification.button.click(); + installDialog = await dialogPromise; + + is( + installDialog.querySelector(".popup-notification-description").textContent, + gNavigatorBundle.getFormattedString( + "webextSitePerms.headerWithGatedPerms.midi", + [testPageHost] + ), + "Install dialog has expected header text" + ); + is( + installDialog.querySelector("popupnotificationcontent description") + .textContent, + gNavigatorBundle.getFormattedString( + "webextSitePerms.descriptionGatedPerms", + [testPageHost] + ), + "Install dialog has expected description" + ); + + installDialog.button.click(); + + info("Wait for the midi access request promise to resolve"); + accessGranted = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + try { + await content.midiNoSysexAccessRequestPromise; + return true; + } catch (e) {} + + delete content.midiNoSysexAccessRequestPromise; + return false; + } + ); + ok(accessGranted, "requestMIDIAccess resolved"); + + info("Check that both midi-sysex and midi are now set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.ALLOW_ACTION, + { url: EXAMPLE_COM_URL } + ), + "midi-sysex value should have ALLOW permission" + ); + ok( + await SpecialPowers.testPermission( + "midi", + SpecialPowers.Services.perms.ALLOW_ACTION, + { url: EXAMPLE_COM_URL } + ), + "and midi value should also have ALLOW permission" + ); + + assertSitePermissionInstallTelemetryEvents([ + "site_warning", + "permissions_prompt", + "completed", + ]); + + info("Check that we don't prompt user again when they perm denied"); + // remove permission to have a clean state + await SpecialPowers.removePermission("midi-sysex", { + url: EXAMPLE_COM_URL, + }); + + onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + + info("Perm-deny site permission addon install"); + addonInstallPanel = await onAddonInstallBlockedNotification; + // Click the "Report Suspicious Site" menuitem, which has the same effect as + // "Never Allow" and also submits a telemetry event (which we check below). + notification.menupopup.querySelectorAll("menuitem")[1].click(); + + rejectionMessage = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + let errorMessage; + try { + await content.midiAccessRequestPromise; + } catch (e) { + errorMessage = e.name; + } + + delete content.midiAccessRequestPromise; + return errorMessage; + } + ); + is(rejectionMessage, "SecurityError", "requestMIDIAccess was rejected"); + + info("Request midi-sysex access again"); + let denyIntervalStart = performance.now(); + rejectionMessage = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + let errorMessage; + try { + await content.navigator.requestMIDIAccess({ + sysex: true, + }); + } catch (e) { + errorMessage = e.name; + } + return errorMessage; + } + ); + is( + rejectionMessage, + "SecurityError", + "requestMIDIAccess was rejected without user prompt" + ); + let denyIntervalElapsed = performance.now() - denyIntervalStart; + ok( + denyIntervalElapsed >= 3000, + `Rejection should be delayed by a randomized interval no less than 3 seconds (got ${denyIntervalElapsed / + 1000} seconds)` + ); + + // Invoking getAMTelemetryEvents resets the mocked event array, and we want + // to test two different things here, so we cache it. + let events = AddonTestUtils.getAMTelemetryEvents(); + Assert.deepEqual( + events.filter(evt => evt.method == "reportSuspiciousSite")[0], + { + method: "reportSuspiciousSite", + object: "suspiciousSite", + value: "example.com", + extra: undefined, + } + ); + assertSitePermissionInstallTelemetryEvents( + ["site_warning", "cancelled"], + events + ); +}); + +add_task(async function testIframeRequestMIDIAccess() { + gBrowser.selectedTab = BrowserTestUtils.addTab( + gBrowser, + PAGE_WITH_IFRAMES_URL + ); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + info("Check that midi-sysex isn't set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + { url: PAGE_WITH_IFRAMES_URL } + ), + "midi-sysex value should have UNKNOWN permission" + ); + + info("Request midi-sysex access from the same-origin iframe"); + const sameOriginIframeBrowsingContext = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + return content.document.getElementById("sameOrigin").browsingContext; + } + ); + + let onAddonInstallBlockedNotification = waitForNotification( + "addon-install-blocked" + ); + await SpecialPowers.spawn(sameOriginIframeBrowsingContext, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + + info("Accept site permission addon install"); + const addonInstallPanel = await onAddonInstallBlockedNotification; + const notification = addonInstallPanel.childNodes[0]; + const dialogPromise = waitForInstallDialog(); + notification.button.click(); + let installDialog = await dialogPromise; + installDialog.button.click(); + + info("Wait for the midi-sysex access request promise to resolve"); + const accessGranted = await SpecialPowers.spawn( + sameOriginIframeBrowsingContext, + [], + async () => { + try { + await content.midiAccessRequestPromise; + return true; + } catch (e) {} + + delete content.midiAccessRequestPromise; + return false; + } + ); + ok(accessGranted, "requestMIDIAccess resolved"); + + info("Check that midi-sysex is now set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.ALLOW_ACTION, + { url: PAGE_WITH_IFRAMES_URL } + ), + "midi-sysex value should have ALLOW permission" + ); + + info( + "Check that we don't prompt user again once they installed the addon from the same-origin iframe" + ); + const accessPromiseState = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + return content.navigator + .requestMIDIAccess({ sysex: true }) + .then(() => "resolved"); + } + ); + is( + accessPromiseState, + "resolved", + "requestMIDIAccess resolved without user prompt" + ); + + assertSitePermissionInstallTelemetryEvents([ + "site_warning", + "permissions_prompt", + "completed", + ]); + + info("Check that request is rejected when done from a cross-origin iframe"); + const crossOriginIframeBrowsingContext = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + return content.document.getElementById("crossOrigin").browsingContext; + } + ); + + const onConsoleErrorMessage = new Promise(resolve => { + const errorListener = { + observe(error) { + if (error.message.includes("WebMIDI access request was denied")) { + resolve(error); + Services.console.unregisterListener(errorListener); + } + }, + }; + Services.console.registerListener(errorListener); + }); + + const rejectionMessage = await SpecialPowers.spawn( + crossOriginIframeBrowsingContext, + [], + async () => { + let errorName; + try { + await content.navigator.requestMIDIAccess({ + sysex: true, + }); + } catch (e) { + errorName = e.name; + } + return errorName; + } + ); + + is( + rejectionMessage, + "SecurityError", + "requestMIDIAccess from the remote iframe was rejected" + ); + + const consoleErrorMessage = await onConsoleErrorMessage; + ok( + consoleErrorMessage.message.includes( + `WebMIDI access request was denied: ❝SitePermsAddons can't be installed from cross origin subframes❞`, + "an error message is sent to the console" + ) + ); + assertSitePermissionInstallTelemetryEvents([]); +}); + +add_task(async function testRequestMIDIAccessLocalhost() { + const httpServer = new HttpServer(); + httpServer.start(-1); + httpServer.registerPathHandler(`/test`, function(request, response) { + response.setStatusLine(request.httpVersion, 200, "OK"); + response.write(` + <!DOCTYPE html> + <meta charset=utf8> + <h1>Test requestMIDIAccess on lcoalhost</h1>`); + }); + const localHostTestUrl = `http://localhost:${httpServer.identity.primaryPort}/test`; + + registerCleanupFunction(async function cleanup() { + await new Promise(resolve => httpServer.stop(resolve)); + }); + + gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, localHostTestUrl); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + info("Check that midi-sysex isn't set"); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + { url: localHostTestUrl } + ), + "midi-sysex value should have UNKNOWN permission" + ); + + info( + "Request midi-sysex access should not prompt for addon install on locahost, but for permission" + ); + let popupShown = BrowserTestUtils.waitForEvent( + PopupNotifications.panel, + "popupshown" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + content.midiAccessRequestPromise = content.navigator.requestMIDIAccess({ + sysex: true, + }); + }); + await popupShown; + is( + PopupNotifications.panel.querySelector("popupnotification").id, + "midi-notification", + "midi notification was displayed" + ); + + info("Accept permission"); + PopupNotifications.panel + .querySelector(".popup-notification-primary-button") + .click(); + + info("Wait for the midi-sysex access request promise to resolve"); + const accessGranted = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + async () => { + try { + await content.midiAccessRequestPromise; + return true; + } catch (e) {} + + delete content.midiAccessRequestPromise; + return false; + } + ); + ok(accessGranted, "requestMIDIAccess resolved"); + + info("Check that we prompt user again even if they accepted before"); + popupShown = BrowserTestUtils.waitForEvent( + PopupNotifications.panel, + "popupshown" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => { + content.navigator.requestMIDIAccess({ sysex: true }); + }); + await popupShown; + is( + PopupNotifications.panel.querySelector("popupnotification").id, + "midi-notification", + "midi notification was displayed again" + ); + + assertSitePermissionInstallTelemetryEvents([]); +}); + +add_task(async function testDisabledRequestMIDIAccessFile() { + let dir = getChromeDir(getResolvedURI(gTestPath)); + dir.append("blank.html"); + const fileSchemeTestUri = Services.io.newFileURI(dir).spec; + + gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, fileSchemeTestUri); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + info("Check that requestMIDIAccess isn't set on navigator on file scheme"); + const isRequestMIDIAccessDefined = await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [], + () => { + return "requestMIDIAccess" in content.wrappedJSObject.navigator; + } + ); + is( + isRequestMIDIAccessDefined, + false, + "navigator.requestMIDIAccess is not defined on file scheme" + ); +}); + +// Ignore any additional telemetry events collected in this file. +// Unfortunately it doesn't work to have this in a cleanup function. +// Keep this as the last task done. +add_task(function teardown_telemetry_events() { + AddonTestUtils.getAMTelemetryEvents(); +}); + +/** + * Check that the expected sitepermission install events are recorded. + * + * @param {Array<String>} expectedSteps: An array of the expected extra.step values recorded. + */ +function assertSitePermissionInstallTelemetryEvents( + expectedSteps, + events = null +) { + let amInstallEvents = (events ?? AddonTestUtils.getAMTelemetryEvents()) + .filter(evt => evt.method === "install" && evt.object === "sitepermission") + .map(evt => evt.extra.step); + + Assert.deepEqual(amInstallEvents, expectedSteps); +} + +async function waitForInstallDialog(id = "addon-webext-permissions") { + let panel = await waitForNotification(id); + return panel.childNodes[0]; +} + +/** + * Adds an event listener that will listen for post-install dialog event and automatically + * close the dialogs. + */ +function alwaysAcceptAddonPostInstallDialogs() { + // Once the addon is installed, a dialog is displayed as a confirmation. + // This could interfere with tests running after this one, so we set up a listener + // that will always accept post install dialogs so we don't have to deal with them in + // the test. + const abortController = new AbortController(); + + const { AppMenuNotifications } = ChromeUtils.importESModule( + "resource://gre/modules/AppMenuNotifications.sys.mjs" + ); + info("Start listening and accept addon post-install notifications"); + PanelUI.notificationPanel.addEventListener( + "popupshown", + async function popupshown() { + let notification = AppMenuNotifications.activeNotification; + if (!notification || notification.id !== "addon-installed") { + return; + } + + let popupnotificationID = PanelUI._getPopupId(notification); + if (popupnotificationID) { + info("Accept post-install dialog"); + let popupnotification = document.getElementById(popupnotificationID); + popupnotification?.button.click(); + } + }, + { + signal: abortController.signal, + } + ); + + registerCleanupFunction(async () => { + // Clear the listener at the end of the test file, to prevent it to stay + // around when the same browser instance may be running other unrelated + // test files. + abortController.abort(); + }); +} + +const PROGRESS_NOTIFICATION = "addon-progress"; +async function waitForNotification(notificationId) { + info(`Waiting for ${notificationId} notification`); + + let topic = getObserverTopic(notificationId); + + let observerPromise; + if (notificationId !== "addon-webext-permissions") { + observerPromise = new Promise(resolve => { + Services.obs.addObserver(function observer(aSubject, aTopic, aData) { + // Ignore the progress notification unless that is the notification we want + if ( + notificationId != PROGRESS_NOTIFICATION && + aTopic == getObserverTopic(PROGRESS_NOTIFICATION) + ) { + return; + } + Services.obs.removeObserver(observer, topic); + resolve(); + }, topic); + }); + } + + let panelEventPromise = new Promise(resolve => { + window.PopupNotifications.panel.addEventListener( + "PanelUpdated", + function eventListener(e) { + // Skip notifications that are not the one that we are supposed to be looking for + if (!e.detail.includes(notificationId)) { + return; + } + window.PopupNotifications.panel.removeEventListener( + "PanelUpdated", + eventListener + ); + resolve(); + } + ); + }); + + await observerPromise; + await panelEventPromise; + await waitForTick(); + + info(`Saw a ${notificationId} notification`); + await SimpleTest.promiseFocus(window.PopupNotifications.window); + return window.PopupNotifications.panel; +} + +function getObserverTopic(aNotificationId) { + let topic = aNotificationId; + if (topic == "xpinstall-disabled") { + topic = "addon-install-disabled"; + } else if (topic == "addon-progress") { + topic = "addon-install-started"; + } else if (topic == "addon-install-restart") { + topic = "addon-install-complete"; + } else if (topic == "addon-installed") { + topic = "webextension-install-notify"; + } + return topic; +} + +function waitForTick() { + return new Promise(resolve => executeSoon(resolve)); +} diff --git a/dom/midi/tests/browser_refresh_port_list.js b/dom/midi/tests/browser_refresh_port_list.js new file mode 100644 index 0000000000..0bbf8fce85 --- /dev/null +++ b/dom/midi/tests/browser_refresh_port_list.js @@ -0,0 +1,71 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const EXAMPLE_ORG_URL = "https://example.org/browser/dom/midi/tests/"; +const PAGE = "refresh_port_list.html"; + +async function get_access(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], function() { + return content.wrappedJSObject.get_access(); + }); +} + +async function reset_access(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], function() { + return content.wrappedJSObject.reset_access(); + }); +} + +async function get_num_ports(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], function() { + return content.wrappedJSObject.get_num_ports(); + }); +} + +async function add_port(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + return content.wrappedJSObject.add_port(); + }); +} + +async function remove_port(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + return content.wrappedJSObject.remove_port(); + }); +} + +async function force_refresh(browser) { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + return content.wrappedJSObject.force_refresh(); + }); +} + +add_task(async function() { + gBrowser.selectedTab = BrowserTestUtils.addTab( + gBrowser, + EXAMPLE_ORG_URL + PAGE + ); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + await get_access(gBrowser.selectedBrowser); + let ports_num = await get_num_ports(gBrowser.selectedBrowser); + Assert.equal(ports_num, 4, "We start with four ports"); + await add_port(gBrowser.selectedBrowser); + ports_num = await get_num_ports(gBrowser.selectedBrowser); + Assert.equal(ports_num, 5, "One port is added manually"); + // This causes the test service to refresh the ports the next time a refresh + // is requested, it will happen after we reload the tab later on and will add + // back the port that we're removing on the next line. + await force_refresh(gBrowser.selectedBrowser); + await remove_port(gBrowser.selectedBrowser); + ports_num = await get_num_ports(gBrowser.selectedBrowser); + Assert.equal(ports_num, 4, "One port is removed manually"); + + await BrowserTestUtils.reloadTab(gBrowser.selectedTab); + + await get_access(gBrowser.selectedBrowser); + let refreshed_ports_num = await get_num_ports(gBrowser.selectedBrowser); + Assert.equal(refreshed_ports_num, 5, "One port is added by the refresh"); + + gBrowser.removeTab(gBrowser.selectedTab); +}); diff --git a/dom/midi/tests/browser_stable_midi_port_ids.js b/dom/midi/tests/browser_stable_midi_port_ids.js new file mode 100644 index 0000000000..e2f7f3a7eb --- /dev/null +++ b/dom/midi/tests/browser_stable_midi_port_ids.js @@ -0,0 +1,52 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const EXAMPLE_COM_URL = "https://example.com/browser/dom/midi/tests/"; +const EXAMPLE_ORG_URL = "https://example.org/browser/dom/midi/tests/"; +const PAGE1 = "port_ids_page_1.html"; +const PAGE2 = "port_ids_page_2.html"; + +// Return the MIDI port id of the first input port for the given URL and page +function id_for_tab(url, page) { + return BrowserTestUtils.withNewTab( + { + gBrowser, + url: url + page, + waitForLoad: true, + }, + async function(browser) { + return SpecialPowers.spawn(browser, [""], function() { + return content.wrappedJSObject.get_first_input_id(); + }); + } + ); +} + +add_task(async function() { + let com_page1; + let com_page1_reload; + let org_page1; + let org_page2; + + [com_page1, com_page1_reload, org_page1, org_page2] = await Promise.all([ + id_for_tab(EXAMPLE_COM_URL, PAGE1), + id_for_tab(EXAMPLE_COM_URL, PAGE1), + id_for_tab(EXAMPLE_ORG_URL, PAGE1), + id_for_tab(EXAMPLE_ORG_URL, PAGE2), + ]); + Assert.equal( + com_page1, + com_page1_reload, + "MIDI port ids should be the same when reloading the same page" + ); + Assert.notEqual( + com_page1, + org_page1, + "MIDI port ids should be different in different origins" + ); + Assert.equal( + org_page1, + org_page2, + "MIDI port ids should be the same in the same origin" + ); +}); diff --git a/dom/midi/tests/file_midi_permission_gated.html b/dom/midi/tests/file_midi_permission_gated.html new file mode 100644 index 0000000000..8e3ed4d625 --- /dev/null +++ b/dom/midi/tests/file_midi_permission_gated.html @@ -0,0 +1,15 @@ +<!DOCTYPE html> +<html> +<head> +<script> + window.addEventListener("message", async (evt) => { + try { + await navigator.requestMIDIAccess({sysex: evt.data}); + parent.postMessage("succeeded", "*"); + } catch (ex) { + parent.postMessage("failed", "*"); + } + }); +</script> +<body></body> +</html> diff --git a/dom/midi/tests/mochitest.ini b/dom/midi/tests/mochitest.ini new file mode 100644 index 0000000000..5d0ded33e8 --- /dev/null +++ b/dom/midi/tests/mochitest.ini @@ -0,0 +1,23 @@ +[DEFAULT] +support-files = + MIDITestUtils.js + file_midi_permission_gated.html +scheme = https + +[test_midi_permission_prompt.html] +[test_midi_permission_allow.html] +[test_midi_permission_deny.html] +[test_midi_permission_gated.html] +skip-if = os == 'android' #Bug 1747637 +[test_midi_device_enumeration.html] +[test_midi_device_implicit_open_close.html] +[test_midi_device_explicit_open_close.html] +[test_midi_device_sysex.html] +[test_midi_device_system_rt.html] +[test_midi_packet_timing_sorting.html] +[test_midi_device_connect_disconnect.html] +disabled = Bug 1437204 +[test_midi_device_pending.html] +disabled = Bug 1437204 +[test_midi_send_messages.html] +[test_midi_message_event.html] diff --git a/dom/midi/tests/port_ids_page_1.html b/dom/midi/tests/port_ids_page_1.html new file mode 100644 index 0000000000..31dadad4a5 --- /dev/null +++ b/dom/midi/tests/port_ids_page_1.html @@ -0,0 +1,17 @@ +<!DOCTYPE html> +<html> +<head> +<title>Stable MIDI port id test</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<script> + async function get_first_input_id() { + let access = await navigator.requestMIDIAccess({ sysex: false }); + const inputs = access.inputs.values(); + const input = inputs.next(); + return input.value.id; + } +</script> +</body> +</html> diff --git a/dom/midi/tests/port_ids_page_2.html b/dom/midi/tests/port_ids_page_2.html new file mode 100644 index 0000000000..8c313b04da --- /dev/null +++ b/dom/midi/tests/port_ids_page_2.html @@ -0,0 +1,17 @@ +<!DOCTYPE html> +<html> +<head> +<title>Stable MIDI port id test</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<script> + async function get_first_input_id() { + let access = await navigator.requestMIDIAccess({ sysex: false }); + const inputs = access.inputs.values(); + const input = inputs.next(); + return input.value.id; +} +</script> +</body> +</html> diff --git a/dom/midi/tests/refresh_port_list.html b/dom/midi/tests/refresh_port_list.html new file mode 100644 index 0000000000..96e4a7a309 --- /dev/null +++ b/dom/midi/tests/refresh_port_list.html @@ -0,0 +1,49 @@ +<!DOCTYPE html> +<html> +<head> +<title>Refresh MIDI port list test</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<script> + var access = null; + async function get_access() { + access = await navigator.requestMIDIAccess({ sysex: true }); + } + + async function reset_access() { + access = null; + } + + async function get_num_ports() { + return access.inputs.size + access.outputs.size; + } + + async function add_port() { + let addPortPromise = new Promise(resolve => { + access.addEventListener("statechange", (event) => { dump("***** 1 event.port.name = " + event.port.name + "event.connection = " + event.port.connection + "\n"); if (event.port.connection != "open") { resolve(); } }); + }); + const outputs = access.outputs.values(); + const output = outputs.next().value; + output.send([0x90, 0x01, 0x00]); + await addPortPromise; + } + + async function remove_port() { + let removePortPromise = new Promise(resolve => { + access.addEventListener("statechange", (event) => { dump("***** 2 event.port.name = " + event.port.name + "event.connection = " + event.port.connection + "\n"); if (event.port.connection != "open") { resolve(); } }); + }); + const outputs = access.outputs.values(); + const output = outputs.next().value; + output.send([0x90, 0x02, 0x00]); + await removePortPromise; + } + + async function force_refresh() { + const outputs = access.outputs.values(); + const output = outputs.next().value; + output.send([0x90, 0x04, 0x00]); + } +</script> +</body> +</html> diff --git a/dom/midi/tests/test_midi_device_connect_disconnect.html b/dom/midi/tests/test_midi_device_connect_disconnect.html new file mode 100644 index 0000000000..338d1de55d --- /dev/null +++ b/dom/midi/tests/test_midi_device_connect_disconnect.html @@ -0,0 +1,54 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + let output; + + let midi_access; + try { + midi_access = await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "MIDI Access Request successful"); + } catch (e) { + ok(false, "MIDI Access Request failed!"); + SimpleTest.finish(); + return; + } + is(midi_access.sysexEnabled, false, "Sysex should be false"); + output = midi_access.outputs.get(await MIDITestUtils.outputInfo.id); + let statePromiseRes; + let statePromise = new Promise((res) => { statePromiseRes = res; }); + await output.open(); + let stateChangeHandler = (event) => { + if (event.port == output) { + return; + } + statePromiseRes(event.port); + }; + midi_access.addEventListener("statechange", stateChangeHandler); + // Send command to connect new port. + output.send([0x90, 0x01, 0x00]); + let p = await statePromise; + is(p.state, "connected", "Device " + p.name + " connected"); + + // Rebuild our promise, we'll need to await another one. + statePromise = new Promise((res) => { statePromiseRes = res; }); + output.send([0x90, 0x02, 0x00]); + p = await statePromise; + is(p.state, "disconnected", "Device " + p.name + " disconnected"); + midi_access.removeEventListener("statechange", stateChangeHandler); + SimpleTest.finish(); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_enumeration.html b/dom/midi/tests/test_midi_device_enumeration.html new file mode 100644 index 0000000000..1dab1c8cf7 --- /dev/null +++ b/dom/midi/tests/test_midi_device_enumeration.html @@ -0,0 +1,46 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + let objectCompare = async (type, props, obj) => { + for (var prop in props) { + is(await props[prop], obj[prop], type + " property value " + prop + " is " + props[prop]); + } + }; + let failOnCall = (event) => { + ok(false, "No connect/state events should be received on startup!"); + }; + async function runTests () { + await MIDITestUtils.permissionSetup(true); + // Request access without sysex. + let access = await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "MIDI Access Request successful"); + is(access.sysexEnabled, false, "Sysex should be false"); + access.addEventListener("statechange", failOnCall); + var input_id = await MIDITestUtils.inputInfo.id; + var output_id = await MIDITestUtils.outputInfo.id; + var inputs = access.inputs; + var outputs = access.outputs; + is(inputs.size, 1, "Should have one input"); + is(outputs.size, 3, "Should have three outputs"); + ok(inputs.has(input_id), "input list should contain input id"); + ok(outputs.has(output_id), "output list should contain output id"); + var input = access.inputs.get(input_id); + var output = access.outputs.get(output_id); + await objectCompare("input", MIDITestUtils.inputInfo, input); + await objectCompare("output", MIDITestUtils.outputInfo, output); + access.removeEventListener("statechange", failOnCall); + SimpleTest.finish(); + }; + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_explicit_open_close.html b/dom/midi/tests/test_midi_device_explicit_open_close.html new file mode 100644 index 0000000000..d3ed910a55 --- /dev/null +++ b/dom/midi/tests/test_midi_device_explicit_open_close.html @@ -0,0 +1,94 @@ +<html> + <head> + <title>WebMIDI Device Open/Close Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + + let access; + try { + access = await navigator.requestMIDIAccess({ "sysex": false }) + } catch (e) { + ok(false, "MIDI Access Request Failed!"); + SimpleTest.finish(); + } + + ok(true, "MIDI Access Request successful"); + let input = access.inputs.get(await MIDITestUtils.inputInfo.id); + let portEventRes; + let accessEventRes; + let portEventPromise = new Promise((resolve, reject) => { portEventRes = resolve; }); + let accessEventPromise = new Promise((resolve, reject) => { accessEventRes = resolve; }); + let shouldClose = false; + let checkPort = (event) => { + ok(input === event.port, "input port object and event port object are same object"); + ok(true, "port connection event fired"); + ok(event.port.connection === (!shouldClose ? "open" : "closed"), "connection registered correctly"); + }; + let inputEventHandler = (event) => { + checkPort(event); + portEventRes(); + }; + let accessEventHandler = (event) => { + checkPort(event); + accessEventRes(); + }; + input.addEventListener("statechange", inputEventHandler); + access.addEventListener("statechange", accessEventHandler); + await input.open(); + ok(true, "connection successful"); + ok(input.connection === "open", "connection registered as open"); + await Promise.all([portEventPromise, accessEventPromise]); + input.removeEventListener("statechange", inputEventHandler); + access.removeEventListener("statechange", accessEventHandler); + ok(true, "MIDI Port Open Test finished."); + ok(true, "Testing open failure"); + let out_access; + try { + out_access = await navigator.requestMIDIAccess({ "sysex": false }); + } catch (e) { + ok(false, "MIDI Access Request Failed!"); + SimpleTest.finish(); + } + let outputEventHandler = (event) => { + ok(output_opened === event.port, "output port object and event port object are same object"); + ok(true, "access connection event fired"); + ok(event.port.connection === "closed", "connection registered as closed"); + }; + out_access.addEventListener("statechange", outputEventHandler); + let output_opened = out_access.outputs.get(await MIDITestUtils.alwaysClosedTestOutputInfo.id); + try { + await output_opened.open(); + ok(false, "Should've failed to open port!"); + } catch(err) { + is(err.name, "InvalidAccessError", "error name " + err.name + " should be InvalidAccessError"); + ok(output_opened.connection == "closed", "connection registered as closed"); + ok(true, "Port not opened, test succeeded"); + } finally { + out_access.removeEventListener("statechange", outputEventHandler); + } + ok(true, "Starting MIDI port closing test"); + portEventPromise = new Promise((resolve, reject) => { portEventRes = resolve; }); + accessEventPromise = new Promise((resolve, reject) => { accessEventRes = resolve; }); + input.addEventListener("statechange", inputEventHandler); + access.addEventListener("statechange", accessEventHandler); + shouldClose = true; + await input.close(); + ok(input.connection === "closed", "connection registered as closed"); + await Promise.all([portEventPromise, accessEventPromise]); + input.removeEventListener("statechange", inputEventHandler); + access.removeEventListener("statechange", accessEventHandler); + SimpleTest.finish(); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_implicit_open_close.html b/dom/midi/tests/test_midi_device_implicit_open_close.html new file mode 100644 index 0000000000..cddbaf26c2 --- /dev/null +++ b/dom/midi/tests/test_midi_device_implicit_open_close.html @@ -0,0 +1,54 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + let access = await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "MIDI Access Request successful"); + is(access.sysexEnabled, false, "Sysex should be false"); + + var checkCount = 0; + var input; + var output; + function checkCallbacks(port) { + if (checkCount < 2) { + ok(port.connection === "open", "Got port " + port.connection + " for " + port.name); + } else { + ok(port.connection === "closed", "Got port " + port.connection + " for " + port.name); + } + + checkCount++; + if (checkCount == 4) { + input.onstatechange = undefined; + output.onstatechange = undefined; + SimpleTest.finish(); + } + } + function checkReturn(event) { + ok(true, "Got echo message back"); + MIDITestUtils.checkPacket(event.data, [0x90, 0x00, 0x7f]); + input.close(); + output.close(); + } + + input = access.inputs.get(await MIDITestUtils.inputInfo.id); + output = access.outputs.get(await MIDITestUtils.outputInfo.id); + input.onstatechange = (event) => { checkCallbacks(event.port); }; + output.onstatechange = (event) => { checkCallbacks(event.port); }; + // Ports are closed. Fire rest of tests. + input.onmidimessage = checkReturn; + output.send([0x90, 0x00, 0x7F]); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_pending.html b/dom/midi/tests/test_midi_device_pending.html new file mode 100644 index 0000000000..2e6bd08420 --- /dev/null +++ b/dom/midi/tests/test_midi_device_pending.html @@ -0,0 +1,118 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + + + var output; + var test_ports = []; + let access; + + let accessRes; + let accessPromise; + let portRes; + let portPromise; + + function resetPromises() { + accessPromise = new Promise((res, rej) => { accessRes = res; }); + portPromise = new Promise((res, rej) => { portRes = res; }); + } + + function accessStateChangeHandler(event) { + var p = event.port; + // We'll get an open event for the output control port. Ignore it. + if (p.name == MIDITestUtils.outputInfo.name) { + return; + } + accessRes(event); + } + + function portStateChangeHandler(event) { + var p = event.port; + // We'll get an open event for the output control port. Ignore it. + if (p.name == MIDITestUtils.outputInfo.name) { + return; + } + portRes(event); + } + + // Part 1: Create MIDIAccess object, attach state change listener to list for new connections + access = await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "MIDI Access Request successful"); + is(access.sysexEnabled, false, "Sysex should be false"); + access.addEventListener("statechange", accessStateChangeHandler); + + // Part 2: open test device, make sure it connects, attach event handler to device object + output = access.outputs.get(await MIDITestUtils.outputInfo.id); + resetPromises(); + output.send([0x90, 0x01, 0x00]); + let accessEvent = await accessPromise; + let testPort = accessEvent.port; + test_ports.push(testPort); + testPort.addEventListener("statechange", portStateChangeHandler); + is(testPort.state, "connected", "Device " + testPort.name + " connected"); + + // Part 3: Listen for port status change on open as both an access event + // and a port event. + resetPromises(); + testPort.open(); + accessEvent = await accessPromise; + is(testPort.connection, "open", "Connection " + testPort.name + " opened"); + let portEvent = await portPromise; + is(testPort.connection, "open", "Connection " + testPort.name + " opened"); + + // Part 4: Disconnect port but don't close, check status to make sure we're pending. + resetPromises(); + output.send([0x90, 0x02, 0x00]); + accessEvent = await accessPromise; + is(testPort.connection, "pending", "Connection " + testPort.name + " pending"); + is(access.inputs.has(testPort.id), false, "port removed from input map while pending"); + portEvent = await portPromise; + is(testPort.connection, "pending", "Connection " + testPort.name + " pending"); + + // Part 5: Connect ports again, make sure we return to the right status. The events will + // fire because the device has been readded to the device maps in the access object. + resetPromises(); + output.send([0x90, 0x01, 0x00]); + accessEvent = await accessPromise; + var port = access.inputs.get(testPort.id); + is(port, accessEvent.port, "port in map and port in event should be the same"); + is(testPort.connection, "pending", "Connection " + testPort.name + " pending"); + portEvent = await portPromise; + is(testPort.connection, "pending", "Connection " + testPort.name + " pending"); + + // Part 6: Close out everything and clean up. + resetPromises(); + accessEvent = await accessPromise; + is(accessEvent.port.connection, "open", "Connection " + testPort.name + " opened"); + portEvent = await portPromise; + is(portEvent.port.connection, "open", "Connection " + testPort.name + " opened"); + + /* for (let port of test_ports) { + * port.removeEventListener("statechange", checkDevices); + * } + * access.removeEventListener("statechange", checkDevices);*/ + output.send([0x90, 0x02, 0x00]); + testPort.removeEventListener("statechange", portStateChangeHandler); + access.removeEventListener("statechange", accessStateChangeHandler); + access = undefined; + output = undefined; + testPort = undefined; + accessEvent = undefined; + portEvent = undefined; + SimpleTest.finish(); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_sysex.html b/dom/midi/tests/test_midi_device_sysex.html new file mode 100644 index 0000000000..618f54ac8a --- /dev/null +++ b/dom/midi/tests/test_midi_device_sysex.html @@ -0,0 +1,57 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + var sysexCheckCount = 0; + var checkCount = 0; + var input; + var output; + function checkSysexReceive(event) { + checkCount++; + sysexCheckCount++; + if (sysexCheckCount == 1) { + is(event.data[0], 0xF0, "Echoed sysex message via sysex port"); + } else { + is(event.data[0], 0x90, "Echoed regular message via sysex port"); + } + if (checkCount == 5) { + SimpleTest.finish(); + } + } + + function checkNoSysexReceive(event) { + checkCount++; + is(event.data[0], 0x90, "Echoed regular message via non-sysex port"); + if (checkCount == 5) { + SimpleTest.finish() + } + } + + // Request access without sysex. + let access_regular = await navigator.requestMIDIAccess({ "sysex": false }); + let access_sysex = await navigator.requestMIDIAccess({ "sysex": true }); + ok(true, "MIDI Access Request successful"); + ok(true, "Check for sysex message drop"); + input = access_regular.inputs.get(await MIDITestUtils.inputInfo.id); + output = access_sysex.outputs.get(await MIDITestUtils.outputInfo.id); + let input_sysex = access_sysex.inputs.get(await MIDITestUtils.inputInfo.id); + input_sysex.onmidimessage = checkSysexReceive; + input.onmidimessage = checkNoSysexReceive; + output.send([0xF0, 0x00, 0xF7]); + output.send([0x90, 0x00, 0x01]); + output.send([0x90, 0x00, 0x01]); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_device_system_rt.html b/dom/midi/tests/test_midi_device_system_rt.html new file mode 100644 index 0000000000..81de0c3a94 --- /dev/null +++ b/dom/midi/tests/test_midi_device_system_rt.html @@ -0,0 +1,39 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + var checkCount = 0; + + function checkReturn(msg) { + checkCount++; + if (checkCount == 1) { + MIDITestUtils.checkPacket(msg.data, [0xFA]); + } else if (checkCount == 2) { + MIDITestUtils.checkPacket(msg.data, [0xF8]); + } else if (checkCount == 3) { + MIDITestUtils.checkPacket(msg.data, [0xF0, 0x01, 0x02, 0x03, 0x04, 0x05, 0xF7]); + SimpleTest.finish(); + } + } + + // Request access without sysex. + let access_sysex = await navigator.requestMIDIAccess({ "sysex": true }); + let input_sysex = access_sysex.inputs.get(await MIDITestUtils.inputInfo.id); + input_sysex.onmidimessage = checkReturn; + let output_sysex = access_sysex.outputs.get(await MIDITestUtils.outputInfo.id); + output_sysex.send([0xF0, 0x01, 0xF7]); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_message_event.html b/dom/midi/tests/test_midi_message_event.html new file mode 100644 index 0000000000..098b033008 --- /dev/null +++ b/dom/midi/tests/test_midi_message_event.html @@ -0,0 +1,45 @@ +<html> + +<head> + <title>WebMIDI MIDIMessageEvent Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> +</head> + +<body> + <script class="testbody" type="application/javascript"> + add_task(async () => { + await MIDITestUtils.permissionSetup(true); + + is(new MIDIMessageEvent('eventType').bubbles, false, "bubbles field is false by default"); + is(new MIDIMessageEvent('eventType').cancelable, false, "cancelable field is false by default"); + isDeeply(new MIDIMessageEvent('eventType').data, [], "The default message is empty"); + + is(new MIDIMessageEvent('eventType', { bubbles: false }).bubbles, false, "bubbles is passed"); + is(new MIDIMessageEvent('eventType', { bubbles: true }).bubbles, true, "bubbles is passed"); + + is(new MIDIMessageEvent('eventType', { cancelable: false }).cancelable, false, "cancelable is passed"); + is(new MIDIMessageEvent('eventType', { cancelable: true }).cancelable, true, "cancelable is passed"); + + var data = new Uint8Array(16); + isDeeply(new MIDIMessageEvent('eventType', { data }).data, data, "data is passed"); + + // All initializers are passed. + data = new Uint8Array(3); + is(new MIDIMessageEvent('eventType', { bubbles: true, cancelable: true, data }).bubbles, true, "all initializers are passed"); + is(new MIDIMessageEvent('eventType', { bubbles: true, cancelable: true, data }).cancelable, true, "all initializers are passed"); + isDeeply(new MIDIMessageEvent('eventType', { bubbles: true, cancelable: true, data }).data, data, "all initializers are passed"); + + if (window.SharedArrayBuffer) { + data = new Uint8Array(new SharedArrayBuffer(3)); + SimpleTest.doesThrow(() => { new MIDIMessageEvent('eventType', { data }); }, "shared array buffers are rejected"); + } else { + todo(false, 'SharedArrayBuffer is unavailable.'); + } + }); + </script> +</body> + +</html> diff --git a/dom/midi/tests/test_midi_packet_timing_sorting.html b/dom/midi/tests/test_midi_packet_timing_sorting.html new file mode 100644 index 0000000000..3c344066ac --- /dev/null +++ b/dom/midi/tests/test_midi_packet_timing_sorting.html @@ -0,0 +1,47 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + await SpecialPowers.pushPrefEnv({"set": [["privacy.resistFingerprinting.reduceTimerPrecision.jitter", false]]}); + var checkCount = 0; + var lastTime = 0; + var input; + var output; + function checkReturn(event) { + ok(event.timeStamp > lastTime, "Received timestamp " + event.timeStamp + " should be greater than " + lastTime); + lastTime = event.timeStamp; + checkCount++; + + if (checkCount == 6) { + input.close(); + output.close(); + SimpleTest.finish(); + } + } + ok("Testing MIDI packet reordering based on timestamps"); + // Request access without sysex. + let access = await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "MIDI Access Request successful"); + is(access.sysexEnabled, false, "Sysex should be false"); + + input = access.inputs.get(await MIDITestUtils.inputInfo.id); + output = access.outputs.get(await MIDITestUtils.outputInfo.id); + input.onmidimessage = checkReturn; + // trigger the packet timing sorting tests + output.send([0x90, 0x03, 0x00], 0); + ok(true, "Waiting on packets"); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_permission_allow.html b/dom/midi/tests/test_midi_permission_allow.html new file mode 100644 index 0000000000..84578cfeae --- /dev/null +++ b/dom/midi/tests/test_midi_permission_allow.html @@ -0,0 +1,26 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + // Request access without sysex. + try { + await navigator.requestMIDIAccess({ "sysex": false }) + ok(true, "MIDI Access Request successful"); + SimpleTest.finish(); + } catch (ex) { + ok(false, "MIDI Access Request Failed!"); + SimpleTest.finish(); + } + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_permission_deny.html b/dom/midi/tests/test_midi_permission_deny.html new file mode 100644 index 0000000000..8e3043a49a --- /dev/null +++ b/dom/midi/tests/test_midi_permission_deny.html @@ -0,0 +1,26 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(false); + // Request access without sysex. + try { + await navigator.requestMIDIAccess({ "sysex": false }); + ok(false, "MIDI Access Request Deny failed"); + SimpleTest.finish(); + } catch (ex) { + ok(true, "MIDI Access Request Deny successful!"); + SimpleTest.finish(); + } + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_permission_gated.html b/dom/midi/tests/test_midi_permission_gated.html new file mode 100644 index 0000000000..b3b1af7f32 --- /dev/null +++ b/dom/midi/tests/test_midi_permission_gated.html @@ -0,0 +1,176 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <iframe id="subdomain"></iframe> + <iframe id="localhost"></iframe> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + const filePath = "/tests/dom/midi/tests/file_midi_permission_gated.html"; + // Generally this runs on example.com but with --enable-xorigin-tests it runs + // on example.org. + let subdomainURL = "https://test1." + location.host + filePath; + $("subdomain").src = subdomainURL; + // For some reason the mochitest server returns "Bad request" with localhost, + // but permits the loopback address. That's good enough for testing purposes. + $("localhost").src = "http://127.0.0.1:8888" + filePath; + + function waitForMessage() { + return new Promise((resolve) => { + window.addEventListener("message", (e) => resolve(e.data), {once: true}); + }); + } + + async function runTests() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["dom.webmidi.enabled", true], + ["midi.testing", true], + ], + }); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + document + ), + "midi-sysex value should have UNKNOWN permission" + ); + ok( + await SpecialPowers.testPermission( + "midi-sysex", + SpecialPowers.Services.perms.UNKNOWN_ACTION, + subdomainURL + ), + "permission should also not be set for subdomain" + ); + + let onChangeCalled = 0; + let onChangeCalledWithSysex = 0; + // We expect the same states with and without sysex support. + const expectedChangedStates = ["denied", "granted", "prompt"]; + + for (let sysex of [false, true]) { + let result = await navigator.permissions.query({ name: "midi", sysex }); + is(result?.state, "prompt", "expected 'prompt' permission status"); + // Register two unique listeners that should be invoked every time we + // change permissions in the rest of this test case: one with sysex + // support, and the other one without. + if (sysex) { + result.onchange = () => { + is( + result.state, + expectedChangedStates[onChangeCalledWithSysex++], + "expected change event with sysex support" + ); + }; + } else { + result.onchange = () => { + is( + result.state, + expectedChangedStates[onChangeCalled++], + "expected change event" + ); + }; + } + } + + // Explicitly set the permission as blocked, and expect the + // `requestMIDIAccess` call to be automatically rejected (not having any + // permission set would trigger the synthetic addon install provided by + // AddonManager and SitePermsAddonProvider). + await SpecialPowers.addPermission( + "midi-sysex", + SpecialPowers.Services.perms.DENY_ACTION, + document + ); + await SpecialPowers.addPermission( + "midi", + SpecialPowers.Services.perms.DENY_ACTION, + document + ); + for (let sysex of [false, true]) { + try { + await navigator.requestMIDIAccess({ sysex }); + ok(false, "MIDI Access Request gate allowed but expected to be denied"); + } catch (ex) { + ok(true, "MIDI Access Request denied by default"); + } + + let result = await navigator.permissions.query({ name: "midi", sysex }); + // We expect "denied" because that's what has been set above (with + // `SpecialPowers.addPermission()`). In practice, this state should + // never be returned since explicit rejection is handled at the add-on + // installation level. + is(result?.state, "denied", "expected 'denied' permission status"); + } + + // Gated permission should prompt for localhost. + // + // Note: We don't appear to have good test machinery anymore for + // navigating prompts from a plain mochitest. If you uncomment the lines + // below and run the test interactively, it should pass. Given that this + // is a niche feature that's unlikely to break, it doesn't seem worth + // investing in complicated test infrastructure to check it in automation. + // for (let sysex of [false, true]) { + // $("localhost").contentWindow.postMessage(sysex, "*"); + // let response = await waitForMessage(); + // is(response, "succeeded", "MIDI Access Request allowed for localhost"); + // } + + // When an addon is installed, the permission is inserted. Test + // that the request succeeds after we insert the permission. + await SpecialPowers.addPermission( + "midi-sysex", + SpecialPowers.Services.perms.ALLOW_ACTION, + document + ); + await SpecialPowers.addPermission( + "midi", + SpecialPowers.Services.perms.ALLOW_ACTION, + document + ); + // Gated permission should allow access after addon inserted permission. + for (let sysex of [false, true]) { + try { + await navigator.requestMIDIAccess({ sysex }); + ok(true, "MIDI Access Request allowed"); + } catch (ex) { + ok(false, "MIDI Access Request failed"); + } + + let result = await navigator.permissions.query({ name: "midi", sysex }); + is(result?.state, "granted", "expected 'granted' permission status"); + } + + // Gated permission should also apply to subdomains. + for (let sysex of [false, true]) { + $("subdomain").contentWindow.postMessage(sysex, "*"); + let response = await waitForMessage(); + is(response, "succeeded", "MIDI Access Request allowed for subdomain"); + } + + is( + onChangeCalled, + expectedChangedStates.length - 1, + `expected onchange listener to have been called ${expectedChangedStates.length - 1} times` + ); + is( + onChangeCalledWithSysex, + expectedChangedStates.length - 1, + `expected onchange listener to have been called ${expectedChangedStates.length - 1} times (sysex)` + ); + + // Remove the permission. + await SpecialPowers.removePermission("midi-sysex", document); + await SpecialPowers.removePermission("midi", document); + + SimpleTest.finish(); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_permission_prompt.html b/dom/midi/tests/test_midi_permission_prompt.html new file mode 100644 index 0000000000..26a6b3d789 --- /dev/null +++ b/dom/midi/tests/test_midi_permission_prompt.html @@ -0,0 +1,24 @@ +<html> + <head> + <title>WebMIDI Listener Test</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="application/javascript" src="MIDITestUtils.js"></script> + </head> + + <body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + try { + await navigator.requestMIDIAccess({ "sysex": false }); + ok(true, "Prompting for permissions succeeded!"); + } catch (e) { + ok(false, "Prompting for permissions failed!"); + } + SimpleTest.finish(); + } + </script> + </body> +</html> diff --git a/dom/midi/tests/test_midi_send_messages.html b/dom/midi/tests/test_midi_send_messages.html new file mode 100644 index 0000000000..1d78709877 --- /dev/null +++ b/dom/midi/tests/test_midi_send_messages.html @@ -0,0 +1,112 @@ +<html> + +<head> + <title>WebMIDI Send Test</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <script type="application/javascript" src="MIDITestUtils.js"></script> +</head> + +<body onload="runTests()"> + <script class="testbody" type="application/javascript"> + SimpleTest.waitForExplicitFinish(); + + async function runTests() { + await MIDITestUtils.permissionSetup(true); + const access = await navigator.requestMIDIAccess({ sysex: true }); + const output = access.outputs.get(await MIDITestUtils.stateTestOutputInfo.id); + + + // Note on(off). + output.send([0xff, 0x90, 0x00, 0x00, 0x90, 0x07, 0x00]); + + try { + output.send([0x00, 0x01]) + } catch (ex) { + ok(true, "Caught exception"); + } + + // Running status is not allowed in Web MIDI API. + SimpleTest.doesThrow(() => output.send([0x00, 0x01]), "Running status is not allowed in Web MIDI API."); + + // Unexpected End of Sysex. + SimpleTest.doesThrow(() => output.send([0xf7]), "Unexpected End of Sysex."); + + // Unexpected reserved status bytes. + SimpleTest.doesThrow(() => output.send([0xf4]), "Unexpected reserved status byte 0xf4."); + SimpleTest.doesThrow(() => output.send([0xf5]), "Unexpected reserved status byte 0xf5."); + SimpleTest.doesThrow(() => output.send([0xf9]), "Unexpected reserved status byte 0xf9."); + SimpleTest.doesThrow(() => output.send([0xfd]), "Unexpected reserved status byte 0xfd."); + + // Incomplete channel messages. + SimpleTest.doesThrow(() => output.send([0x80]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0x80, 0x00]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0x90]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0x90, 0x00]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xa0]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xa0, 0x00]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xb0]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xb0, 0x00]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xc0]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xd0]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xe0]), "Incomplete channel message."); + SimpleTest.doesThrow(() => output.send([0xe0, 0x00]), "Incomplete channel message."); + + // Incomplete system messages. + SimpleTest.doesThrow(() => output.send([0xf1]), "Incomplete system message."); + SimpleTest.doesThrow(() => output.send([0xf2]), "Incomplete system message."); + SimpleTest.doesThrow(() => output.send([0xf2, 0x00]), "Incomplete system message."); + SimpleTest.doesThrow(() => output.send([0xf3]), "Incomplete system message."); + + // Invalid data bytes. + SimpleTest.doesThrow(() => output.send([0x80, 0x80, 0x00]), "Incomplete system message."); + SimpleTest.doesThrow(() => output.send([0x80, 0x00, 0x80]), "Incomplete system message."); + + // Complete messages. + output.send([0x80, 0x00, 0x00]); + output.send([0x90, 0x00, 0x00]); + output.send([0xa0, 0x00, 0x00]); + output.send([0xb0, 0x00, 0x00]); + output.send([0xc0, 0x00]); + output.send([0xd0, 0x00]); + output.send([0xe0, 0x00, 0x00]); + + // Real-Time messages. + output.send([0xf8]); + output.send([0xfa]); + output.send([0xfb]); + output.send([0xfc]); + output.send([0xfe]); + output.send([0xff]); + + // Valid messages with Real-Time messages. + output.send([0x90, 0xff, 0xff, 0x00, 0xff, 0x01, 0xff, 0x80, 0xff, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff]); + + // Sysex messages. + output.send([0xf0, 0x00, 0x01, 0x02, 0x03, 0xf7]); + output.send([0xf0, 0xf8, 0xf7, 0xff]); + SimpleTest.doesThrow(() => output.send([0xf0, 0x80, 0xf7]), "Invalid sysex message."); + SimpleTest.doesThrow(() => output.send([0xf0, 0xf0, 0xf7]), "Double begin sysex message."); + SimpleTest.doesThrow(() => output.send([0xf0, 0xff, 0xf7, 0xf7]), "Double end sysex message."); + + // Reserved status bytes. + SimpleTest.doesThrow(() => output.send([0xf4, 0x80, 0x00, 0x00]), "Reserved status byte."); + SimpleTest.doesThrow(() => output.send([0x80, 0xf4, 0x00, 0x00]), "Reserved status byte."); + SimpleTest.doesThrow(() => output.send([0x80, 0x00, 0xf4, 0x00]), "Reserved status byte."); + SimpleTest.doesThrow(() => output.send([0x80, 0x00, 0x00, 0xf4]), "Reserved status byte."); + SimpleTest.doesThrow(() => output.send([0xf0, 0xff, 0xf4, 0xf7]), "Reserved status byte."); + + // Invalid timestamps. + SimpleTest.doesThrow(() => output.send([], NaN), "NaN timestamp."); + SimpleTest.doesThrow(() => output.send([], Infinity), "Infinity timestamp."); + SimpleTest.doesThrow(() => output.send(new Uint8Array(), NaN), "NaN timestamp."); + SimpleTest.doesThrow(() => output.send(new Uint8Array(), Infinity), "Infinity timestamp."); + + SimpleTest.finish(); + } + </script> +</body> + +</html> |