dom/workers/WorkerEventTarget.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 "WorkerEventTarget.h"
   8 #include "WorkerPrivate.h"
   9 #include "WorkerRunnable.h"
  10
  11 #include "mozilla/dom/ReferrerInfo.h"
  12
  13 namespace mozilla::dom {
  14
  15 namespace {
  16
  17 class WrappedControlRunnable final : public WorkerControlRunnable {
  18   nsCOMPtr<nsIRunnable> mInner;
  19
  20   ~WrappedControlRunnable() = default;
  21
  22  public:
  23   WrappedControlRunnable(WorkerPrivate* aWorkerPrivate,
  24                          nsCOMPtr<nsIRunnable>&& aInner)
  25       : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
  26         mInner(std::move(aInner)) {}
  27
  28   virtual bool PreDispatch(WorkerPrivate* aWorkerPrivate) override {
  29     // Silence bad assertions, this can be dispatched from any thread.
  30     return true;
  31   }
  32
  33   virtual void PostDispatch(WorkerPrivate* aWorkerPrivate,
  34                             bool aDispatchResult) override {
  35     // Silence bad assertions, this can be dispatched from any thread.
  36   }
  37
  38   bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
  39     mInner->Run();
  40     return true;
  41   }
  42
  43   nsresult Cancel() override {
  44     nsCOMPtr<nsICancelableRunnable> cr = do_QueryInterface(mInner);
  45
  46     // If the inner runnable is not cancellable, then just do the normal
  47     // WorkerControlRunnable thing.  This will end up calling Run().
  48     if (!cr) {
  49       WorkerControlRunnable::Cancel();
  50       return NS_OK;
  51     }
  52
  53     // Otherwise call the inner runnable's Cancel() and treat this like
  54     // a WorkerRunnable cancel.  We can't call WorkerControlRunnable::Cancel()
  55     // in this case since that would result in both Run() and the inner
  56     // Cancel() being called.
  57     Unused << cr->Cancel();
  58     return WorkerRunnable::Cancel();
  59   }
  60 };
  61
  62 }  // anonymous namespace
  63
  64 NS_IMPL_ISUPPORTS(WorkerEventTarget, nsIEventTarget, nsISerialEventTarget)
  65
  66 WorkerEventTarget::WorkerEventTarget(WorkerPrivate* aWorkerPrivate,
  67                                      Behavior aBehavior)
  68     : mMutex("WorkerEventTarget"),
  69       mWorkerPrivate(aWorkerPrivate),
  70       mBehavior(aBehavior) {
  71   MOZ_DIAGNOSTIC_ASSERT(mWorkerPrivate);
  72 }
  73
  74 void WorkerEventTarget::ForgetWorkerPrivate(WorkerPrivate* aWorkerPrivate) {
  75   MutexAutoLock lock(mMutex);
  76   MOZ_DIAGNOSTIC_ASSERT(!mWorkerPrivate || mWorkerPrivate == aWorkerPrivate);
  77   mWorkerPrivate = nullptr;
  78 }
  79
  80 NS_IMETHODIMP
  81 WorkerEventTarget::DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) {
  82   nsCOMPtr<nsIRunnable> runnable(aRunnable);
  83   return Dispatch(runnable.forget(), aFlags);
  84 }
  85
  86 NS_IMETHODIMP
  87 WorkerEventTarget::Dispatch(already_AddRefed<nsIRunnable> aRunnable,
  88                             uint32_t aFlags) {
  89   nsCOMPtr<nsIRunnable> runnable(aRunnable);
  90
  91   MutexAutoLock lock(mMutex);
  92
  93   if (!mWorkerPrivate) {
  94     return NS_ERROR_FAILURE;
  95   }
  96
  97   if (mBehavior == Behavior::Hybrid) {
  98     RefPtr<WorkerRunnable> r =
  99         mWorkerPrivate->MaybeWrapAsWorkerRunnable(runnable.forget());
 100     if (r->Dispatch()) {
 101       return NS_OK;
 102     }
 103
 104     runnable = std::move(r);
 105   }
 106
 107   RefPtr<WorkerControlRunnable> r =
 108       new WrappedControlRunnable(mWorkerPrivate, std::move(runnable));
 109   if (!r->Dispatch()) {
 110     return NS_ERROR_FAILURE;
 111   }
 112
 113   return NS_OK;
 114 }
 115
 116 NS_IMETHODIMP
 117 WorkerEventTarget::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) {
 118   return NS_ERROR_NOT_IMPLEMENTED;
 119 }
 120
 121 NS_IMETHODIMP
 122 WorkerEventTarget::RegisterShutdownTask(nsITargetShutdownTask* aTask) {
 123   NS_ENSURE_ARG(aTask);
 124
 125   MutexAutoLock lock(mMutex);
 126
 127   // If mWorkerPrivate is gone, the event target is already late during
 128   // shutdown, return NS_ERROR_UNEXPECTED as documented in `nsIEventTarget.idl`.
 129   if (!mWorkerPrivate) {
 130     return NS_ERROR_UNEXPECTED;
 131   }
 132
 133   return mWorkerPrivate->RegisterShutdownTask(aTask);
 134 }
 135
 136 NS_IMETHODIMP
 137 WorkerEventTarget::UnregisterShutdownTask(nsITargetShutdownTask* aTask) {
 138   NS_ENSURE_ARG(aTask);
 139
 140   MutexAutoLock lock(mMutex);
 141
 142   if (!mWorkerPrivate) {
 143     return NS_ERROR_UNEXPECTED;
 144   }
 145
 146   return mWorkerPrivate->UnregisterShutdownTask(aTask);
 147 }
 148
 149 NS_IMETHODIMP_(bool)
 150 WorkerEventTarget::IsOnCurrentThreadInfallible() {
 151   MutexAutoLock lock(mMutex);
 152
 153   if (!mWorkerPrivate) {
 154     return false;
 155   }
 156
 157   return mWorkerPrivate->IsOnCurrentThread();
 158 }
 159
 160 NS_IMETHODIMP
 161 WorkerEventTarget::IsOnCurrentThread(bool* aIsOnCurrentThread) {
 162   MOZ_ASSERT(aIsOnCurrentThread);
 163   *aIsOnCurrentThread = IsOnCurrentThreadInfallible();
 164   return NS_OK;
 165 }
 166
 167 }  // namespace mozilla::dom