dom/workers/MessagePort.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "MessagePort.h"
   7
   8 #include "mozilla/dom/MessagePortBinding.h"
   9 #include "nsDOMEvent.h"
  10 #include "nsEventDispatcher.h"
  11
  12 #include "SharedWorker.h"
  13 #include "WorkerPrivate.h"
  14
  15 using mozilla::dom::EventHandlerNonNull;
  16 using mozilla::dom::MessagePortBase;
  17 using mozilla::dom::Optional;
  18 using mozilla::dom::Sequence;
  19
  20 USING_WORKERS_NAMESPACE
  21
  22 namespace {
  23
  24 class DelayedEventRunnable MOZ_FINAL : public WorkerRunnable
  25 {
  26   nsRefPtr<MessagePort> mMessagePort;
  27   nsTArray<nsCOMPtr<nsIDOMEvent>> mEvents;
  28
  29 public:
  30   DelayedEventRunnable(WorkerPrivate* aWorkerPrivate,
  31                        Target aTarget,
  32                        MessagePort* aMessagePort,
  33                        nsTArray<nsCOMPtr<nsIDOMEvent>>& aEvents)
  34   : WorkerRunnable(aWorkerPrivate, aTarget,
  35                    aTarget == WorkerThread ? ModifyBusyCount : UnchangedBusyCount,
  36                    SkipWhenClearing),
  37     mMessagePort(aMessagePort)
  38   {
  39     AssertIsOnMainThread();
  40     MOZ_ASSERT(aMessagePort);
  41     MOZ_ASSERT(aEvents.Length());
  42
  43     mEvents.SwapElements(aEvents);
  44   }
  45
  46   bool
  47   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
  48 };
  49
  50 } // anonymous namespace
  51
  52 MessagePort::MessagePort(nsPIDOMWindow* aWindow, SharedWorker* aSharedWorker,
  53                          uint64_t aSerial)
  54 : MessagePortBase(aWindow), mSharedWorker(aSharedWorker),
  55   mWorkerPrivate(nullptr), mSerial(aSerial), mStarted(false)
  56 {
  57   AssertIsOnMainThread();
  58   MOZ_ASSERT(aSharedWorker);
  59   SetIsDOMBinding();
  60 }
  61
  62 MessagePort::MessagePort(WorkerPrivate* aWorkerPrivate, uint64_t aSerial)
  63 : mWorkerPrivate(aWorkerPrivate), mSerial(aSerial), mStarted(false)
  64 {
  65   aWorkerPrivate->AssertIsOnWorkerThread();
  66   SetIsDOMBinding();
  67 }
  68
  69 MessagePort::~MessagePort()
  70 {
  71   Close();
  72 }
  73
  74 void
  75 MessagePort::PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage,
  76                             const Optional<Sequence<JS::Value>>& aTransferable,
  77                             ErrorResult& aRv)
  78 {
  79   AssertCorrectThread();
  80
  81   if (IsClosed()) {
  82     aRv = NS_ERROR_DOM_INVALID_STATE_ERR;
  83     return;
  84   }
  85
  86   if (mSharedWorker) {
  87     mSharedWorker->PostMessage(aCx, aMessage, aTransferable, aRv);
  88   }
  89   else {
  90     mWorkerPrivate->PostMessageToParentMessagePort(aCx, Serial(), aMessage,
  91                                                    aTransferable, aRv);
  92   }
  93 }
  94
  95 void
  96 MessagePort::Start()
  97 {
  98   AssertCorrectThread();
  99
 100   if (IsClosed()) {
 101     NS_WARNING("Called start() after calling close()!");
 102     return;
 103   }
 104
 105   if (mStarted) {
 106     return;
 107   }
 108
 109   mStarted = true;
 110
 111   if (!mQueuedEvents.IsEmpty()) {
 112     WorkerRunnable::Target target = WorkerRunnable::WorkerThread;
 113     WorkerPrivate* workerPrivate = mWorkerPrivate;
 114
 115     if (!workerPrivate) {
 116       target = WorkerRunnable::ParentThread;
 117       workerPrivate = mSharedWorker->GetWorkerPrivate();
 118     }
 119
 120     nsRefPtr<DelayedEventRunnable> runnable =
 121       new DelayedEventRunnable(workerPrivate, target, this, mQueuedEvents);
 122     runnable->Dispatch(nullptr);
 123   }
 124 }
 125
 126 void
 127 MessagePort::Close()
 128 {
 129   AssertCorrectThread();
 130
 131   if (!IsClosed()) {
 132     CloseInternal();
 133   }
 134 }
 135
 136 void
 137 MessagePort::QueueEvent(nsIDOMEvent* aEvent)
 138 {
 139   AssertCorrectThread();
 140   MOZ_ASSERT(aEvent);
 141   MOZ_ASSERT(!IsClosed());
 142   MOZ_ASSERT(!mStarted);
 143
 144   mQueuedEvents.AppendElement(aEvent);
 145 }
 146
 147 EventHandlerNonNull*
 148 MessagePort::GetOnmessage()
 149 {
 150   AssertCorrectThread();
 151
 152   return NS_IsMainThread() ? GetEventHandler(nsGkAtoms::onmessage, EmptyString())
 153                            : GetEventHandler(nullptr, NS_LITERAL_STRING("message"));
 154 }
 155
 156 void
 157 MessagePort::SetOnmessage(EventHandlerNonNull* aCallback)
 158 {
 159   AssertCorrectThread();
 160
 161   if (NS_IsMainThread()) {
 162     SetEventHandler(nsGkAtoms::onmessage, EmptyString(), aCallback);
 163   }
 164   else {
 165     SetEventHandler(nullptr, NS_LITERAL_STRING("message"), aCallback);
 166   }
 167
 168   Start();
 169 }
 170
 171 already_AddRefed<MessagePortBase>
 172 MessagePort::Clone()
 173 {
 174   NS_WARNING("Haven't implemented structured clone for these ports yet!");
 175   return nullptr;
 176 }
 177
 178 void
 179 MessagePort::CloseInternal()
 180 {
 181   AssertCorrectThread();
 182   MOZ_ASSERT(!IsClosed());
 183   MOZ_ASSERT_IF(mStarted, mQueuedEvents.IsEmpty());
 184
 185   NS_WARN_IF_FALSE(mStarted, "Called close() before start()!");
 186
 187   if (!mStarted) {
 188     mQueuedEvents.Clear();
 189   }
 190
 191   mSharedWorker = nullptr;
 192   mWorkerPrivate = nullptr;
 193 }
 194
 195 #ifdef DEBUG
 196 void
 197 MessagePort::AssertCorrectThread() const
 198 {
 199   if (IsClosed()) {
 200     return; // Can't assert anything if we nulled out our pointers.
 201   }
 202
 203   MOZ_ASSERT((mSharedWorker || mWorkerPrivate) &&
 204              !(mSharedWorker && mWorkerPrivate));
 205
 206   if (mSharedWorker) {
 207     AssertIsOnMainThread();
 208   }
 209   else {
 210     mWorkerPrivate->AssertIsOnWorkerThread();
 211   }
 212 }
 213 #endif
 214
 215 NS_IMPL_ADDREF_INHERITED(MessagePort, nsDOMEventTargetHelper)
 216 NS_IMPL_RELEASE_INHERITED(MessagePort, nsDOMEventTargetHelper)
 217
 218 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(MessagePort)
 219 NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
 220
 221 NS_IMPL_CYCLE_COLLECTION_CLASS(MessagePort)
 222
 223 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MessagePort,
 224                                                   nsDOMEventTargetHelper)
 225   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSharedWorker)
 226   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mQueuedEvents)
 227 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 228
 229 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MessagePort,
 230                                                 nsDOMEventTargetHelper)
 231   tmp->Close();
 232 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 233
 234 JSObject*
 235 MessagePort::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope)
 236 {
 237   AssertCorrectThread();
 238
 239   return MessagePortBinding::Wrap(aCx, aScope, this);
 240 }
 241
 242 nsresult
 243 MessagePort::PreHandleEvent(nsEventChainPreVisitor& aVisitor)
 244 {
 245   AssertCorrectThread();
 246
 247   nsIDOMEvent*& event = aVisitor.mDOMEvent;
 248
 249   if (event) {
 250     bool preventDispatch = false;
 251
 252     if (IsClosed()) {
 253       preventDispatch = true;
 254     } else if (NS_IsMainThread() && mSharedWorker->IsSuspended()) {
 255       mSharedWorker->QueueEvent(event);
 256       preventDispatch = true;
 257     } else if (!mStarted) {
 258       QueueEvent(event);
 259       preventDispatch = true;
 260     }
 261
 262     if (preventDispatch) {
 263       aVisitor.mCanHandle = false;
 264       aVisitor.mParentTarget = nullptr;
 265       return NS_OK;
 266     }
 267   }
 268
 269   return nsDOMEventTargetHelper::PreHandleEvent(aVisitor);
 270 }
 271
 272 bool
 273 DelayedEventRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
 274 {
 275   MOZ_ASSERT(mMessagePort);
 276   mMessagePort->AssertCorrectThread();
 277   MOZ_ASSERT(mEvents.Length());
 278
 279   bool ignored;
 280   for (uint32_t i = 0; i < mEvents.Length(); i++) {
 281     mMessagePort->DispatchEvent(mEvents[i], &ignored);
 282   }
 283
 284   return true;
 285 }