dom/midi/MIDIPort.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/MIDIPort.h"
   8 #include "mozilla/dom/MIDIConnectionEvent.h"
   9 #include "mozilla/dom/MIDIPortChild.h"
  10 #include "mozilla/dom/MIDIAccess.h"
  11 #include "mozilla/dom/MIDITypes.h"
  12 #include "mozilla/ipc/Endpoint.h"
  13 #include "mozilla/ipc/PBackgroundChild.h"
  14 #include "mozilla/ipc/BackgroundChild.h"
  15 #include "mozilla/dom/Document.h"
  16 #include "mozilla/dom/Promise.h"
  17 #include "nsContentUtils.h"
  18 #include "nsISupportsImpl.h"  // for MOZ_COUNT_CTOR, MOZ_COUNT_DTOR
  19 #include "MIDILog.h"
  20
  21 using namespace mozilla::ipc;
  22
  23 namespace mozilla::dom {
  24
  25 NS_IMPL_CYCLE_COLLECTION_INHERITED(MIDIPort, DOMEventTargetHelper,
  26                                    mOpeningPromise, mClosingPromise)
  27
  28 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(MIDIPort, DOMEventTargetHelper)
  29 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  30
  31 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MIDIPort)
  32   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  33 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  34
  35 NS_IMPL_ADDREF_INHERITED(MIDIPort, DOMEventTargetHelper)
  36 NS_IMPL_RELEASE_INHERITED(MIDIPort, DOMEventTargetHelper)
  37
  38 MIDIPort::MIDIPort(nsPIDOMWindowInner* aWindow)
  39     : DOMEventTargetHelper(aWindow),
  40       mMIDIAccessParent(nullptr),
  41       mKeepAlive(false) {
  42   MOZ_ASSERT(aWindow);
  43
  44   Document* aDoc = GetOwner()->GetExtantDoc();
  45   if (aDoc) {
  46     aDoc->DisallowBFCaching();
  47   }
  48 }
  49
  50 MIDIPort::~MIDIPort() {
  51   if (mMIDIAccessParent) {
  52     mMIDIAccessParent->RemovePortListener(this);
  53     mMIDIAccessParent = nullptr;
  54   }
  55   if (Port()) {
  56     // If the IPC port channel is still alive at this point, it means we're
  57     // probably CC'ing this port object. Send the shutdown message to also clean
  58     // up the IPC channel.
  59     Port()->SendShutdown();
  60   }
  61 }
  62
  63 bool MIDIPort::Initialize(const MIDIPortInfo& aPortInfo, bool aSysexEnabled,
  64                           MIDIAccess* aMIDIAccessParent) {
  65   MOZ_ASSERT(aMIDIAccessParent);
  66   nsCOMPtr<Document> document = GetDocumentIfCurrent();
  67   if (!document) {
  68     return false;
  69   }
  70
  71   nsCOMPtr<nsIURI> uri = document->GetDocumentURI();
  72   if (!uri) {
  73     return false;
  74   }
  75
  76   nsAutoCString origin;
  77   nsresult rv = nsContentUtils::GetWebExposedOriginSerialization(uri, origin);
  78   if (NS_FAILED(rv)) {
  79     return false;
  80   }
  81   RefPtr<MIDIPortChild> port =
  82       new MIDIPortChild(aPortInfo, aSysexEnabled, this);
  83   if (NS_FAILED(port->GenerateStableId(origin))) {
  84     return false;
  85   }
  86   PBackgroundChild* b = BackgroundChild::GetForCurrentThread();
  87   MOZ_ASSERT(b,
  88              "Should always have a valid BackgroundChild when creating a port "
  89              "object!");
  90
  91   // Create the endpoints and bind the one on the child side.
  92   Endpoint<PMIDIPortParent> parentEndpoint;
  93   Endpoint<PMIDIPortChild> childEndpoint;
  94   MOZ_ALWAYS_SUCCEEDS(
  95       PMIDIPort::CreateEndpoints(&parentEndpoint, &childEndpoint));
  96   MOZ_ALWAYS_TRUE(childEndpoint.Bind(port));
  97
  98   if (!b->SendCreateMIDIPort(std::move(parentEndpoint), aPortInfo,
  99                              aSysexEnabled)) {
 100     return false;
 101   }
 102
 103   mMIDIAccessParent = aMIDIAccessParent;
 104   mPortHolder.Init(port.forget());
 105   LOG("MIDIPort::Initialize (%s, %s)",
 106       NS_ConvertUTF16toUTF8(Port()->Name()).get(),
 107       MIDIPortTypeValues::strings[uint32_t(Port()->Type())].value);
 108   return true;
 109 }
 110
 111 void MIDIPort::UnsetIPCPort() {
 112   LOG("MIDIPort::UnsetIPCPort (%s, %s)",
 113       NS_ConvertUTF16toUTF8(Port()->Name()).get(),
 114       MIDIPortTypeValues::strings[uint32_t(Port()->Type())].value);
 115   mPortHolder.Clear();
 116 }
 117
 118 void MIDIPort::GetId(nsString& aRetVal) const {
 119   MOZ_ASSERT(Port());
 120   aRetVal = Port()->StableId();
 121 }
 122
 123 void MIDIPort::GetManufacturer(nsString& aRetVal) const {
 124   MOZ_ASSERT(Port());
 125   aRetVal = Port()->Manufacturer();
 126 }
 127
 128 void MIDIPort::GetName(nsString& aRetVal) const {
 129   MOZ_ASSERT(Port());
 130   aRetVal = Port()->Name();
 131 }
 132
 133 void MIDIPort::GetVersion(nsString& aRetVal) const {
 134   MOZ_ASSERT(Port());
 135   aRetVal = Port()->Version();
 136 }
 137
 138 MIDIPortType MIDIPort::Type() const {
 139   MOZ_ASSERT(Port());
 140   return Port()->Type();
 141 }
 142
 143 MIDIPortConnectionState MIDIPort::Connection() const {
 144   MOZ_ASSERT(Port());
 145   return Port()->ConnectionState();
 146 }
 147
 148 MIDIPortDeviceState MIDIPort::State() const {
 149   MOZ_ASSERT(Port());
 150   return Port()->DeviceState();
 151 }
 152
 153 bool MIDIPort::SysexEnabled() const {
 154   MOZ_ASSERT(Port());
 155   return Port()->SysexEnabled();
 156 }
 157
 158 already_AddRefed<Promise> MIDIPort::Open(ErrorResult& aError) {
 159   LOG("MIDIPort::Open");
 160   MOZ_ASSERT(Port());
 161   RefPtr<Promise> p;
 162   if (mOpeningPromise) {
 163     p = mOpeningPromise;
 164     return p.forget();
 165   }
 166   nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner());
 167   p = Promise::Create(go, aError);
 168   if (aError.Failed()) {
 169     return nullptr;
 170   }
 171   mOpeningPromise = p;
 172   Port()->SendOpen();
 173   return p.forget();
 174 }
 175
 176 already_AddRefed<Promise> MIDIPort::Close(ErrorResult& aError) {
 177   LOG("MIDIPort::Close");
 178   MOZ_ASSERT(Port());
 179   RefPtr<Promise> p;
 180   if (mClosingPromise) {
 181     p = mClosingPromise;
 182     return p.forget();
 183   }
 184   nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(GetOwner());
 185   p = Promise::Create(go, aError);
 186   if (aError.Failed()) {
 187     return nullptr;
 188   }
 189   mClosingPromise = p;
 190   Port()->SendClose();
 191   return p.forget();
 192 }
 193
 194 void MIDIPort::Notify(const void_t& aVoid) {
 195   LOG("MIDIPort::notify MIDIAccess shutting down, dropping reference.");
 196   // If we're getting notified, it means the MIDIAccess parent object is dead.
 197   // Nullify our copy.
 198   mMIDIAccessParent = nullptr;
 199 }
 200
 201 void MIDIPort::FireStateChangeEvent() {
 202   if (!GetOwner()) {
 203     return;  // Ignore changes once we've been disconnected from the owner
 204   }
 205
 206   StateChange();
 207
 208   MOZ_ASSERT(Port());
 209   if (Port()->ConnectionState() == MIDIPortConnectionState::Open ||
 210       Port()->ConnectionState() == MIDIPortConnectionState::Pending) {
 211     if (mOpeningPromise) {
 212       mOpeningPromise->MaybeResolve(this);
 213       mOpeningPromise = nullptr;
 214     }
 215   } else if (Port()->ConnectionState() == MIDIPortConnectionState::Closed) {
 216     if (mOpeningPromise) {
 217       mOpeningPromise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR);
 218       mOpeningPromise = nullptr;
 219     }
 220     if (mClosingPromise) {
 221       mClosingPromise->MaybeResolve(this);
 222       mClosingPromise = nullptr;
 223     }
 224   }
 225
 226   if (Port()->DeviceState() == MIDIPortDeviceState::Connected &&
 227       Port()->ConnectionState() == MIDIPortConnectionState::Pending) {
 228     Port()->SendOpen();
 229   }
 230
 231   if (Port()->ConnectionState() == MIDIPortConnectionState::Open ||
 232       (Port()->DeviceState() == MIDIPortDeviceState::Connected &&
 233        Port()->ConnectionState() == MIDIPortConnectionState::Pending)) {
 234     KeepAliveOnStatechange();
 235   } else {
 236     DontKeepAliveOnStatechange();
 237   }
 238
 239   // Fire MIDIAccess events first so that the port is no longer in the port
 240   // maps.
 241   if (mMIDIAccessParent) {
 242     mMIDIAccessParent->FireConnectionEvent(this);
 243   }
 244
 245   MIDIConnectionEventInit init;
 246   init.mPort = this;
 247   RefPtr<MIDIConnectionEvent> event(
 248       MIDIConnectionEvent::Constructor(this, u"statechange"_ns, init));
 249   DispatchTrustedEvent(event);
 250 }
 251
 252 void MIDIPort::StateChange() {}
 253
 254 void MIDIPort::Receive(const nsTArray<MIDIMessage>& aMsg) {
 255   MOZ_CRASH("We should never get here!");
 256 }
 257
 258 void MIDIPort::DisconnectFromOwner() {
 259   if (Port()) {
 260     Port()->SendClose();
 261   }
 262   DontKeepAliveOnStatechange();
 263
 264   DOMEventTargetHelper::DisconnectFromOwner();
 265 }
 266
 267 void MIDIPort::KeepAliveOnStatechange() {
 268   if (!mKeepAlive) {
 269     mKeepAlive = true;
 270     KeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
 271   }
 272 }
 273
 274 void MIDIPort::DontKeepAliveOnStatechange() {
 275   if (mKeepAlive) {
 276     IgnoreKeepAliveIfHasListenersFor(nsGkAtoms::onstatechange);
 277     mKeepAlive = false;
 278   }
 279 }
 280
 281 const nsString& MIDIPort::StableId() { return Port()->StableId(); }
 282
 283 }  // namespace mozilla::dom