tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

RemoteWorkerControllerChild.cpp (3903B)

      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 "RemoteWorkerControllerChild.h"
      8 
      9 #include <utility>
     10 
     11 #include "MainThreadUtils.h"
     12 #include "ServiceWorkerPrivate.h"
     13 #include "mozilla/Assertions.h"
     14 #include "mozilla/RefPtr.h"
     15 #include "mozilla/dom/PFetchEventOpChild.h"
     16 #include "nsError.h"
     17 #include "nsThreadUtils.h"
     18 
     19 namespace mozilla {
     20 
     21 using ipc::IPCResult;
     22 
     23 namespace dom {
     24 
     25 RemoteWorkerControllerChild::RemoteWorkerControllerChild(
     26    RefPtr<RemoteWorkerObserver> aObserver)
     27    : mObserver(std::move(aObserver)) {
     28  AssertIsOnMainThread();
     29  mRemoteWorkerLaunchStart = TimeStamp::Now();
     30  MOZ_ASSERT(mObserver);
     31 }
     32 
     33 PFetchEventOpChild* RemoteWorkerControllerChild::AllocPFetchEventOpChild(
     34    const ParentToParentServiceWorkerFetchEventOpArgs& aArgs) {
     35  MOZ_CRASH("PFetchEventOpChild actors must be manually constructed!");
     36  return nullptr;
     37 }
     38 
     39 TimeStamp RemoteWorkerControllerChild::GetRemoteWorkerLaunchStart() {
     40  MOZ_ASSERT(mRemoteWorkerLaunchStart);
     41  return mRemoteWorkerLaunchStart;
     42 }
     43 
     44 TimeStamp RemoteWorkerControllerChild::GetRemoteWorkerLaunchEnd() {
     45  MOZ_ASSERT(mRemoteWorkerLaunchEnd);
     46  return mRemoteWorkerLaunchEnd;
     47 }
     48 
     49 bool RemoteWorkerControllerChild::DeallocPFetchEventOpChild(
     50    PFetchEventOpChild* aActor) {
     51  AssertIsOnMainThread();
     52  MOZ_ASSERT(aActor);
     53 
     54  delete aActor;
     55  return true;
     56 }
     57 
     58 void RemoteWorkerControllerChild::ActorDestroy(ActorDestroyReason aReason) {
     59  AssertIsOnMainThread();
     60 
     61  mIPCActive = false;
     62 
     63  if (NS_WARN_IF(mObserver)) {
     64    mObserver->ErrorReceived(NS_ERROR_DOM_ABORT_ERR);
     65  }
     66 }
     67 
     68 IPCResult RemoteWorkerControllerChild::RecvCreationFailed() {
     69  AssertIsOnMainThread();
     70 
     71  if (mObserver) {
     72    mObserver->CreationFailed();
     73  }
     74 
     75  return IPC_OK();
     76 }
     77 
     78 IPCResult RemoteWorkerControllerChild::RecvCreationSucceeded() {
     79  AssertIsOnMainThread();
     80  mRemoteWorkerLaunchEnd = TimeStamp::Now();
     81 
     82  if (mObserver) {
     83    mObserver->CreationSucceeded();
     84  }
     85 
     86  return IPC_OK();
     87 }
     88 
     89 IPCResult RemoteWorkerControllerChild::RecvErrorReceived(
     90    const ErrorValue& aError) {
     91  AssertIsOnMainThread();
     92  mRemoteWorkerLaunchEnd = TimeStamp::Now();
     93 
     94  if (mObserver) {
     95    mObserver->ErrorReceived(aError);
     96  }
     97 
     98  return IPC_OK();
     99 }
    100 
    101 IPCResult RemoteWorkerControllerChild::RecvTerminated() {
    102  AssertIsOnMainThread();
    103 
    104  if (mObserver) {
    105    mObserver->Terminated();
    106  }
    107 
    108  return IPC_OK();
    109 }
    110 
    111 IPCResult RemoteWorkerControllerChild::RecvSetServiceWorkerSkipWaitingFlag(
    112    SetServiceWorkerSkipWaitingFlagResolver&& aResolve) {
    113  AssertIsOnMainThread();
    114 
    115  if (mObserver) {
    116    static_cast<ServiceWorkerPrivate*>(mObserver.get())
    117        ->SetSkipWaitingFlag()
    118        ->Then(GetCurrentSerialEventTarget(), __func__,
    119               [resolve = std::move(aResolve)](
    120                   const GenericPromise::ResolveOrRejectValue& aResult) {
    121                 resolve(aResult.IsResolve() ? aResult.ResolveValue() : false);
    122               });
    123 
    124    return IPC_OK();
    125  }
    126 
    127  aResolve(false);
    128 
    129  return IPC_OK();
    130 }
    131 
    132 void RemoteWorkerControllerChild::RevokeObserver(
    133    RemoteWorkerObserver* aObserver) {
    134  AssertIsOnMainThread();
    135  MOZ_ASSERT(aObserver);
    136  MOZ_ASSERT(aObserver == mObserver);
    137 
    138  mObserver = nullptr;
    139 }
    140 
    141 void RemoteWorkerControllerChild::MaybeSendDelete() {
    142  AssertIsOnMainThread();
    143 
    144  if (!mIPCActive) {
    145    return;
    146  }
    147 
    148  RefPtr<RemoteWorkerControllerChild> self = this;
    149 
    150  SendShutdown()->Then(
    151      GetCurrentSerialEventTarget(), __func__,
    152      [self = std::move(self)](const ShutdownPromise::ResolveOrRejectValue&) {
    153        if (self->mIPCActive) {
    154          (void)self->Send__delete__(self);
    155        }
    156      });
    157 }
    158 
    159 }  // namespace dom
    160 }  // namespace mozilla