dom/workers/SharedWorker.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 "SharedWorker.h"
   7
   8 #include "nsPIDOMWindow.h"
   9
  10 #include "mozilla/Preferences.h"
  11 #include "mozilla/dom/SharedWorkerBinding.h"
  12 #include "nsContentUtils.h"
  13 #include "nsDOMEvent.h"
  14 #include "nsEventDispatcher.h"
  15 #include "nsIClassInfoImpl.h"
  16
  17 #include "MessagePort.h"
  18 #include "RuntimeService.h"
  19 #include "WorkerPrivate.h"
  20
  21 using mozilla::dom::Optional;
  22 using mozilla::dom::Sequence;
  23
  24 USING_WORKERS_NAMESPACE
  25
  26 namespace {
  27
  28 const char kSharedWorkersEnabledPref[] = "dom.workers.sharedWorkers.enabled";
  29
  30 } // anonymous namespace
  31
  32 SharedWorker::SharedWorker(nsPIDOMWindow* aWindow,
  33                            WorkerPrivate* aWorkerPrivate)
  34 : nsDOMEventTargetHelper(aWindow), mWorkerPrivate(aWorkerPrivate),
  35   mSuspended(false)
  36 {
  37   AssertIsOnMainThread();
  38   MOZ_ASSERT(aWorkerPrivate);
  39
  40   mSerial = aWorkerPrivate->NextMessagePortSerial();
  41
  42   mMessagePort = new MessagePort(aWindow, this, mSerial);
  43 }
  44
  45 SharedWorker::~SharedWorker()
  46 {
  47   AssertIsOnMainThread();
  48   MOZ_ASSERT(!mWorkerPrivate);
  49 }
  50
  51 //static
  52 bool
  53 SharedWorker::PrefEnabled()
  54 {
  55   AssertIsOnMainThread();
  56
  57   return mozilla::Preferences::GetBool(kSharedWorkersEnabledPref, false);
  58 }
  59
  60 // static
  61 already_AddRefed<SharedWorker>
  62 SharedWorker::Constructor(const GlobalObject& aGlobal, JSContext* aCx,
  63                           const nsAString& aScriptURL,
  64                           const mozilla::dom::Optional<nsAString>& aName,
  65                           ErrorResult& aRv)
  66 {
  67   AssertIsOnMainThread();
  68
  69   RuntimeService* rts = RuntimeService::GetOrCreateService();
  70   if (!rts) {
  71     aRv = NS_ERROR_NOT_AVAILABLE;
  72     return nullptr;
  73   }
  74
  75   nsString name;
  76   if (aName.WasPassed()) {
  77     name = aName.Value();
  78   }
  79
  80   nsRefPtr<SharedWorker> sharedWorker;
  81   nsresult rv = rts->CreateSharedWorker(aGlobal, aScriptURL, name,
  82                                         getter_AddRefs(sharedWorker));
  83   if (NS_FAILED(rv)) {
  84     aRv = rv;
  85     return nullptr;
  86   }
  87
  88   return sharedWorker.forget();
  89 }
  90
  91 already_AddRefed<MessagePort>
  92 SharedWorker::Port()
  93 {
  94   AssertIsOnMainThread();
  95
  96   nsRefPtr<MessagePort> messagePort = mMessagePort;
  97   return messagePort.forget();
  98 }
  99
 100 void
 101 SharedWorker::Suspend()
 102 {
 103   AssertIsOnMainThread();
 104   MOZ_ASSERT(!IsSuspended());
 105
 106   mSuspended = true;
 107 }
 108
 109 void
 110 SharedWorker::Resume()
 111 {
 112   AssertIsOnMainThread();
 113   MOZ_ASSERT(IsSuspended());
 114
 115   mSuspended = false;
 116
 117   if (!mSuspendedEvents.IsEmpty()) {
 118     nsTArray<nsCOMPtr<nsIDOMEvent>> events;
 119     mSuspendedEvents.SwapElements(events);
 120
 121     for (uint32_t index = 0; index < events.Length(); index++) {
 122       nsCOMPtr<nsIDOMEvent>& event = events[index];
 123       MOZ_ASSERT(event);
 124
 125       nsCOMPtr<nsIDOMEventTarget> target;
 126       if (NS_SUCCEEDED(event->GetTarget(getter_AddRefs(target)))) {
 127         bool ignored;
 128         if (NS_FAILED(target->DispatchEvent(event, &ignored))) {
 129           NS_WARNING("Failed to dispatch event!");
 130         }
 131       } else {
 132         NS_WARNING("Failed to get target!");
 133       }
 134     }
 135   }
 136 }
 137
 138 void
 139 SharedWorker::QueueEvent(nsIDOMEvent* aEvent)
 140 {
 141   AssertIsOnMainThread();
 142   MOZ_ASSERT(aEvent);
 143   MOZ_ASSERT(IsSuspended());
 144
 145   mSuspendedEvents.AppendElement(aEvent);
 146 }
 147
 148 void
 149 SharedWorker::Close()
 150 {
 151   AssertIsOnMainThread();
 152
 153   if (mMessagePort) {
 154     mMessagePort->Close();
 155   }
 156
 157   if (mWorkerPrivate) {
 158     AutoSafeJSContext cx;
 159     NoteDeadWorker(cx);
 160   }
 161 }
 162
 163 void
 164 SharedWorker::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
 165                           const Optional<Sequence<JS::Value>>& aTransferable,
 166                           ErrorResult& aRv)
 167 {
 168   AssertIsOnMainThread();
 169   MOZ_ASSERT(mWorkerPrivate);
 170   MOZ_ASSERT(mMessagePort);
 171
 172   mWorkerPrivate->PostMessageToMessagePort(aCx, mMessagePort->Serial(),
 173                                            aMessage, aTransferable, aRv);
 174 }
 175
 176 void
 177 SharedWorker::NoteDeadWorker(JSContext* aCx)
 178 {
 179   AssertIsOnMainThread();
 180   MOZ_ASSERT(mWorkerPrivate);
 181
 182   mWorkerPrivate->UnregisterSharedWorker(aCx, this);
 183   mWorkerPrivate = nullptr;
 184 }
 185
 186 NS_IMPL_ADDREF_INHERITED(SharedWorker, nsDOMEventTargetHelper)
 187 NS_IMPL_RELEASE_INHERITED(SharedWorker, nsDOMEventTargetHelper)
 188
 189 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(SharedWorker)
 190 NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
 191
 192 NS_IMPL_CYCLE_COLLECTION_CLASS(SharedWorker)
 193
 194 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SharedWorker,
 195                                                   nsDOMEventTargetHelper)
 196   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessagePort)
 197   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSuspendedEvents)
 198 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 199
 200 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SharedWorker,
 201                                                 nsDOMEventTargetHelper)
 202   tmp->Close();
 203   NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessagePort)
 204   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSuspendedEvents)
 205 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 206
 207 JSObject*
 208 SharedWorker::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope)
 209 {
 210   AssertIsOnMainThread();
 211
 212   return SharedWorkerBinding::Wrap(aCx, aScope, this);
 213 }
 214
 215 nsresult
 216 SharedWorker::PreHandleEvent(nsEventChainPreVisitor& aVisitor)
 217 {
 218   AssertIsOnMainThread();
 219
 220   nsIDOMEvent*& event = aVisitor.mDOMEvent;
 221
 222   if (IsSuspended() && event) {
 223     QueueEvent(event);
 224
 225     aVisitor.mCanHandle = false;
 226     aVisitor.mParentTarget = nullptr;
 227     return NS_OK;
 228   }
 229
 230   return nsDOMEventTargetHelper::PreHandleEvent(aVisitor);
 231 }