Bug 1231213 - Implement PRemoteWorkerController IPDL protocol and RemoteWorkerController{Parent,Child}. r=asuth

Differential Revision: https://phabricator.services.mozilla.com/D26168

--HG--
extra : moz-landing-system : lando

Author: perryjiang

dom/workers/remoteworkers/PRemoteWorkerController.ipdl

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+include protocol PBackground;
+
+include RemoteWorkerTypes;
+include ServiceWorkerOpArgs;
+
+namespace mozilla {
+namespace dom {
+
+protocol PRemoteWorkerController {
+  manager PBackground;
+
+ child:
+  async CreationFailed();
+
+  async CreationSucceeded();
+
+  async ErrorReceived(ErrorValue aError);
+
+  async Terminated();
+
+ parent:
+  async __delete__();
+
+  async Shutdown() returns (bool aOk);
+
+};
+
+}  // namespace dom
+}  // namespace mozilla

dom/workers/remoteworkers/RemoteWorkerController.cpp

@@ -6,6 +6,7 @@
 
 #include "mozilla/dom/MessagePort.h"
 #include "mozilla/dom/MessagePortParent.h"
+#include "mozilla/dom/RemoteWorkerTypes.h"
 #include "mozilla/ipc/BackgroundParent.h"
 #include "RemoteWorkerController.h"
 #include "RemoteWorkerManager.h"
@@ -26,7 +27,7 @@ already_AddRefed<RemoteWorkerController> RemoteWorkerController::Create(
   MOZ_ASSERT(aObserver);
 
   RefPtr<RemoteWorkerController> controller =
-      new RemoteWorkerController(aObserver);
+      new RemoteWorkerController(aData, aObserver);
 
   RefPtr<RemoteWorkerManager> manager = RemoteWorkerManager::GetOrCreate();
   MOZ_ASSERT(manager);
@@ -36,8 +37,13 @@ already_AddRefed<RemoteWorkerController> RemoteWorkerController::Create(
   return controller.forget();
 }
 
-RemoteWorkerController::RemoteWorkerController(RemoteWorkerObserver* aObserver)
-    : mObserver(aObserver), mState(ePending) {
+RemoteWorkerController::RemoteWorkerController(const RemoteWorkerData& aData,
+                                               RemoteWorkerObserver* aObserver)
+    : mObserver(aObserver),
+      mState(ePending),
+      mIsServiceWorker(aData.serviceWorkerData().type() ==
+                       OptionalServiceWorkerData::TServiceWorkerData) {
+  AssertIsInMainProcess();
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(XRE_IsParentProcess());
 }

dom/workers/remoteworkers/RemoteWorkerController.h

@@ -80,6 +80,8 @@ namespace dom {
 
 class ErrorValue;
 class MessagePortIdentifier;
+class RemoteWorkerControllerParent;
+class RemoteWorkerData;
 class RemoteWorkerManager;
 class RemoteWorkerParent;
 
@@ -97,6 +99,7 @@ class RemoteWorkerObserver {
 };
 
 class RemoteWorkerController final {
+  friend class RemoteWorkerControllerParent;
   friend class RemoteWorkerManager;
   friend class RemoteWorkerParent;
 
@@ -124,7 +127,9 @@ class RemoteWorkerController final {
   void Thaw();
 
  private:
-  explicit RemoteWorkerController(RemoteWorkerObserver* aObserver);
+  RemoteWorkerController(const RemoteWorkerData& aData,
+                         RemoteWorkerObserver* aObserver);
+
   ~RemoteWorkerController();
 
   void SetWorkerActor(RemoteWorkerParent* aActor);
@@ -150,6 +155,8 @@ class RemoteWorkerController final {
     eTerminated,
   } mState;
 
+  const bool mIsServiceWorker;
+
   struct Op {
     enum Type {
       eTerminate,

dom/workers/remoteworkers/RemoteWorkerControllerChild.cpp

@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RemoteWorkerControllerChild.h"
+
+#include <utility>
+
+#include "MainThreadUtils.h"
+#include "nsError.h"
+#include "nsThreadUtils.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Unused.h"
+
+namespace mozilla {
+
+using ipc::IPCResult;
+
+namespace dom {
+
+RemoteWorkerControllerChild::RemoteWorkerControllerChild(
+    RefPtr<RemoteWorkerObserver> aObserver)
+    : mObserver(std::move(aObserver)) {
+  AssertIsOnMainThread();
+  MOZ_ASSERT(mObserver);
+}
+
+void RemoteWorkerControllerChild::ActorDestroy(ActorDestroyReason aReason) {
+  AssertIsOnMainThread();
+
+  mIPCActive = false;
+
+  if (NS_WARN_IF(mObserver)) {
+    mObserver->ErrorReceived(NS_ERROR_DOM_ABORT_ERR);
+  }
+}
+
+IPCResult RemoteWorkerControllerChild::RecvCreationFailed() {
+  AssertIsOnMainThread();
+
+  if (mObserver) {
+    mObserver->CreationFailed();
+  }
+
+  return IPC_OK();
+}
+
+IPCResult RemoteWorkerControllerChild::RecvCreationSucceeded() {
+  AssertIsOnMainThread();
+
+  if (mObserver) {
+    mObserver->CreationSucceeded();
+  }
+
+  return IPC_OK();
+}
+
+IPCResult RemoteWorkerControllerChild::RecvErrorReceived(
+    const ErrorValue& aError) {
+  AssertIsOnMainThread();
+
+  if (mObserver) {
+    mObserver->ErrorReceived(aError);
+  }
+
+  return IPC_OK();
+}
+
+IPCResult RemoteWorkerControllerChild::RecvTerminated() {
+  AssertIsOnMainThread();
+
+  if (mObserver) {
+    mObserver->Terminated();
+  }
+
+  return IPC_OK();
+}
+
+void RemoteWorkerControllerChild::RevokeObserver(
+    RemoteWorkerObserver* aObserver) {
+  AssertIsOnMainThread();
+  MOZ_ASSERT(aObserver);
+  MOZ_ASSERT(aObserver == mObserver);
+
+  mObserver = nullptr;
+}
+
+void RemoteWorkerControllerChild::MaybeSendDelete() {
+  AssertIsOnMainThread();
+
+  if (!mIPCActive) {
+    return;
+  }
+
+  RefPtr<RemoteWorkerControllerChild> self = this;
+
+  SendShutdown()->Then(
+      GetCurrentThreadSerialEventTarget(), __func__,
+      [self = std::move(self)](const ShutdownPromise::ResolveOrRejectValue&) {
+        if (self->mIPCActive) {
+          Unused << self->Send__delete__(self);
+        }
+      });
+}
+
+}  // namespace dom
+}  // namespace mozilla

dom/workers/remoteworkers/RemoteWorkerControllerChild.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_remoteworkercontrollerchild_h__
+#define mozilla_dom_remoteworkercontrollerchild_h__
+
+#include "nsISupportsImpl.h"
+
+#include "RemoteWorkerController.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/PRemoteWorkerControllerChild.h"
+
+namespace mozilla {
+namespace dom {
+
+class RemoteWorkerControllerChild final : public PRemoteWorkerControllerChild {
+  friend class PRemoteWorkerControllerChild;
+
+ public:
+  NS_INLINE_DECL_REFCOUNTING(RemoteWorkerControllerChild)
+
+  explicit RemoteWorkerControllerChild(RefPtr<RemoteWorkerObserver> aObserver);
+
+  void Initialize();
+
+  void RevokeObserver(RemoteWorkerObserver* aObserver);
+
+  void MaybeSendDelete();
+
+ private:
+  ~RemoteWorkerControllerChild() = default;
+
+  void ActorDestroy(ActorDestroyReason aReason) override;
+
+  mozilla::ipc::IPCResult RecvCreationFailed();
+
+  mozilla::ipc::IPCResult RecvCreationSucceeded();
+
+  mozilla::ipc::IPCResult RecvErrorReceived(const ErrorValue& aError);
+
+  mozilla::ipc::IPCResult RecvTerminated();
+
+  RefPtr<RemoteWorkerObserver> mObserver;
+
+  bool mIPCActive = true;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_remoteworkercontrollerchild_h__

dom/workers/remoteworkers/RemoteWorkerControllerParent.cpp

@@ -0,0 +1,127 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RemoteWorkerControllerParent.h"
+
+#include <utility>
+
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsThreadUtils.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Unused.h"
+#include "mozilla/ipc/BackgroundParent.h"
+
+namespace mozilla {
+
+using namespace ipc;
+
+namespace dom {
+
+RemoteWorkerControllerParent::RemoteWorkerControllerParent(
+    const RemoteWorkerData& aRemoteWorkerData)
+    : mRemoteWorkerController(RemoteWorkerController::Create(
+          aRemoteWorkerData, this, 0 /* random process ID */)) {
+  AssertIsInMainProcess();
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mRemoteWorkerController);
+}
+
+RefPtr<RemoteWorkerParent> RemoteWorkerControllerParent::GetRemoteWorkerParent()
+    const {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mRemoteWorkerController);
+
+  return mRemoteWorkerController->mActor;
+}
+
+RemoteWorkerControllerParent::~RemoteWorkerControllerParent() {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(!mIPCActive);
+  MOZ_ASSERT(!mRemoteWorkerController);
+}
+
+IPCResult RemoteWorkerControllerParent::RecvShutdown(
+    ShutdownResolver&& aResolve) {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mIPCActive);
+  MOZ_ASSERT(mRemoteWorkerController);
+
+  mIPCActive = false;
+
+  mRemoteWorkerController->Shutdown();
+  mRemoteWorkerController = nullptr;
+
+  aResolve(true);
+
+  return IPC_OK();
+}
+
+IPCResult RemoteWorkerControllerParent::Recv__delete__() {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(!mIPCActive);
+  MOZ_ASSERT(!mRemoteWorkerController);
+
+  return IPC_OK();
+}
+
+void RemoteWorkerControllerParent::ActorDestroy(ActorDestroyReason aReason) {
+  AssertIsOnBackgroundThread();
+
+  if (NS_WARN_IF(mIPCActive)) {
+    mIPCActive = false;
+  }
+
+  if (NS_WARN_IF(mRemoteWorkerController)) {
+    mRemoteWorkerController->Shutdown();
+    mRemoteWorkerController = nullptr;
+  }
+}
+
+void RemoteWorkerControllerParent::CreationFailed() {
+  AssertIsOnBackgroundThread();
+
+  if (!mIPCActive) {
+    return;
+  }
+
+  Unused << SendCreationFailed();
+}
+
+void RemoteWorkerControllerParent::CreationSucceeded() {
+  AssertIsOnBackgroundThread();
+
+  if (!mIPCActive) {
+    return;
+  }
+
+  Unused << SendCreationSucceeded();
+}
+
+void RemoteWorkerControllerParent::ErrorReceived(const ErrorValue& aValue) {
+  AssertIsOnBackgroundThread();
+
+  if (!mIPCActive) {
+    return;
+  }
+
+  Unused << SendErrorReceived(aValue);
+}
+
+void RemoteWorkerControllerParent::Terminated() {
+  AssertIsOnBackgroundThread();
+
+  if (!mIPCActive) {
+    return;
+  }
+
+  Unused << SendTerminated();
+}
+
+}  // namespace dom
+}  // namespace mozilla