dom/workers/WorkerDebuggerManager.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 "WorkerDebuggerManager.h"
   8
   9 #include "nsSimpleEnumerator.h"
  10
  11 #include "mozilla/dom/JSExecutionManager.h"
  12 #include "mozilla/ClearOnShutdown.h"
  13 #include "mozilla/Services.h"
  14 #include "mozilla/StaticPtr.h"
  15
  16 #include "WorkerDebugger.h"
  17 #include "WorkerPrivate.h"
  18 #include "nsIObserverService.h"
  19
  20 namespace mozilla::dom {
  21
  22 namespace {
  23
  24 class RegisterDebuggerMainThreadRunnable final : public mozilla::Runnable {
  25   WorkerPrivate* mWorkerPrivate;
  26   bool mNotifyListeners;
  27
  28  public:
  29   RegisterDebuggerMainThreadRunnable(WorkerPrivate* aWorkerPrivate,
  30                                      bool aNotifyListeners)
  31       : mozilla::Runnable("RegisterDebuggerMainThreadRunnable"),
  32         mWorkerPrivate(aWorkerPrivate),
  33         mNotifyListeners(aNotifyListeners) {}
  34
  35  private:
  36   ~RegisterDebuggerMainThreadRunnable() = default;
  37
  38   NS_IMETHOD
  39   Run() override {
  40     WorkerDebuggerManager* manager = WorkerDebuggerManager::Get();
  41     MOZ_ASSERT(manager);
  42
  43     manager->RegisterDebuggerMainThread(mWorkerPrivate, mNotifyListeners);
  44     return NS_OK;
  45   }
  46 };
  47
  48 class UnregisterDebuggerMainThreadRunnable final : public mozilla::Runnable {
  49   WorkerPrivate* mWorkerPrivate;
  50
  51  public:
  52   explicit UnregisterDebuggerMainThreadRunnable(WorkerPrivate* aWorkerPrivate)
  53       : mozilla::Runnable("UnregisterDebuggerMainThreadRunnable"),
  54         mWorkerPrivate(aWorkerPrivate) {}
  55
  56  private:
  57   ~UnregisterDebuggerMainThreadRunnable() = default;
  58
  59   NS_IMETHOD
  60   Run() override {
  61     WorkerDebuggerManager* manager = WorkerDebuggerManager::Get();
  62     MOZ_ASSERT(manager);
  63
  64     manager->UnregisterDebuggerMainThread(mWorkerPrivate);
  65     return NS_OK;
  66   }
  67 };
  68
  69 static StaticRefPtr<WorkerDebuggerManager> gWorkerDebuggerManager;
  70
  71 } /* anonymous namespace */
  72
  73 class WorkerDebuggerEnumerator final : public nsSimpleEnumerator {
  74   nsTArray<RefPtr<WorkerDebugger>> mDebuggers;
  75   uint32_t mIndex;
  76
  77  public:
  78   explicit WorkerDebuggerEnumerator(
  79       const nsTArray<RefPtr<WorkerDebugger>>& aDebuggers)
  80       : mDebuggers(aDebuggers.Clone()), mIndex(0) {}
  81
  82   NS_DECL_NSISIMPLEENUMERATOR
  83
  84   const nsID& DefaultInterface() override {
  85     return NS_GET_IID(nsIWorkerDebugger);
  86   }
  87
  88  private:
  89   ~WorkerDebuggerEnumerator() override = default;
  90 };
  91
  92 NS_IMETHODIMP
  93 WorkerDebuggerEnumerator::HasMoreElements(bool* aResult) {
  94   *aResult = mIndex < mDebuggers.Length();
  95   return NS_OK;
  96 };
  97
  98 NS_IMETHODIMP
  99 WorkerDebuggerEnumerator::GetNext(nsISupports** aResult) {
 100   if (mIndex == mDebuggers.Length()) {
 101     return NS_ERROR_FAILURE;
 102   }
 103
 104   mDebuggers.ElementAt(mIndex++).forget(aResult);
 105   return NS_OK;
 106 };
 107
 108 WorkerDebuggerManager::WorkerDebuggerManager()
 109     : mMutex("WorkerDebuggerManager::mMutex") {
 110   AssertIsOnMainThread();
 111 }
 112
 113 WorkerDebuggerManager::~WorkerDebuggerManager() { AssertIsOnMainThread(); }
 114
 115 // static
 116 already_AddRefed<WorkerDebuggerManager> WorkerDebuggerManager::GetInstance() {
 117   RefPtr<WorkerDebuggerManager> manager = WorkerDebuggerManager::GetOrCreate();
 118   return manager.forget();
 119 }
 120
 121 // static
 122 WorkerDebuggerManager* WorkerDebuggerManager::GetOrCreate() {
 123   AssertIsOnMainThread();
 124
 125   if (!gWorkerDebuggerManager) {
 126     // The observer service now owns us until shutdown.
 127     gWorkerDebuggerManager = new WorkerDebuggerManager();
 128     if (NS_SUCCEEDED(gWorkerDebuggerManager->Init())) {
 129       ClearOnShutdown(&gWorkerDebuggerManager);
 130     } else {
 131       NS_WARNING("Failed to initialize worker debugger manager!");
 132       gWorkerDebuggerManager = nullptr;
 133     }
 134   }
 135
 136   return gWorkerDebuggerManager;
 137 }
 138
 139 WorkerDebuggerManager* WorkerDebuggerManager::Get() {
 140   MOZ_ASSERT(gWorkerDebuggerManager);
 141   return gWorkerDebuggerManager;
 142 }
 143
 144 NS_IMPL_ISUPPORTS(WorkerDebuggerManager, nsIObserver, nsIWorkerDebuggerManager);
 145
 146 NS_IMETHODIMP
 147 WorkerDebuggerManager::Observe(nsISupports* aSubject, const char* aTopic,
 148                                const char16_t* aData) {
 149   if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
 150     Shutdown();
 151     return NS_OK;
 152   }
 153
 154   MOZ_ASSERT_UNREACHABLE("Unknown observer topic!");
 155   return NS_OK;
 156 }
 157
 158 NS_IMETHODIMP
 159 WorkerDebuggerManager::GetWorkerDebuggerEnumerator(
 160     nsISimpleEnumerator** aResult) {
 161   AssertIsOnMainThread();
 162
 163   RefPtr<WorkerDebuggerEnumerator> enumerator =
 164       new WorkerDebuggerEnumerator(mDebuggers);
 165   enumerator.forget(aResult);
 166   return NS_OK;
 167 }
 168
 169 NS_IMETHODIMP
 170 WorkerDebuggerManager::AddListener(
 171     nsIWorkerDebuggerManagerListener* aListener) {
 172   AssertIsOnMainThread();
 173
 174   MutexAutoLock lock(mMutex);
 175
 176   if (mListeners.Contains(aListener)) {
 177     return NS_ERROR_INVALID_ARG;
 178   }
 179
 180   mListeners.AppendElement(aListener);
 181   return NS_OK;
 182 }
 183
 184 NS_IMETHODIMP
 185 WorkerDebuggerManager::RemoveListener(
 186     nsIWorkerDebuggerManagerListener* aListener) {
 187   AssertIsOnMainThread();
 188
 189   MutexAutoLock lock(mMutex);
 190
 191   if (!mListeners.Contains(aListener)) {
 192     return NS_OK;
 193   }
 194
 195   mListeners.RemoveElement(aListener);
 196   return NS_OK;
 197 }
 198
 199 nsresult WorkerDebuggerManager::Init() {
 200   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
 201   NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE);
 202
 203   nsresult rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
 204   NS_ENSURE_SUCCESS(rv, rv);
 205
 206   return NS_OK;
 207 }
 208
 209 void WorkerDebuggerManager::Shutdown() {
 210   AssertIsOnMainThread();
 211
 212   MutexAutoLock lock(mMutex);
 213
 214   mListeners.Clear();
 215 }
 216
 217 void WorkerDebuggerManager::RegisterDebugger(WorkerPrivate* aWorkerPrivate) {
 218   aWorkerPrivate->AssertIsOnParentThread();
 219
 220   if (NS_IsMainThread()) {
 221     // When the parent thread is the main thread, it will always block until all
 222     // register liseners have been called, since it cannot continue until the
 223     // call to RegisterDebuggerMainThread returns.
 224     //
 225     // In this case, it is always safe to notify all listeners on the main
 226     // thread, even if there were no listeners at the time this method was
 227     // called, so we can always pass true for the value of aNotifyListeners.
 228     // This avoids having to lock mMutex to check whether mListeners is empty.
 229     RegisterDebuggerMainThread(aWorkerPrivate, true);
 230   } else {
 231     // We guarantee that if any register listeners are called, the worker does
 232     // not start running until all register listeners have been called. To
 233     // guarantee this, the parent thread should block until all register
 234     // listeners have been called.
 235     //
 236     // However, to avoid overhead when the debugger is not being used, the
 237     // parent thread will only block if there were any listeners at the time
 238     // this method was called. As a result, we should not notify any listeners
 239     // on the main thread if there were no listeners at the time this method was
 240     // called, because the parent will not be blocking in that case.
 241     bool hasListeners = false;
 242     {
 243       MutexAutoLock lock(mMutex);
 244
 245       hasListeners = !mListeners.IsEmpty();
 246     }
 247
 248     nsCOMPtr<nsIRunnable> runnable =
 249         new RegisterDebuggerMainThreadRunnable(aWorkerPrivate, hasListeners);
 250     MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL));
 251
 252     if (hasListeners) {
 253       aWorkerPrivate->WaitForIsDebuggerRegistered(true);
 254     }
 255   }
 256 }
 257
 258 void WorkerDebuggerManager::UnregisterDebugger(WorkerPrivate* aWorkerPrivate) {
 259   aWorkerPrivate->AssertIsOnParentThread();
 260
 261   if (NS_IsMainThread()) {
 262     UnregisterDebuggerMainThread(aWorkerPrivate);
 263   } else {
 264     nsCOMPtr<nsIRunnable> runnable =
 265         new UnregisterDebuggerMainThreadRunnable(aWorkerPrivate);
 266     MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL));
 267
 268     aWorkerPrivate->WaitForIsDebuggerRegistered(false);
 269   }
 270 }
 271
 272 void WorkerDebuggerManager::RegisterDebuggerMainThread(
 273     WorkerPrivate* aWorkerPrivate, bool aNotifyListeners) {
 274   AssertIsOnMainThread();
 275
 276   RefPtr<WorkerDebugger> debugger = new WorkerDebugger(aWorkerPrivate);
 277   mDebuggers.AppendElement(debugger);
 278
 279   aWorkerPrivate->SetDebugger(debugger);
 280
 281   if (aNotifyListeners) {
 282     for (const auto& listener : CloneListeners()) {
 283       listener->OnRegister(debugger);
 284     }
 285   }
 286
 287   aWorkerPrivate->SetIsDebuggerRegistered(true);
 288 }
 289
 290 void WorkerDebuggerManager::UnregisterDebuggerMainThread(
 291     WorkerPrivate* aWorkerPrivate) {
 292   AssertIsOnMainThread();
 293
 294   // There is nothing to do here if the debugger was never succesfully
 295   // registered. We need to check this on the main thread because the worker
 296   // does not wait for the registration to complete if there were no listeners
 297   // installed when it started.
 298   if (!aWorkerPrivate->IsDebuggerRegistered()) {
 299     return;
 300   }
 301
 302   RefPtr<WorkerDebugger> debugger = aWorkerPrivate->Debugger();
 303   mDebuggers.RemoveElement(debugger);
 304
 305   aWorkerPrivate->SetDebugger(nullptr);
 306
 307   for (const auto& listener : CloneListeners()) {
 308     listener->OnUnregister(debugger);
 309   }
 310
 311   debugger->Close();
 312   aWorkerPrivate->SetIsDebuggerRegistered(false);
 313 }
 314
 315 uint32_t WorkerDebuggerManager::GetDebuggersLength() const {
 316   return mDebuggers.Length();
 317 }
 318
 319 WorkerDebugger* WorkerDebuggerManager::GetDebuggerAt(uint32_t aIndex) const {
 320   return mDebuggers.SafeElementAt(aIndex, nullptr);
 321 }
 322
 323 nsTArray<nsCOMPtr<nsIWorkerDebuggerManagerListener>>
 324 WorkerDebuggerManager::CloneListeners() {
 325   MutexAutoLock lock(mMutex);
 326
 327   return mListeners.Clone();
 328 }
 329
 330 }  // namespace mozilla::dom