Bug 1745443 - Keep MIDI objects alive as long as there's some pending activity r=smaug

MIDI ports will be kept alive even without direct JS references to it under
the following conditions:
* They've not been explicitly closed (they're open or waiting to be)
* A statechange listener is present
* A midimessage listener is present for input ports only
* They've not been disconnected from their owner, when they are we implicitly
  close them

MIDI access objects will be kept alive even without direct JS references to it
under the following conditions:
* A statechange listener is present
* They've not been disconnected from their owner

Finally whenever a MIDI port is in use we disable the bfcache on the
document.

Differential Revision: https://phabricator.services.mozilla.com/D131352

Author: gabrielesvelto

dom/midi/MIDIAccess.cpp

@@ -63,6 +63,7 @@ MIDIAccess::MIDIAccess(nsPIDOMWindowInner* aWindow, bool aSysexEnabled,
       mHasShutdown(false) {
   MOZ_ASSERT(aWindow);
   MOZ_ASSERT(aAccessPromise);
+  KeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
 }
 
 MIDIAccess::~MIDIAccess() { Shutdown(); }
@@ -218,4 +219,10 @@ void MIDIAccess::RemovePortListener(MIDIAccessDestructionObserver* aObs) {
   mDestructionObservers.RemoveObserver(aObs);
 }
 
+void MIDIAccess::DisconnectFromOwner() {
+  IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
+
+  DOMEventTargetHelper::DisconnectFromOwner();
+}
+
 }  // namespace mozilla::dom

dom/midi/MIDIAccess.h

@@ -86,6 +86,8 @@ class MIDIAccess final : public DOMEventTargetHelper,
   void Shutdown();
   IMPL_EVENT_HANDLER(statechange);
 
+  void DisconnectFromOwner() override;
+
  private:
   MIDIAccess(nsPIDOMWindowInner* aWindow, bool aSysexEnabled,
              Promise* aAccessPromise);

dom/midi/MIDIInput.cpp

@@ -15,7 +15,7 @@
 namespace mozilla::dom {
 
 MIDIInput::MIDIInput(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent)
-    : MIDIPort(aWindow, aMIDIAccessParent) {}
+    : MIDIPort(aWindow, aMIDIAccessParent), mKeepAlive(false) {}
 
 // static
 MIDIInput* MIDIInput::Create(nsPIDOMWindowInner* aWindow,
@@ -49,14 +49,46 @@ void MIDIInput::Receive(const nsTArray<MIDIMessage>& aMsgs) {
   }
 }
 
-EventHandlerNonNull* MIDIInput::GetOnmidimessage() {
-  return GetEventHandler(nsGkAtoms::onmidimessage);
+void MIDIInput::StateChange() {
+  if (mPort->ConnectionState() == MIDIPortConnectionState::Open ||
+      (mPort->DeviceState() == MIDIPortDeviceState::Connected &&
+       mPort->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 (mPort->ConnectionState() != MIDIPortConnectionState::Open) {
+      mPort->SendOpen();
+    }
+  }
+
+  DOMEventTargetHelper::EventListenerAdded(aType);
+}
+
+void MIDIInput::DisconnectFromOwner() {
+  DontKeepAliveOnMidimessage();
+
+  MIDIPort::DisconnectFromOwner();
+}
+
+void MIDIInput::KeepAliveOnMidimessage() {
+  if (!mKeepAlive) {
+    mKeepAlive = true;
+    KeepAliveIfHasListenersFor(nsGkAtoms::onmidimessage);
+  }
 }
 
-void MIDIInput::SetOnmidimessage(EventHandlerNonNull* aCallback) {
-  SetEventHandler(nsGkAtoms::onmidimessage, aCallback);
-  if (mPort->ConnectionState() != MIDIPortConnectionState::Open) {
-    mPort->SendOpen();
+void MIDIInput::DontKeepAliveOnMidimessage() {
+  if (mKeepAlive) {
+    IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onmidimessage);
+    mKeepAlive = false;
   }
 }
 

dom/midi/MIDIInput.h

@@ -30,20 +30,23 @@ class MIDIInput final : public MIDIPort {
   JSObject* WrapObject(JSContext* aCx,
                        JS::Handle<JSObject*> aGivenProto) override;
 
-  // Since we need to be able to open the port on event handler assignment, we
-  // can't use IMPL_EVENT_HANDLER. We have to implement the event handler
-  // functions ourselves.
+  IMPL_EVENT_HANDLER(midimessage);
 
-  // Getter for the event handler callback
-  EventHandlerNonNull* GetOnmidimessage();
-  // Setter for the event handler callback
-  void SetOnmidimessage(EventHandlerNonNull* aCallback);
+  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

dom/midi/MIDIPort.cpp

@@ -11,8 +11,8 @@
 #include "mozilla/dom/MIDITypes.h"
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/dom/Document.h"
 #include "mozilla/dom/Promise.h"
-#include "mozilla/dom/MIDITypes.h"
 #include "mozilla/Unused.h"
 #include "nsISupportsImpl.h"  // for MOZ_COUNT_CTOR, MOZ_COUNT_DTOR
 
@@ -34,9 +34,16 @@ NS_IMPL_ADDREF_INHERITED(MIDIPort, DOMEventTargetHelper)
 NS_IMPL_RELEASE_INHERITED(MIDIPort, DOMEventTargetHelper)
 
 MIDIPort::MIDIPort(nsPIDOMWindowInner* aWindow, MIDIAccess* aMIDIAccessParent)
-    : DOMEventTargetHelper(aWindow), mMIDIAccessParent(aMIDIAccessParent) {
+    : DOMEventTargetHelper(aWindow),
+      mMIDIAccessParent(aMIDIAccessParent),
+      mKeepAlive(false) {
   MOZ_ASSERT(aWindow);
   MOZ_ASSERT(aMIDIAccessParent);
+
+  Document* aDoc = GetOwner()->GetExtantDoc();
+  if (aDoc) {
+    aDoc->DisallowBFCaching();
+  }
 }
 
 MIDIPort::~MIDIPort() {
@@ -156,6 +163,8 @@ void MIDIPort::Notify(const void_t& aVoid) {
 }
 
 void MIDIPort::FireStateChangeEvent() {
+  StateChange();
+
   MOZ_ASSERT(mPort);
   if (mPort->ConnectionState() == MIDIPortConnectionState::Open ||
       mPort->ConnectionState() == MIDIPortConnectionState::Pending) {
@@ -173,10 +182,20 @@ void MIDIPort::FireStateChangeEvent() {
       mClosingPromise = nullptr;
     }
   }
+
   if (mPort->DeviceState() == MIDIPortDeviceState::Connected &&
       mPort->ConnectionState() == MIDIPortConnectionState::Pending) {
     mPort->SendOpen();
   }
+
+  if (mPort->ConnectionState() == MIDIPortConnectionState::Open ||
+      (mPort->DeviceState() == MIDIPortDeviceState::Connected &&
+       mPort->ConnectionState() == MIDIPortConnectionState::Pending)) {
+    KeepAliveOnStatechange();
+  } else {
+    DontKeepAliveOnStatechange();
+  }
+
   // Fire MIDIAccess events first so that the port is no longer in the port
   // maps.
   if (mMIDIAccessParent) {
@@ -190,8 +209,31 @@ void MIDIPort::FireStateChangeEvent() {
   DispatchTrustedEvent(event);
 }
 
+void MIDIPort::StateChange() {}
+
 void MIDIPort::Receive(const nsTArray<MIDIMessage>& aMsg) {
   MOZ_CRASH("We should never get here!");
 }
 
+void MIDIPort::DisconnectFromOwner() {
+  DontKeepAliveOnStatechange();
+  mPort->SendClose();
+
+  DOMEventTargetHelper::DisconnectFromOwner();
+}
+
+void MIDIPort::KeepAliveOnStatechange() {
+  if (!mKeepAlive) {
+    mKeepAlive = true;
+    KeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
+  }
+}
+
+void MIDIPort::DontKeepAliveOnStatechange() {
+  if (mKeepAlive) {
+    IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
+    mKeepAlive = false;
+  }
+}
+
 }  // namespace mozilla::dom

dom/midi/MIDIPort.h

@@ -63,18 +63,25 @@ class MIDIPort : public DOMEventTargetHelper,
 
   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;
+
  protected:
   // IPC Actor corresponding to this class
   RefPtr<MIDIPortChild> mPort;
 
  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
@@ -88,6 +95,8 @@ class MIDIPort : public DOMEventTargetHelper,
   // 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