From a84b101f1725c412a8400d07807a44bde764701f Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 20:42:31 -0800
Subject: [PATCH 01/26] Setup sub-root sw scope in dev sandbox

* Setup the WebSDK in the dev sandbox under a sub directory scope.
   - This is to confirm the current limitation that this SDK does not
   work if the page currently viewing isn't under control of the sw.
   - The following last message is shown in this example
   - installWorker - Awaiting on navigator.serviceWorker's 'controllerchange' event
* Added OneSignalWorker.js under push/onesignal/ as a possible sub-dir
someone may want to use onesignal under.
* Modified the expresss example's server.js to support the new
subfoldered files.
---
 express_webpack/index.html                                 | 7 +++++++
 .../push/onesignal/OneSignalSDKUpdaterWorker.js            | 1 +
 express_webpack/push/onesignal/OneSignalSDKWorker.js       | 1 +
 express_webpack/server.js                                  | 4 ++--
 src/helpers/ContextHelper.ts                               | 4 ++--
 5 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 express_webpack/push/onesignal/OneSignalSDKUpdaterWorker.js
 create mode 100644 express_webpack/push/onesignal/OneSignalSDKWorker.js
diff --git a/express_webpack/index.html b/express_webpack/index.html
index 3910c4bfe..a160c559f 100644
--- a/express_webpack/index.html
+++ b/express_webpack/index.html
@@ -2,6 +2,8 @@
 <html lang="en">
 <script src="/sdks/Dev-OneSignalSDK.js" async=""></script>
 <script>
+    const SERVICE_WORKER_PATH = "push/onesignal/";
+
     function getUrlQueryParam(name) {
         var url = window.location.href;
         // This is just to avoid case sensitiveness
@@ -14,9 +16,14 @@
         if (!results[2]) return '';
         return decodeURIComponent(results[2].replace(/\+/g, " "));
     }
+
     const appId = getUrlQueryParam('app_id');
     var OneSignal = window.OneSignal || [];
     OneSignal.push(function() {
+      OneSignal.SERVICE_WORKER_PARAM = { scope: "/" + SERVICE_WORKER_PATH };
+      OneSignal.SERVICE_WORKER_UPDATER_PATH = SERVICE_WORKER_PATH + "OneSignalSDKUpdaterWorker.js";
+      OneSignal.SERVICE_WORKER_PATH = SERVICE_WORKER_PATH + "OneSignalSDKWorker.js";
+
       OneSignal.init({
           appId,
           notifyButton: {
diff --git a/express_webpack/push/onesignal/OneSignalSDKUpdaterWorker.js b/express_webpack/push/onesignal/OneSignalSDKUpdaterWorker.js
new file mode 100644
index 000000000..0c83e65aa
--- /dev/null
+++ b/express_webpack/push/onesignal/OneSignalSDKUpdaterWorker.js
@@ -0,0 +1 @@
+importScripts("https://localhost:4001/sdks/Dev-OneSignalSDKWorker.js");
diff --git a/express_webpack/push/onesignal/OneSignalSDKWorker.js b/express_webpack/push/onesignal/OneSignalSDKWorker.js
new file mode 100644
index 000000000..0c83e65aa
--- /dev/null
+++ b/express_webpack/push/onesignal/OneSignalSDKWorker.js
@@ -0,0 +1 @@
+importScripts("https://localhost:4001/sdks/Dev-OneSignalSDKWorker.js");
diff --git a/express_webpack/server.js b/express_webpack/server.js
index df9bc6581..f2b88d55d 100644
--- a/express_webpack/server.js
+++ b/express_webpack/server.js
@@ -17,11 +17,11 @@ app.get('/', (req, res) => {
 })
 
 app.get('/sdks/:file', (req, res) => {
-    res.sendFile(SDK_FILES+req.params.file);
+    res.sendFile(SDK_FILES + req.params.file);
 });
 
 app.get('/:file', (req, res) => {
-    res.sendFile(SDK_FILES+req.params.file);
+    res.sendFile(req.params.file);
 });
 
 https.createServer(options, app).listen(4001, () => console.log("express_webpack: listening on port 4001 (https)"));
diff --git a/src/helpers/ContextHelper.ts b/src/helpers/ContextHelper.ts
index 93c73ff10..2c1fbd36d 100644
--- a/src/helpers/ContextHelper.ts
+++ b/src/helpers/ContextHelper.ts
@@ -19,9 +19,9 @@ export class ContextHelper {
     if (config.userConfig) {
       if (config.userConfig.path) {
         serviceWorkerManagerConfig.workerAPath =
-          new Path(`${config.userConfig.path}${envPrefix}${config.userConfig.serviceWorkerPath}`);
+          new Path(`${config.userConfig.path}${config.userConfig.serviceWorkerPath}`);
         serviceWorkerManagerConfig.workerBPath =
-          new Path(`${config.userConfig.path}${envPrefix}${config.userConfig.serviceWorkerUpdaterPath}`);
+          new Path(`${config.userConfig.path}${config.userConfig.serviceWorkerUpdaterPath}`);
       }
       if (config.userConfig.serviceWorkerParam) {
         serviceWorkerManagerConfig.registrationOptions = config.userConfig.serviceWorkerParam;

From 57e1833fd92913737cd47dc947655057c20d5f9a Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 20:59:29 -0800
Subject: [PATCH 02/26] rm page control awaiting on sw install

* No need to wait for page control for any of the sw features
OneSignal uses.
---
 src/managers/ServiceWorkerManager.ts | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index fdac2f3dd..9827d2fee 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -297,36 +297,8 @@ export class ServiceWorkerManager {
       return;
     }
 
-    const preInstallWorkerState = await this.getActiveState();
     await this.installAlternatingWorker();
 
-    await new Promise<void>(async resolve => {
-      const postInstallWorkerState = await this.getActiveState();
-      Log.debug(
-        "installWorker - Comparing pre and post states",
-        preInstallWorkerState,
-        postInstallWorkerState
-      );
-
-      if (preInstallWorkerState !== postInstallWorkerState &&
-          postInstallWorkerState !== ServiceWorkerActiveState.Installing) {
-        resolve();
-      }
-      else {
-        Log.debug("installWorker - Awaiting on navigator.serviceWorker's 'controllerchange' event");
-        navigator.serviceWorker.addEventListener('controllerchange', async e => {
-          const postInstallWorkerState = await this.getActiveState();
-          if (postInstallWorkerState !== preInstallWorkerState &&
-            postInstallWorkerState !== ServiceWorkerActiveState.Installing) {
-            resolve();
-          }
-          else {
-            Log.error("installWorker - SW's 'controllerchange' fired but no state change!");
-          }
-        });
-      }
-    });
-
     if ((await this.getActiveState()) === ServiceWorkerActiveState.WorkerB) {
       // If the worker is Worker B, reinstall Worker A
       await this.installAlternatingWorker();

From f4e32c2a32b9e6c9e9cf89989a36f74adc8f9efd Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 21:15:42 -0800
Subject: [PATCH 03/26] rm waitUntilWorkerControlsPage

* We do NOT need to wait to setup a listner to get messages sent from
a ServiceWorker
   - In fact it can be setup before we even install one.
* It isn't clear if we need to wait for a specific ServiceWorker state
before we use `postMessage`.
   - We can't use "controllerchange" as this is the specific requirment
   we want to drop.
   - This didn't have an issue while testing this SDK as a whole at this
   point but doesn't mean there could be an issue.
   - TODO to confirm in before considering this PR complete.
---
 src/libraries/WorkerMessenger.ts | 38 ++------------------------------
 1 file changed, 2 insertions(+), 36 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index b262645b6..873758f91 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -140,10 +140,8 @@ export class WorkerMessenger {
         } as any);
       }
     } else {
-      if (!(await this.isWorkerControllingPage())) {
-        Log.debug("[Worker Messenger] The page is not controlled by the service worker yet. Waiting...", (<ServiceWorkerGlobalScope><any>self).registration);
-      }
-      await this.waitUntilWorkerControlsPage();
+      // TODO:THIS_PR: Might need a replacement for "controllerchange.
+      ///  It isn't clear if browsers will give the message to the SW if done too soon after installing it.
       Log.debug(`[Worker Messenger] [Page -> SW] Unicasting '${command.toString()}' to service worker.`)
       this.directPostMessageToSW(command, payload);
     }
@@ -189,10 +187,6 @@ export class WorkerMessenger {
    */
   private async listenForPage(listenIfPageUncontrolled?: boolean) {
     if (!listenIfPageUncontrolled) {
-      if (!(await this.isWorkerControllingPage())) {
-        Log.debug(`(${location.origin}) [Worker Messenger] The page is not controlled by the service worker yet. Waiting...`, (<ServiceWorkerGlobalScope><any>self).registration);
-      }
-      await this.waitUntilWorkerControlsPage();
       Log.debug(`(${location.origin}) [Worker Messenger] The page is now controlled by the service worker.`);
     }
 
@@ -327,32 +321,4 @@ export class WorkerMessenger {
         workerState === ServiceWorkerActiveState.WorkerB;
     }
   }
-
-  /**
-   * For pages, waits until one of our workers is activated.
-   *
-   * For service workers, waits until the registration is active.
-   */
-  async waitUntilWorkerControlsPage() {
-    return new Promise<void>(async resolve => {
-      if (await this.isWorkerControllingPage())
-        resolve();
-      else {
-        const env = SdkEnvironment.getWindowEnv();
-
-        if (env === WindowEnvironmentKind.ServiceWorker) {
-          self.addEventListener('activate', async (_e: Event) => {
-            if (await this.isWorkerControllingPage())
-              resolve();
-          });
-        }
-        else {
-          navigator.serviceWorker.addEventListener('controllerchange', async (_e: Event) => {
-            if (await this.isWorkerControllingPage())
-              resolve();
-          });
-        }
-      }
-    });
-  }
 }

From 18fe8aed9ac32d3dc4cbff5426fe82cbcaf06912 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 21:20:10 -0800
Subject: [PATCH 04/26] rm isWorkerControllingPage

* This is no longer being used any more and is dead code
* We also never need to know this as we don't want to depend on
our SW being in control of the page.
---
 src/libraries/WorkerMessenger.ts | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 873758f91..c3f6323d9 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -295,30 +295,4 @@ export class WorkerMessenger {
       this.replies.deleteAllListenerRecords();
     }
   }
-
-
-  /*
-    Service worker postMessage() communication relies on the property
-    navigator.serviceWorker.controller to be non-null. The controller property
-    references the active service worker controlling the page. Without this
-    property, there is no service worker to message.
-
-    The controller property is set when a service worker has successfully
-    registered, installed, and activated a worker, and when a page isn't loaded
-    in a hard refresh mode bypassing the cache.
-
-    It's possible for a service worker to take a second page load to be fully
-    activated.
-   */
-  async isWorkerControllingPage(): Promise<boolean> {
-    const env = SdkEnvironment.getWindowEnv();
-
-    if (env === WindowEnvironmentKind.ServiceWorker)
-      return !!(<ServiceWorkerGlobalScope><any>self).registration.active;
-    else {
-      const workerState = await this.context.serviceWorkerManager.getActiveState();
-      return workerState === ServiceWorkerActiveState.WorkerA ||
-        workerState === ServiceWorkerActiveState.WorkerB;
-    }
-  }
 }

From a2838ccdd605d756e1256e28ea52af35a2e87041 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 22:53:35 -0800
Subject: [PATCH 05/26] mv getRegistration to ServicWorkerManager

* Moved getRegistration to ServicWorkerManager
* getRegistration requires a scope to get the correct sw that only the
ServiceWorkerManager instance can provide
* We don't want to use location.href any more as this is the
ServiceWorker that is in control of the page which may not be
OneSIgnal's.
---
 src/helpers/InitHelper.ts               | 3 +--
 src/helpers/ServiceWorkerHelper.ts      | 5 -----
 src/helpers/SubscriptionHelper.ts       | 3 +--
 src/helpers/page/ServiceWorkerHelper.ts | 9 ++++-----
 src/managers/SdkEnvironment.ts          | 2 +-
 src/managers/ServiceWorkerManager.ts    | 7 ++++---
 src/managers/SubscriptionManager.ts     | 4 ++--
 7 files changed, 13 insertions(+), 20 deletions(-)

diff --git a/src/helpers/InitHelper.ts b/src/helpers/InitHelper.ts
index d2c901455..09aae8062 100755
--- a/src/helpers/InitHelper.ts
+++ b/src/helpers/InitHelper.ts
@@ -24,7 +24,6 @@ import Log from '../libraries/Log';
 import Environment from '../Environment';
 import Bell from '../bell/Bell';
 import { CustomLink } from '../CustomLink';
-import { ServiceWorkerManager } from "../managers/ServiceWorkerManager";
 import SubscriptionPopupHost from "../modules/frames/SubscriptionPopupHost";
 import { OneSignalUtils } from "../utils/OneSignalUtils";
 import { DeprecatedApiError, DeprecatedApiReason } from "../errors/DeprecatedApiError";
@@ -261,7 +260,7 @@ export default class InitHelper {
       !await SdkEnvironment.isFrameContextInsecure()
     ) {
       try {
-        const registration = await ServiceWorkerManager.getRegistration();
+        const registration = await OneSignal.context.serviceWorkerManager.getRegistration();
         if (registration && registration.active) {
           await OneSignal.context.serviceWorkerManager.establishServiceWorkerChannel();
         }
diff --git a/src/helpers/ServiceWorkerHelper.ts b/src/helpers/ServiceWorkerHelper.ts
index 1f7732d47..ee62119f8 100755
--- a/src/helpers/ServiceWorkerHelper.ts
+++ b/src/helpers/ServiceWorkerHelper.ts
@@ -8,7 +8,6 @@ import Database from "../services/Database";
 import { SerializedPushDeviceRecord, PushDeviceRecord } from "../models/PushDeviceRecord";
 import { NotificationClicked } from "../models/Notification";
 import { RawPushSubscription } from '../models/RawPushSubscription';
-import PageServiceWorkerHelper from "./page/ServiceWorkerHelper";
 import { OutcomesConfig } from "../models/Outcomes";
 import OutcomesHelper from './shared/OutcomesHelper';
 import { cancelableTimeout, CancelableTimeoutPromise } from './sw/CancelableTimeout';
@@ -17,10 +16,6 @@ import { OSServiceWorkerFields } from "../service-worker/types";
 declare var self: ServiceWorkerGlobalScope & OSServiceWorkerFields;
 
 export default class ServiceWorkerHelper {
-  public static async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
-    return await PageServiceWorkerHelper.getRegistration();
-  }
-
   public static getServiceWorkerHref(
     workerState: ServiceWorkerActiveState,
     config: ServiceWorkerManagerConfig): string {
diff --git a/src/helpers/SubscriptionHelper.ts b/src/helpers/SubscriptionHelper.ts
index 0eae84ee2..e294cc903 100755
--- a/src/helpers/SubscriptionHelper.ts
+++ b/src/helpers/SubscriptionHelper.ts
@@ -15,7 +15,6 @@ import LocalStorage from '../utils/LocalStorage';
 import { SessionOrigin } from "../models/Session";
 import MainHelper from "./MainHelper";
 import { PushDeviceRecord } from "../models/PushDeviceRecord";
-import PageServiceWorkerHelper from "./page/ServiceWorkerHelper";
 import { EnvironmentInfo } from "../context/browser/models/EnvironmentInfo";
 import { Browser } from "../context/browser/models/Browser";
 
@@ -163,7 +162,7 @@ export default class SubscriptionHelper {
   }
 
   static async getRawPushSubscriptionFromServiceWorkerRegistration(): Promise<RawPushSubscription | null> {
-    const registration = await PageServiceWorkerHelper.getRegistration();
+    const registration = await OneSignal.context.serviceWorkerManager.getRegistration();
     if (!registration) {
       return null;
     }
diff --git a/src/helpers/page/ServiceWorkerHelper.ts b/src/helpers/page/ServiceWorkerHelper.ts
index f261586bd..81fb87f6f 100644
--- a/src/helpers/page/ServiceWorkerHelper.ts
+++ b/src/helpers/page/ServiceWorkerHelper.ts
@@ -1,14 +1,13 @@
 import Log from "../../libraries/Log";
 
 export default class ServiceWorkerHelper {
-  // Gets details on the service-worker (if any) that controls the current page
-  static async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
+  // Get the service worker based on a scope as a domain can have none to many service workers.
+  static async getRegistration(scope: string): Promise<ServiceWorkerRegistration | null | undefined> {
     try {
-      // location.href is used for <base> tag compatibility when it is set to a different origin
-      return await navigator.serviceWorker.getRegistration(location.href);
+      return await navigator.serviceWorker.getRegistration(scope);
     } catch (e) {
       // This could be null in an HTTP context or error if the user doesn't accept cookies
-      Log.warn("[Service Worker Status] Error Checking service worker registration", location.href, e);
+      Log.warn("[Service Worker Status] Error Checking service worker registration", scope, e);
       return null;
     }
   }
diff --git a/src/managers/SdkEnvironment.ts b/src/managers/SdkEnvironment.ts
index f9be3daa0..70547aeaf 100644
--- a/src/managers/SdkEnvironment.ts
+++ b/src/managers/SdkEnvironment.ts
@@ -170,7 +170,7 @@ export default class SdkEnvironment {
     }
 
     // Will be null if there was an issue retrieving a status
-    const registrationResult = await ServiceWorkerHelper.getRegistration();
+    const registrationResult = await OneSignal.context.serviceWorkerManager.getRegistration();
     return !registrationResult;
   }
 
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 9827d2fee..4e6d29480 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -17,6 +17,7 @@ import ServiceWorkerHelper, { ServiceWorkerActiveState, ServiceWorkerManagerConf
 import { ContextSWInterface } from '../models/ContextSW';
 import { Utils } from "../context/shared/utils/Utils";
 import { PageVisibilityRequest, PageVisibilityResponse } from "../models/Session";
+import PageServiceWorkerHelper from "../helpers/page/ServiceWorkerHelper";
 
 export class ServiceWorkerManager {
   private context: ContextSWInterface;
@@ -28,8 +29,8 @@ export class ServiceWorkerManager {
   }
 
   // Gets details on the service-worker (if any) that controls the current page
-  public static async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
-    return await ServiceWorkerHelper.getRegistration();
+  public async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
+    return await PageServiceWorkerHelper.getRegistration(this.config.registrationOptions.scope);
   }
 
   public async getActiveState(): Promise<ServiceWorkerActiveState> {
@@ -87,7 +88,7 @@ export class ServiceWorkerManager {
       }
     }
 
-    const workerRegistration = await ServiceWorkerManager.getRegistration();
+    const workerRegistration = await this.context.serviceWorkerManager.getRegistration();
     if (!workerRegistration) {
       /*
         A site may have a service worker nested at /folder1/folder2/folder3, while the user is
diff --git a/src/managers/SubscriptionManager.ts b/src/managers/SubscriptionManager.ts
index 539aa104f..12dc39f2e 100644
--- a/src/managers/SubscriptionManager.ts
+++ b/src/managers/SubscriptionManager.ts
@@ -639,7 +639,7 @@ export class SubscriptionManager {
         return false;
     }
 
-    const serviceWorkerRegistration = await ServiceWorkerManager.getRegistration();
+    const serviceWorkerRegistration = await this.context.serviceWorkerManager.getRegistration();
     if (!serviceWorkerRegistration)
       return false;
 
@@ -743,7 +743,7 @@ export class SubscriptionManager {
     }
 
     const workerState = await this.context.serviceWorkerManager.getActiveState();
-    const workerRegistration = await ServiceWorkerManager.getRegistration();
+    const workerRegistration = await this.context.serviceWorkerManager.getRegistration();
     const notificationPermission =
       await this.context.permissionManager.getNotificationPermission(this.context.appConfig.safariWebId);
     const isWorkerActive = (

From 321acdbd76fff7ad06b73233ed30c58be93e8e9a Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 22:56:21 -0800
Subject: [PATCH 06/26] Update directPostMessageToSW to use the correct sw

* Changed `navigator.serviceWorker.controller` to `this.context.serviceWorkerManager.getRegistration()`
* This ensure we get the correct OneSignal ServiceWorker.
* Added error handling that was missing before
   - This was also required to get some tests to pass
---
 src/libraries/WorkerMessenger.ts | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index c3f6323d9..4ba265d2d 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -147,9 +147,20 @@ export class WorkerMessenger {
     }
   }
 
-  public directPostMessageToSW(command: WorkerMessengerCommand, payload?: WorkerMessengerPayload) {
+  public async directPostMessageToSW(command: WorkerMessengerCommand, payload?: WorkerMessengerPayload): Promise<void> {
     Log.debug(`[Worker Messenger] [Page -> SW] Direct command '${command.toString()}' to service worker.`);
-    navigator.serviceWorker!.controller!.postMessage({
+    
+    const serviceWorker = await this.context.serviceWorkerManager.getRegistration();
+    if (!serviceWorker) {
+      Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorker to postMessage!");
+      return;
+    }
+    if (!serviceWorker.active) {
+      Log.error("`[Worker Messenger] [Page -> SW] ServiceWorker found but it could not get active instance to postMessage!");
+      return;
+    }
+
+    serviceWorker.active.postMessage({
       command: command,
       payload: payload
     });

From 6cafaed9040cc201d022e27c0bb50e78763a683b Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 23:09:36 -0800
Subject: [PATCH 07/26] Fixed tests from getRegistration change

* getRegistration is now only defined on ServiceWorkerManager. This
requires a few things now:
   - An instance to ServiceWorkerManager
   - A OneSignal.context, due to above.
* Removed location.href check as we dont' call this any more
* postMessage does now get called in tests due the usage of
getRegistration, this is ok but had to remove NotImplementedError
from the mock so tests do not break.
---
 .../support/mocks/service-workers/models/MockServiceWorker.ts | 1 -
 test/support/tester/sinonSandboxUtils.ts                      | 2 +-
 test/unit/managers/ServiceWorkerManager.ts                    | 4 +---
 test/unit/managers/SubscriptionManager.ts                     | 4 ++--
 test/unit/modules/sdkEnvironment.ts                           | 4 ++++
 5 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/test/support/mocks/service-workers/models/MockServiceWorker.ts b/test/support/mocks/service-workers/models/MockServiceWorker.ts
index c96e978d4..ae875f471 100644
--- a/test/support/mocks/service-workers/models/MockServiceWorker.ts
+++ b/test/support/mocks/service-workers/models/MockServiceWorker.ts
@@ -23,7 +23,6 @@ export class MockServiceWorker implements ServiceWorker {
   }
 
   postMessage(message: any, transfer: Array<Transferable> | PostMessageOptions): void {
-    throw new NotImplementedError();
   }
 
   removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
diff --git a/test/support/tester/sinonSandboxUtils.ts b/test/support/tester/sinonSandboxUtils.ts
index 6c66d896b..c8889a609 100644
--- a/test/support/tester/sinonSandboxUtils.ts
+++ b/test/support/tester/sinonSandboxUtils.ts
@@ -55,7 +55,7 @@ export function stubServiceWorkerInstallation(sinonSandbox: SinonSandbox) {
     .get(() => new Promise((resolve) => { resolve(swRegistration); }));
   sinonSandbox.stub(ServiceWorkerManager.prototype, "getActiveState")
     .resolves(ServiceWorkerActiveState.WorkerA);
-  sinonSandbox.stub(ServiceWorkerManager, "getRegistration")
+  sinonSandbox.stub(ServiceWorkerManager.prototype, "getRegistration")
     .resolves(swRegistration);
   sinonSandbox.stub(WorkerMessenger.prototype, "unicast").resolves();
 }
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index af4d3c99f..a3a3e4bb8 100644
--- a/test/unit/managers/ServiceWorkerManager.ts
+++ b/test/unit/managers/ServiceWorkerManager.ts
@@ -57,8 +57,6 @@ test.beforeEach(async function() {
 });
 
 test.afterEach(function () {
-  if (getRegistrationStub.callCount > 0)
-    sandbox.assert.alwaysCalledWithExactly(getRegistrationStub, location.href);
   sandbox.restore();
 });
 
@@ -431,6 +429,6 @@ test('ServiceWorkerManager.getRegistration() handles throws by returning null',
   getRegistrationStub.returns(new Promise(() => {
     throw new Error("HTTP NOT SUPPORTED");
   }));
-  const result = await ServiceWorkerManager.getRegistration();
+  const result = await OneSignal.context.serviceWorkerManager.getRegistration();
   t.is(result, null);
 });
diff --git a/test/unit/managers/SubscriptionManager.ts b/test/unit/managers/SubscriptionManager.ts
index 48a12a13d..0ff7473e7 100644
--- a/test/unit/managers/SubscriptionManager.ts
+++ b/test/unit/managers/SubscriptionManager.ts
@@ -74,7 +74,7 @@ async function testCase(
 
   // Register a mock service worker to access push subscription
   await navigator.serviceWorker.register('/worker.js');
-  const registration: any = await ServiceWorkerManager.getRegistration();
+  const registration: any = await OneSignal.context.serviceWorkerManager.getRegistration();
 
   // There should be no existing subscription
   const existingSubscription = await registration.pushManager.getSubscription();
@@ -357,7 +357,7 @@ test('device ID is available after register event', async t => {
     null
   );
 
-  const serviceWorkerRegistration = await ServiceWorkerManager.getRegistration();
+  const serviceWorkerRegistration = await OneSignal.context.serviceWorkerManager.getRegistration();
   const pushSubscription = await serviceWorkerRegistration.pushManager.getSubscription();
   const rawPushSubscription = RawPushSubscription.setFromW3cSubscription(pushSubscription);
   const randomPlayerId = Random.getRandomUuid();
diff --git a/test/unit/modules/sdkEnvironment.ts b/test/unit/modules/sdkEnvironment.ts
index 8916b1f12..8d1b9c587 100644
--- a/test/unit/modules/sdkEnvironment.ts
+++ b/test/unit/modules/sdkEnvironment.ts
@@ -106,6 +106,10 @@ test('getIntegration should return Secure in HTTPS top-level frame', async t =>
 });
 
 test('getIntegration should return Secure in HTTPS child frame under top-level HTTPS frame', async t => {
+  const OneSignal: any = await TestEnvironment.initialize({
+    httpOrHttps: HttpHttpsEnvironment.Http
+  });
+  TestEnvironment.mockInternalOneSignal();
   const browser = await TestEnvironment.stubDomEnvironment();
   browser.reconfigureWindow(window, { top: 'another frame' as any });
   browser.changeURL(window, "https://site.com");

From 19f62140d48ac8272b4c91392973f5ca0031bd7b Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 23:44:12 -0800
Subject: [PATCH 08/26] Replaced serviceWorker.ready with getRegistration

* This corrects which sw we use to subscribe and unsubscribe from push
* navigator.serviceWorker.controller gets the service worker in control
of the page which isn't what we want.
    - We want to use the serviceWorkerManager.getRegistration() so we
    get the sw OneSignal registered.
* Clean up tests using serviceWorker.ready
---
 src/managers/SubscriptionManager.ts      |  9 +++++---
 src/utils.ts                             | 29 +++++++++++++-----------
 test/support/tester/sinonSandboxUtils.ts |  2 --
 test/unit/meta/mockServiceWorker.ts      |  1 -
 4 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/managers/SubscriptionManager.ts b/src/managers/SubscriptionManager.ts
index 12dc39f2e..e003ba548 100644
--- a/src/managers/SubscriptionManager.ts
+++ b/src/managers/SubscriptionManager.ts
@@ -382,9 +382,12 @@ export class SubscriptionManager {
       throw err;
     }
 
-    Log.debug('Waiting for the service worker to activate...');
-    const workerRegistration = await navigator.serviceWorker.ready;
-    Log.debug('Service worker is ready to continue subscribing.');
+    Log.debug('[Subscription Manager] Getting OneSignal service Worker...');
+    const workerRegistration = await this.context.serviceWorkerManager.getRegistration();
+    if (!workerRegistration) {
+      throw new Error("OneSignal service worker not found!");
+    }
+    Log.debug('[Subscription Manager] Service worker is ready to continue subscribing.');
 
     return await this.subscribeWithVapidKey(workerRegistration.pushManager, subscriptionStrategy);
   }
diff --git a/src/utils.ts b/src/utils.ts
index 93718a3c6..cec3517c8 100755
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -300,19 +300,22 @@ export function unsubscribeFromPush() {
         });
       });
     } else {
-      if (!navigator.serviceWorker || !navigator.serviceWorker.controller)
-        return Promise.resolve();
-
-      return navigator.serviceWorker.ready
-                      .then(registration => registration.pushManager)
-                      .then(pushManager => pushManager.getSubscription())
-                      .then((subscription: any) => {
-                        if (subscription) {
-                          return subscription.unsubscribe();
-                        } else {
-                          return Promise.resolve();
-                        }
-                      });
+      return OneSignal.context.serviceWorkerManager.getRegistration()
+              .then((serviceWorker : ServiceWorkerRegistration | null | undefined) => {
+                if (!serviceWorker) {
+                  return Promise.resolve();
+                }
+                return serviceWorker
+              })
+              .then(registration => registration.pushManager)
+              .then(pushManager => pushManager.getSubscription())
+              .then((subscription: any) => {
+                if (subscription) {
+                  return subscription.unsubscribe();
+                } else {
+                  return Promise.resolve();
+                }
+              });
     }
   }
 }
diff --git a/test/support/tester/sinonSandboxUtils.ts b/test/support/tester/sinonSandboxUtils.ts
index c8889a609..d68aeb158 100644
--- a/test/support/tester/sinonSandboxUtils.ts
+++ b/test/support/tester/sinonSandboxUtils.ts
@@ -51,8 +51,6 @@ export function stubServiceWorkerInstallation(sinonSandbox: SinonSandbox) {
 
   sinonSandbox.stub(SubscriptionManager.prototype, "subscribeWithVapidKey")
     .resolves(TestEnvironment.getFakeRawPushSubscription());
-  sinonSandbox.stub((global as any).navigator.serviceWorker, "ready")
-    .get(() => new Promise((resolve) => { resolve(swRegistration); }));
   sinonSandbox.stub(ServiceWorkerManager.prototype, "getActiveState")
     .resolves(ServiceWorkerActiveState.WorkerA);
   sinonSandbox.stub(ServiceWorkerManager.prototype, "getRegistration")
diff --git a/test/unit/meta/mockServiceWorker.ts b/test/unit/meta/mockServiceWorker.ts
index b904996e3..33cc0ed22 100644
--- a/test/unit/meta/mockServiceWorker.ts
+++ b/test/unit/meta/mockServiceWorker.ts
@@ -17,7 +17,6 @@ test('mock service worker browser API properties should exist', async t => {
   t.true(navigator.serviceWorker instanceof MockServiceWorkerContainer);
   t.true(navigator.serviceWorker.getRegistration instanceof Function);
   t.true(navigator.serviceWorker.getRegistrations instanceof Function);
-  t.true(navigator.serviceWorker.ready instanceof Promise);
   t.true(navigator.serviceWorker.register instanceof Function);
   t.true(navigator.serviceWorker.addEventListener instanceof Function);
 });

From 99e2955f862757ebaffa515bf7f083371a391b07 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 11 Feb 2021 23:49:38 -0800
Subject: [PATCH 09/26] rm Bypassed serviceworker state
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Bypassed isn't something we care about any more as it only matters if
you require page control which our service worker no longer requires.
* This means hard refreashes don't break the SDK either now 🙌!
---
 src/helpers/ServiceWorkerHelper.ts         | 16 -------------
 src/managers/ServiceWorkerManager.ts       | 16 -------------
 test/unit/managers/ServiceWorkerManager.ts | 26 ----------------------
 3 files changed, 58 deletions(-)

diff --git a/src/helpers/ServiceWorkerHelper.ts b/src/helpers/ServiceWorkerHelper.ts
index ee62119f8..52d9958be 100755
--- a/src/helpers/ServiceWorkerHelper.ts
+++ b/src/helpers/ServiceWorkerHelper.ts
@@ -28,16 +28,6 @@ export default class ServiceWorkerHelper {
       workerState === ServiceWorkerActiveState.ThirdParty ||
       workerState === ServiceWorkerActiveState.None)
       workerFullPath = config.workerAPath.getFullPath();
-    else if (workerState === ServiceWorkerActiveState.Bypassed) {
-      /*
-        if the page is hard refreshed bypassing the cache, no service worker
-        will control the page.
-
-        It doesn't matter if we try to reinstall an existing worker; still no
-        service worker will control the page after installation.
-       */
-      throw new InvalidStateError(InvalidStateReason.UnsupportedEnvironment);
-    }
 
     return new URL(workerFullPath, OneSignalUtils.getBaseUrl()).href;
   }
@@ -262,12 +252,6 @@ export enum ServiceWorkerActiveState {
    * No service worker is installed.
    */
   None = 'None',
-  /**
-   * A service worker is active but not controlling the page. This can occur if
-   * the page is hard-refreshed bypassing the cache, which also bypasses service
-   * workers.
-   */
-  Bypassed = 'Bypassed',
   /**
    * Service workers are not supported in this environment. This status is used
    * on HTTP pages where it isn't possible to know whether a service worker is
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 4e6d29480..982c80798 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -121,22 +121,6 @@ export class ServiceWorkerManager {
     // We are now; 1. Getting the filename of the SW; 2. Checking if it is ours or a 3rd parties.
     const swFileName = ServiceWorkerManager.activeSwFileName(workerRegistration);
     const workerState = this.swActiveStateByFileName(swFileName);
-
-    /*
-      Our service worker registration can be both active and in the controlling scope of the current
-      page, but if the page was hard refreshed to bypass the cache (e.g. Ctrl + Shift + R), a
-      service worker will not control the page.
-
-      For a third-party service worker, if it does not call clients.claim(), even if its
-      registration is both active and in the controlling scope of the current page,
-      navigator.serviceWorker.controller will still be null on the first page visit. So we only
-      check if the controller is null for our worker, which we know uses clients.claim().
-     */
-    if (!navigator.serviceWorker.controller && (
-      workerState === ServiceWorkerActiveState.WorkerA ||
-      workerState === ServiceWorkerActiveState.WorkerB
-    ))
-      return ServiceWorkerActiveState.Bypassed;
     return workerState;
   }
 
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index a3a3e4bb8..f1275334c 100644
--- a/test/unit/managers/ServiceWorkerManager.ts
+++ b/test/unit/managers/ServiceWorkerManager.ts
@@ -113,32 +113,6 @@ test('getActiveState() detects a 3rd party worker, a worker that is activated bu
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.ThirdParty);
 });
 
-test('getActiveState() detects a page loaded by hard-refresh with our service worker as bypassed', async t => {
-  const mockWorkerRegistration = new MockServiceWorkerRegistration();
-  const mockInstallingWorker = new MockServiceWorker();
-  mockInstallingWorker.state = 'activated';
-  mockInstallingWorker.scriptURL = 'https://site.com/Worker-A.js';
-  mockWorkerRegistration.active = mockInstallingWorker;
-
-  getRegistrationStub.resolves(mockWorkerRegistration);
-  sandbox.stub(navigator.serviceWorker, 'controller').resolves(null);
-  const manager = LocalHelpers.getServiceWorkerManager();
-  t.is(await manager.getActiveState(), ServiceWorkerActiveState.Bypassed);
-});
-
-test('getActiveState() detects an activated third-party service worker not controlling the page as third-party and not bypassed', async t => {
-  const mockWorkerRegistration = new MockServiceWorkerRegistration();
-  const mockInstallingWorker = new MockServiceWorker();
-  mockInstallingWorker.state = 'activated';
-  mockInstallingWorker.scriptURL = 'https://site.com/another-worker.js';
-  mockWorkerRegistration.active = mockInstallingWorker;
-
-  getRegistrationStub.resolves(mockWorkerRegistration);
-  sandbox.stub(navigator.serviceWorker, 'controller').resolves(null);
-  const manager = LocalHelpers.getServiceWorkerManager();
-  t.is(await manager.getActiveState(), ServiceWorkerActiveState.ThirdParty);
-});
-
 test('getActiveState() should detect Akamai akam-sw.js?othersw= when our is contain within', async t => {
   await navigator.serviceWorker.register('/akam-sw.js?othersw=https://domain.com/Worker-A.js?appId=12345');
 

From 932ef35ec5171065beb8ada577b754a1c8a178cf Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 12 Feb 2021 00:08:07 -0800
Subject: [PATCH 10/26] Updated includeUncontrolled to true

* We had includeUncontrolled: true in 2 of 3 spots already this was an
outlier without any reason given.
* This is requried to track on_session and on_focus correctly.
* Confirmed this changed was required on an HTTPS setup
---
 src/service-worker/ServiceWorker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/service-worker/ServiceWorker.ts b/src/service-worker/ServiceWorker.ts
index 1d316d7b5..3b0498f75 100755
--- a/src/service-worker/ServiceWorker.ts
+++ b/src/service-worker/ServiceWorker.ts
@@ -441,7 +441,7 @@ export class ServiceWorker {
      */
     if (options.isHttps) {
       const windowClients: ReadonlyArray<Client> = await self.clients.matchAll(
-        { type: "window", includeUncontrolled: false }
+        { type: "window", includeUncontrolled: true }
       );
 
       if (options.isSafari) {

From d171014629a51e7151baf960c64e56eb7362ab90 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 12 Feb 2021 00:10:26 -0800
Subject: [PATCH 11/26] Wrong orgin in HTTP header if non-root scope

* self.location.origin works in the service worker context and won't be
wrong when the scope of the service worker isn't root.
---
 src/managers/SdkEnvironment.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/managers/SdkEnvironment.ts b/src/managers/SdkEnvironment.ts
index 70547aeaf..17779d0e7 100644
--- a/src/managers/SdkEnvironment.ts
+++ b/src/managers/SdkEnvironment.ts
@@ -182,7 +182,7 @@ export default class SdkEnvironment {
     if (Environment.isBrowser()) {
       return window.location.origin;
     } else if (typeof self !== "undefined" && typeof ServiceWorkerGlobalScope !== "undefined") {
-      return self.registration.scope;
+      return self.location.origin;
     }
     return "Unknown";
   }

From c069c66bcc2cb3cb3fad9b6bbcb30e1e3855840e Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 12 Feb 2021 02:42:57 -0800
Subject: [PATCH 12/26] Fix SW null somtimes when trying to postMessage

* Fixed bug where sometime in Firefox `serviceWorker.active` is `null`
because it take a few secounds to become active for postMessage to use.
* See "Page to SW Message race condition" in PR for more details on how
I validated this as a stable solution.
---
 src/libraries/WorkerMessenger.ts | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 4ba265d2d..6ebe1f706 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -140,8 +140,6 @@ export class WorkerMessenger {
         } as any);
       }
     } else {
-      // TODO:THIS_PR: Might need a replacement for "controllerchange.
-      ///  It isn't clear if browsers will give the message to the SW if done too soon after installing it.
       Log.debug(`[Worker Messenger] [Page -> SW] Unicasting '${command.toString()}' to service worker.`)
       this.directPostMessageToSW(command, payload);
     }
@@ -149,18 +147,21 @@ export class WorkerMessenger {
 
   public async directPostMessageToSW(command: WorkerMessengerCommand, payload?: WorkerMessengerPayload): Promise<void> {
     Log.debug(`[Worker Messenger] [Page -> SW] Direct command '${command.toString()}' to service worker.`);
-    
+
     const serviceWorker = await this.context.serviceWorkerManager.getRegistration();
     if (!serviceWorker) {
-      Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorker to postMessage!");
+      Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorkerRegistration to postMessage!");
       return;
     }
-    if (!serviceWorker.active) {
-      Log.error("`[Worker Messenger] [Page -> SW] ServiceWorker found but it could not get active instance to postMessage!");
+
+    // ServiceWorker will be in 1 of 3 states; The postMessage payload will still arrive at the SW even if it isn't active
+    const availableWorker = serviceWorker.active || serviceWorker.waiting || serviceWorker.installing;
+    if (!availableWorker) {
+      Log.error("`[Worker Messenger] [Page -> SW] ServiceWorkerRegistration found but it could find an available ServiceWorker instance to postMessage!");
       return;
     }
 
-    serviceWorker.active.postMessage({
+    availableWorker.postMessage({
       command: command,
       payload: payload
     });

From 178e74ec2056941b8167e67d1943c9cd04f191e9 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 12 Feb 2021 03:06:49 -0800
Subject: [PATCH 13/26] rm skipWaiting and claim

* Since we no longer need to control the page for OneSignal to work
there is no longer a need to claim or skipWaiting for the service worker
---
 src/service-worker/ServiceWorker.ts | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/service-worker/ServiceWorker.ts b/src/service-worker/ServiceWorker.ts
index 3b0498f75..23e175687 100755
--- a/src/service-worker/ServiceWorker.ts
+++ b/src/service-worker/ServiceWorker.ts
@@ -96,8 +96,6 @@ export class ServiceWorker {
     self.addEventListener('push', ServiceWorker.onPushReceived);
     self.addEventListener('notificationclose', ServiceWorker.onNotificationClosed);
     self.addEventListener('notificationclick', event => event.waitUntil(ServiceWorker.onNotificationClicked(event)));
-    self.addEventListener('install', ServiceWorker.onServiceWorkerInstalled);
-    self.addEventListener('activate', ServiceWorker.onServiceWorkerActivated);
     self.addEventListener('pushsubscriptionchange', (event: PushSubscriptionChangeEvent) => {
       event.waitUntil(ServiceWorker.onPushSubscriptionChange(event))
     });
@@ -998,21 +996,6 @@ export class ServiceWorker {
     }
   }
 
-  static onServiceWorkerInstalled(event) {
-    Log.info("Installing service worker...");
-    // At this point, the old service worker is still in control
-    event.waitUntil(self.skipWaiting());
-  }
-
-  /*
-   1/11/16: Enable the waiting service worker to immediately become the active service worker: https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
-   */
-  static onServiceWorkerActivated(event) {
-    // The old service worker is gone now
-    Log.info(`%cOneSignal Service Worker activated (version ${Environment.version()}, ${SdkEnvironment.getWindowEnv().toString()} environment).`, Utils.getConsoleStyle('bold'));
-    event.waitUntil(self.clients.claim());
-  }
-
   static async onPushSubscriptionChange(event: PushSubscriptionChangeEvent) {
     Log.debug(`Called %conPushSubscriptionChange(${JSON.stringify(event, null, 4)}):`, Utils.getConsoleStyle('code'), event);
 

From 090fb7fa211e94faebd78868914955593f5baaf3 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Tue, 16 Feb 2021 17:19:05 -0800
Subject: [PATCH 14/26] Changed default open URL to the root domain

* Since the scope of the ServiceWorker can be a path where no HTML pages
are served it is safer to use the origin instead as a default
the notification open URL.
---
 src/service-worker/ServiceWorker.ts   | 2 +-
 test/unit/context/sw/ServiceWorker.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/service-worker/ServiceWorker.ts b/src/service-worker/ServiceWorker.ts
index 23e175687..4fbda12db 100755
--- a/src/service-worker/ServiceWorker.ts
+++ b/src/service-worker/ServiceWorker.ts
@@ -749,7 +749,7 @@ export class ServiceWorker {
   static async getNotificationUrlToOpen(notification): Promise<string> {
     // Defaults to the URL the service worker was registered
     // TODO: This should be fixed for HTTP sites
-    let launchUrl = self.registration.scope;
+    let launchUrl = location.origin;
 
     // Use the user-provided default URL if one exists
     const { defaultNotificationUrl: dbDefaultNotificationUrl } = await Database.getAppState();
diff --git a/test/unit/context/sw/ServiceWorker.ts b/test/unit/context/sw/ServiceWorker.ts
index e345632df..ffc0ef9d2 100644
--- a/test/unit/context/sw/ServiceWorker.ts
+++ b/test/unit/context/sw/ServiceWorker.ts
@@ -277,7 +277,7 @@ test('onNotificationClicked - openWindow', async t => {
   const notificationEvent = mockNotificationNotificationEventInit(notificationId);
   await OSServiceWorker.onNotificationClicked(notificationEvent);
 
-  t.true(openWindowMock.calledWithExactly('https://site.com'));
+  t.deepEqual(openWindowMock.getCalls().map(call => call.args[0]), ['https://localhost:3001'])
 });
 
 /*

From 7840d1bf03c33338a82267a146e8174687a31551 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 01:34:35 -0800
Subject: [PATCH 15/26] rm `ServiceWorkerActiveState.Installing`

* `Installing` is not a state we care about since we don't need control
of the page so removing the logic for this.
   - Both `postMessage` and `pushManager.subscribe` work in any state.
* `.active` will be covered in a different commit.
---
 src/helpers/ServiceWorkerHelper.ts         |  5 -----
 src/managers/ServiceWorkerManager.ts       |  7 -------
 test/unit/managers/ServiceWorkerManager.ts | 11 -----------
 3 files changed, 23 deletions(-)

diff --git a/src/helpers/ServiceWorkerHelper.ts b/src/helpers/ServiceWorkerHelper.ts
index 52d9958be..afe2dde7c 100755
--- a/src/helpers/ServiceWorkerHelper.ts
+++ b/src/helpers/ServiceWorkerHelper.ts
@@ -243,11 +243,6 @@ export enum ServiceWorkerActiveState {
    * provided by user config).
    */
   ThirdParty = '3rd Party',
-  /**
-   * A service worker is currently installing and we can't determine its final state yet. Wait until
-   * the service worker is finished installing by checking for a controllerchange property..
-   */
-  Installing = 'Installing',
   /**
    * No service worker is installed.
    */
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 982c80798..6db282558 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -102,13 +102,6 @@ export class ServiceWorkerManager {
        */
       return ServiceWorkerActiveState.None;
     }
-    else if (workerRegistration.installing) {
-      /*
-        Workers that are installing block for a while, since we can't use them until they're done
-        installing.
-       */
-      return ServiceWorkerActiveState.Installing;
-    }
     else if (!workerRegistration.active) {
       /*
         Workers that are waiting won't be our service workers, since we use clients.claim() and
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index f1275334c..c7012d60c 100644
--- a/test/unit/managers/ServiceWorkerManager.ts
+++ b/test/unit/managers/ServiceWorkerManager.ts
@@ -95,17 +95,6 @@ test('getActiveState() detects worker B, even when worker filename uses query pa
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.WorkerB);
 });
 
-test('getActiveState() detects an installing worker (not active)', async t => {
-  const mockWorkerRegistration = new MockServiceWorkerRegistration();
-  const mockInstallingWorker = new MockServiceWorker();
-  mockInstallingWorker.state = 'installing';
-  mockWorkerRegistration.installing = mockInstallingWorker;
-
-  getRegistrationStub.resolves(mockWorkerRegistration);
-  const manager = LocalHelpers.getServiceWorkerManager();
-  t.is(await manager.getActiveState(), ServiceWorkerActiveState.Installing);
-});
-
 test('getActiveState() detects a 3rd party worker, a worker that is activated but has an unrecognized script URL', async t => {
   await navigator.serviceWorker.register('/Worker-C.js');
 

From 1fa911864ac20f097dada27c74c6a5f9db3a285a Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 01:53:43 -0800
Subject: [PATCH 16/26] rm `!active` sw detection for thirdparty

* Since we are no longer useing `skipWaiting` and `clients.claim()`
`workerRegistration.active` can't be used to detect if the SW is
`ThirdParty` or not.
* This signal also is unnecessary as the filename is later used with the
call to `swActiveStateByFileName` which should be the source of turth
for this.
---
 src/managers/ServiceWorkerManager.ts | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 6db282558..e05db3d4e 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -102,13 +102,6 @@ export class ServiceWorkerManager {
        */
       return ServiceWorkerActiveState.None;
     }
-    else if (!workerRegistration.active) {
-      /*
-        Workers that are waiting won't be our service workers, since we use clients.claim() and
-        skipWaiting() to bypass the install and waiting stages.
-       */
-      return ServiceWorkerActiveState.ThirdParty;
-    }
 
     // At this point, there is an active service worker registration controlling this page.
     // We are now; 1. Getting the filename of the SW; 2. Checking if it is ours or a 3rd parties.

From ef0480792e5806c6acfe9468641525b2625bf797 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 02:15:36 -0800
Subject: [PATCH 17/26] rm listenIfPageUncontrolled

* Removed `listenIfPageUncontrolled` flag on listen.
* This is dead code as we never passing in this flag.
* Also controlled vs uncontrolled is no longer relevent with this PR.
---
 src/libraries/WorkerMessenger.ts | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 6ebe1f706..0bda081b5 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -171,13 +171,8 @@ export class WorkerMessenger {
    * Due to https://github.com/w3c/ServiceWorker/issues/1156, listen() must
    * synchronously add self.addEventListener('message') if we are running in the
    * service worker.
-   *
-   * @param listenIfPageUncontrolled If true, begins listening for service
-   * worker messages even if the service worker does not control this page. This
-   * parameter is set to true on HTTPS iframes expecting service worker messages
-   * that live under an HTTP page.
    */
-  public async listen(listenIfPageUncontrolled?: boolean) {
+  public async listen() {
     if (!Environment.supportsServiceWorkers())
       return;
 
@@ -188,20 +183,13 @@ export class WorkerMessenger {
       Log.debug('[Worker Messenger] Service worker is now listening for messages.');
     }
     else
-      await this.listenForPage(listenIfPageUncontrolled);
+      await this.listenForPage();
   }
 
   /**
    * Listens for messages for the service worker.
-   *
-   * Waits until the service worker is controlling the page before listening for
-   * messages.
    */
-  private async listenForPage(listenIfPageUncontrolled?: boolean) {
-    if (!listenIfPageUncontrolled) {
-      Log.debug(`(${location.origin}) [Worker Messenger] The page is now controlled by the service worker.`);
-    }
-
+  private async listenForPage() {
     navigator.serviceWorker.addEventListener('message', this.onPageMessageReceivedFromServiceWorker.bind(this));
     Log.debug(`(${location.origin}) [Worker Messenger] Page is now listening for messages.`);
   }

From 403d118a1d1e6cb2cac2a6baab5c575aefafc95e Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 02:25:19 -0800
Subject: [PATCH 18/26] Cleaned up comments with "control.*page"

* Page control isn't a factor in the PR so cleaned up all comments
referencing to ServiceWorker page control.
---
 src/libraries/WorkerMessenger.ts     | 10 ++++-----
 src/managers/ServiceWorkerManager.ts | 32 +---------------------------
 src/service-worker/ServiceWorker.ts  |  6 +++---
 3 files changed, 8 insertions(+), 40 deletions(-)

diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 0bda081b5..13a5e67cb 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -119,12 +119,10 @@ export class WorkerMessenger {
   }
 
   /*
-    For pages:
-
-      Sends a postMessage() to the service worker controlling the page.
-
-      Waits until the service worker is controlling the page before sending the
-      message.
+    If running on a page context:
+      Sends a postMessage() to OneSignal's Serviceworker
+    If running in a ServiceWorker context:
+      Sends a postMessage() to the supplied windowClient
    */
   async unicast(command: WorkerMessengerCommand, payload?: WorkerMessengerPayload, windowClient?: Client) {
     const env = SdkEnvironment.getWindowEnv();
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index e05db3d4e..6ec69666b 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -28,7 +28,7 @@ export class ServiceWorkerManager {
     this.config = config;
   }
 
-  // Gets details on the service-worker (if any) that controls the current page
+  // Gets details on the OneSignal service-worker (if any)
   public async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
     return await PageServiceWorkerHelper.getRegistration(this.config.registrationOptions.scope);
   }
@@ -39,25 +39,6 @@ export class ServiceWorkerManager {
       origin, it'll throw on getRegistration().
     */
 
-    /*
-      We want to find out if the *current* page is currently controlled by an
-      active service worker.
-
-      There are three ways (sort of) to do this:
-        - getRegistration()
-        - getRegistrations()
-        - navigator.serviceWorker.ready
-
-      We want to use getRegistration(), since it will not return a value if the
-      page is not currently controlled by an active service worker.
-
-      getRegistrations() returns all service worker registrations under the
-      origin (i.e. registrations in nested folders).
-
-      navigator.serviceWorker.ready will hang indefinitely and never resolve if
-      no registration is active.
-    */
-
     const integration = await SdkEnvironment.getIntegration();
     if (integration === IntegrationKind.InsecureProxy) {
       /* Service workers are not accessible on insecure origins */
@@ -90,20 +71,9 @@ export class ServiceWorkerManager {
 
     const workerRegistration = await this.context.serviceWorkerManager.getRegistration();
     if (!workerRegistration) {
-      /*
-        A site may have a service worker nested at /folder1/folder2/folder3, while the user is
-        currently on /folder1. The nested service worker does not control /folder1 though. Although
-        the nested service worker can receive push notifications without issue, it cannot perform
-        other SDK operations like checking whether existing tabs are optn eo the site on /folder1
-        (used to prevent opening unnecessary new tabs on notification click.)
-
-        Because we rely on being able to communicate with the service worker for SDK operations, we
-        only say we're active if the service worker directly controls this page.
-       */
       return ServiceWorkerActiveState.None;
     }
 
-    // At this point, there is an active service worker registration controlling this page.
     // We are now; 1. Getting the filename of the SW; 2. Checking if it is ours or a 3rd parties.
     const swFileName = ServiceWorkerManager.activeSwFileName(workerRegistration);
     const workerState = this.swActiveStateByFileName(swFileName);
diff --git a/src/service-worker/ServiceWorker.ts b/src/service-worker/ServiceWorker.ts
index 4fbda12db..a873179fa 100755
--- a/src/service-worker/ServiceWorker.ts
+++ b/src/service-worker/ServiceWorker.ts
@@ -77,8 +77,8 @@ export class ServiceWorker {
   }
 
   /**
-   * Allows message passing between this service worker and its controlled clients, or webpages. Controlled
-   * clients include any HTTPS site page, or the nested iFrame pointing to OneSignal on any HTTP site. This allows
+   * Allows message passing between this service worker and pages on the same domain.
+   * Clients include any HTTPS site page, or the nested iFrame pointing to OneSignal on any HTTP site. This allows
    * events like notification dismissed, clicked, and displayed to be fired on the clients. It also allows the
    * clients to communicate with the service worker to close all active notifications.
    */
@@ -886,7 +886,7 @@ export class ServiceWorker {
             }
         } else {
           /*
-          We must focus first; once the client navigates away, it may not be to a service worker-controlled page, and
+          We must focus first; once the client navigates away, it may not be on a domain the same domain, and
           the client ID may change, making it unable to focus.
 
           client.navigate() is available on Chrome 49+ and Firefox 50+.

From 8d69de5e6de971fc8462e0efdbf0c60aaf011e8a Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 02:47:13 -0800
Subject: [PATCH 19/26] Cleaned up duplicated ServiceWorkerHelper name

* renamed helpers/page/ServiceWorkerHelper to helpers/page/ServiceWorkerUtilHelper.
* There was another `ServiceWorkerHelper` class under just /helpers/
and this was creating some confussion.
---
 .../{ServiceWorkerHelper.ts => ServiceWorkerUtilHelper.ts}    | 2 +-
 src/managers/ServiceWorkerManager.ts                          | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/helpers/page/{ServiceWorkerHelper.ts => ServiceWorkerUtilHelper.ts} (92%)

diff --git a/src/helpers/page/ServiceWorkerHelper.ts b/src/helpers/page/ServiceWorkerUtilHelper.ts
similarity index 92%
rename from src/helpers/page/ServiceWorkerHelper.ts
rename to src/helpers/page/ServiceWorkerUtilHelper.ts
index 81fb87f6f..fed8e9df4 100644
--- a/src/helpers/page/ServiceWorkerHelper.ts
+++ b/src/helpers/page/ServiceWorkerUtilHelper.ts
@@ -1,6 +1,6 @@
 import Log from "../../libraries/Log";
 
-export default class ServiceWorkerHelper {
+export default class ServiceWorkerUtilHelper {
   // Get the service worker based on a scope as a domain can have none to many service workers.
   static async getRegistration(scope: string): Promise<ServiceWorkerRegistration | null | undefined> {
     try {
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 6ec69666b..019e68668 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -17,7 +17,7 @@ import ServiceWorkerHelper, { ServiceWorkerActiveState, ServiceWorkerManagerConf
 import { ContextSWInterface } from '../models/ContextSW';
 import { Utils } from "../context/shared/utils/Utils";
 import { PageVisibilityRequest, PageVisibilityResponse } from "../models/Session";
-import PageServiceWorkerHelper from "../helpers/page/ServiceWorkerHelper";
+import ServiceWorkerUtilHelper from "../helpers/page/ServiceWorkerUtilHelper";
 
 export class ServiceWorkerManager {
   private context: ContextSWInterface;
@@ -30,7 +30,7 @@ export class ServiceWorkerManager {
 
   // Gets details on the OneSignal service-worker (if any)
   public async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
-    return await PageServiceWorkerHelper.getRegistration(this.config.registrationOptions.scope);
+    return await ServiceWorkerUtilHelper.getRegistration(this.config.registrationOptions.scope);
   }
 
   public async getActiveState(): Promise<ServiceWorkerActiveState> {

From 42bec5fe11aad0f65d48711a89ffcbbe94cdec8d Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Wed, 17 Feb 2021 03:07:00 -0800
Subject: [PATCH 20/26] Replaced all page `sw.active` calls

* Replaced all `ServiceWorker.active` with a new getAvailableServiceWorker helper method.
* Updated in place `availableWorker` to use this.
---
 src/helpers/page/ServiceWorkerUtilHelper.ts | 10 ++++++++++
 src/libraries/WorkerMessenger.ts            | 16 +++++-----------
 src/managers/ServiceWorkerManager.ts        |  8 +++-----
 3 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/src/helpers/page/ServiceWorkerUtilHelper.ts b/src/helpers/page/ServiceWorkerUtilHelper.ts
index fed8e9df4..21a3ac94b 100644
--- a/src/helpers/page/ServiceWorkerUtilHelper.ts
+++ b/src/helpers/page/ServiceWorkerUtilHelper.ts
@@ -11,4 +11,14 @@ export default class ServiceWorkerUtilHelper {
       return null;
     }
   }
+
+  // A ServiceWorkerRegistration will have a ServiceWorker in 1 of 3 states, get which ever is available.
+  static getAvailableServiceWorker(registration: ServiceWorkerRegistration): ServiceWorker {
+    const availableWorker = registration.active || registration.installing || registration.waiting;
+    // This should never throw unless ServiceWorkerRegistration is pointing to a worker that is completely gone.
+    if (!availableWorker) {
+      throw new Error("Could not find an available ServiceWorker instance!");
+    }
+    return availableWorker;
+  }
 }
diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 13a5e67cb..04eb8e0ea 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -1,12 +1,12 @@
 import { InvalidArgumentError, InvalidArgumentReason } from '../errors/InvalidArgumentError';
 import SdkEnvironment from '../managers/SdkEnvironment';
-import { ServiceWorkerActiveState } from '../helpers/ServiceWorkerHelper';
 import { WindowEnvironmentKind } from '../models/WindowEnvironmentKind';
 
 import { Serializable } from '../models/Serializable';
 import Environment from '../Environment';
 import Log from './Log';
 import { ContextSWInterface } from '../models/ContextSW';
+import ServiceWorkerUtilHelper from '../helpers/page/ServiceWorkerUtilHelper';
 
 /**
  * NOTE: This file contains a mix of code that runs in ServiceWorker and Page contexts
@@ -146,20 +146,14 @@ export class WorkerMessenger {
   public async directPostMessageToSW(command: WorkerMessengerCommand, payload?: WorkerMessengerPayload): Promise<void> {
     Log.debug(`[Worker Messenger] [Page -> SW] Direct command '${command.toString()}' to service worker.`);
 
-    const serviceWorker = await this.context.serviceWorkerManager.getRegistration();
-    if (!serviceWorker) {
+    const workerRegistration = await this.context.serviceWorkerManager.getRegistration();
+    if (!workerRegistration) {
       Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorkerRegistration to postMessage!");
       return;
     }
 
-    // ServiceWorker will be in 1 of 3 states; The postMessage payload will still arrive at the SW even if it isn't active
-    const availableWorker = serviceWorker.active || serviceWorker.waiting || serviceWorker.installing;
-    if (!availableWorker) {
-      Log.error("`[Worker Messenger] [Page -> SW] ServiceWorkerRegistration found but it could find an available ServiceWorker instance to postMessage!");
-      return;
-    }
-
-    availableWorker.postMessage({
+    // The postMessage payload will still arrive at the SW even if it isn't active yet.
+    ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration).postMessage({
       command: command,
       payload: payload
     });
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 019e68668..effd89930 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -82,16 +82,14 @@ export class ServiceWorkerManager {
 
   // Get the file name of the active ServiceWorker
   private static activeSwFileName(workerRegistration: ServiceWorkerRegistration): string | null {
-    if (!workerRegistration.active)
-      return null;
-
-    const workerScriptPath = new URL(workerRegistration.active.scriptURL).pathname;
+    const serviceWorker = ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration);
+    const workerScriptPath = new URL(serviceWorker.scriptURL).pathname;
     const swFileName = new Path(workerScriptPath).getFileName();
 
     // If the current service worker is Akamai's
     if (swFileName == "akam-sw.js") {
       // Check if its importing a ServiceWorker under it's "othersw" query param
-      const searchParams = new URLSearchParams(new URL(workerRegistration.active.scriptURL).search);
+      const searchParams = new URLSearchParams(new URL(serviceWorker.scriptURL).search);
       const importedSw = searchParams.get("othersw");
       if (importedSw) {
         Log.debug("Found a ServiceWorker under Akamai's akam-sw.js?othersw=", importedSw);

From 57f60b2a3c6e592ce530795414ad57252390d867 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 18 Feb 2021 03:29:31 -0800
Subject: [PATCH 21/26] rm throw from getAvailableServiceWorker

* There are cases where getAvailableServiceWorker returning `null` is ok
and it safe to move on so the following was done.
   - Removed the throw
   - Added a warning log etnry
   - Added null handling where this method is being called.
---
 src/helpers/page/ServiceWorkerUtilHelper.ts | 6 +++---
 src/libraries/WorkerMessenger.ts            | 8 +++++++-
 src/managers/ServiceWorkerManager.ts        | 4 ++++
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/helpers/page/ServiceWorkerUtilHelper.ts b/src/helpers/page/ServiceWorkerUtilHelper.ts
index 21a3ac94b..1839c3f95 100644
--- a/src/helpers/page/ServiceWorkerUtilHelper.ts
+++ b/src/helpers/page/ServiceWorkerUtilHelper.ts
@@ -13,11 +13,11 @@ export default class ServiceWorkerUtilHelper {
   }
 
   // A ServiceWorkerRegistration will have a ServiceWorker in 1 of 3 states, get which ever is available.
-  static getAvailableServiceWorker(registration: ServiceWorkerRegistration): ServiceWorker {
+  static getAvailableServiceWorker(registration: ServiceWorkerRegistration): ServiceWorker | null {
     const availableWorker = registration.active || registration.installing || registration.waiting;
-    // This should never throw unless ServiceWorkerRegistration is pointing to a worker that is completely gone.
+    // This never be null unless ServiceWorkerRegistration is pointing to a worker that is completely gone.
     if (!availableWorker) {
-      throw new Error("Could not find an available ServiceWorker instance!");
+      Log.warn("Could not find an available ServiceWorker instance!");
     }
     return availableWorker;
   }
diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index 04eb8e0ea..8db88122d 100644
--- a/src/libraries/WorkerMessenger.ts
+++ b/src/libraries/WorkerMessenger.ts
@@ -152,8 +152,14 @@ export class WorkerMessenger {
       return;
     }
 
+    const availableWorker = ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration);
+    if (!availableWorker) {
+      Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorker to postMessage!");
+      return;
+    }
+
     // The postMessage payload will still arrive at the SW even if it isn't active yet.
-    ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration).postMessage({
+    availableWorker.postMessage({
       command: command,
       payload: payload
     });
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index effd89930..2ed0b7470 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -83,6 +83,10 @@ export class ServiceWorkerManager {
   // Get the file name of the active ServiceWorker
   private static activeSwFileName(workerRegistration: ServiceWorkerRegistration): string | null {
     const serviceWorker = ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration);
+    if (!serviceWorker) {
+      return null;
+    }
+    
     const workerScriptPath = new URL(serviceWorker.scriptURL).pathname;
     const swFileName = new Path(workerScriptPath).getFileName();
 

From 0ad03d8e3997714677e4cdbadd0595850dd0dd79 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 18 Feb 2021 17:13:01 -0800
Subject: [PATCH 22/26] Tests for banning sw page control APIs

* Created a MockServiceWorkerContainerWithAPIBan that throws on the APIs
we want to ban
* MockServiceWorkerContainerWithAPIBan instance is created by default
for all test's env setup.
   - This means any test that hits these APIs will throw, even for new
   tests
* Also added self test (meta tests) for the new
MockServiceWorkerContainerWithAPIBan class
---
 .../models/MockServiceWorkerContainer.ts      | 33 ++++---
 .../MockServiceWorkerContainerWithAPIBan.ts   | 46 ++++++++++
 test/support/sdk/TestEnvironment.ts           |  4 +-
 test/unit/managers/ServiceWorkerManager.ts    | 14 +--
 test/unit/meta/mockPushManager.ts             | 28 +++---
 test/unit/meta/mockServiceWorker.ts           |  4 +
 .../mockServiceWorkerContainerWithAPIBan.ts   | 91 +++++++++++++++++++
 7 files changed, 187 insertions(+), 33 deletions(-)
 create mode 100644 test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
 create mode 100644 test/unit/meta/mockServiceWorkerContainerWithAPIBan.ts

diff --git a/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts b/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
index 78b9ae575..b19d2b5bd 100644
--- a/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
+++ b/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
@@ -2,29 +2,37 @@ import { DispatchEventUtil } from "../utils/DispatchEventUtil";
 import { MockServiceWorker } from "./MockServiceWorker";
 import { MockServiceWorkerRegistration } from "./MockServiceWorkerRegistration";
 
-export class MockServiceWorkerContainer implements ServiceWorkerContainer {
-  controller: ServiceWorker | null;
-  oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
+// abstract to indicate this isn't designed to be used directly as part of the tests. (expect for the meta one)
+// This is a generic mock.
+//   - no OneSignal specifics, see MockServiceWorkerContainerWithAPIBan 
+export abstract class MockServiceWorkerContainer implements ServiceWorkerContainer {
+  protected _controller: ServiceWorker | null;
+  get controller(): ServiceWorker | null {
+    return this._controller;
+  }
+
+  get ready(): Promise<ServiceWorkerRegistration> {
+    return new Promise<ServiceWorkerRegistration>(resolve => (resolve(new MockServiceWorkerRegistration())));
+  }
+  
+  set oncontrollerchange(event: ((this: ServiceWorkerContainer, ev: Event) => any) | null) {
+  }
+
   onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
   onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
-  readonly ready: Promise<ServiceWorkerRegistration>;
 
   private dispatchEventUtil: DispatchEventUtil = new DispatchEventUtil();
   public serviceWorkerRegistration: ServiceWorkerRegistration | null;
 
   constructor() {
     this.serviceWorkerRegistration = null;
-    this.ready = new Promise<ServiceWorkerRegistration>(resolve => (resolve(new MockServiceWorkerRegistration())));
-    this.controller = null;
-    this.oncontrollerchange = null;
+    this._controller = null;
     this.onmessage = null;
     this.onmessageerror = null;
   }
 
   addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-  addEventListener(type: string, listener: EventListener | EventListenerObject, options?: boolean | AddEventListenerOptions): void;
-  addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void {
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void {
     this.dispatchEventUtil.addEventListener(type, listener, options);
   }
 
@@ -51,10 +59,11 @@ export class MockServiceWorkerContainer implements ServiceWorkerContainer {
     const mockSw = new MockServiceWorker();
     mockSw.scriptURL = scriptURL;
     mockSw.state = 'activated';
-    this.controller = mockSw;
+ 
+    this._controller = mockSw;
 
     const swReg = new MockServiceWorkerRegistration();
-    swReg.active = this.controller;
+    swReg.active = this._controller;
     this.serviceWorkerRegistration = swReg;
 
     return this.serviceWorkerRegistration;
diff --git a/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts b/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
new file mode 100644
index 000000000..f2c8313d0
--- /dev/null
+++ b/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
@@ -0,0 +1,46 @@
+import { MockServiceWorkerContainer } from "./MockServiceWorkerContainer";
+
+// This mock adds throws to APIs we want to ensure OneSignal never uses.
+// The baned APIs are those that fit under assuming our ServiceWorker is:
+//   * the only one
+//   * in control of the page
+// These are important to ensure the SDK compatibility with PWA and AMP pages as an example
+//   of possible other ServiceWorkers.
+export class MockServiceWorkerContainerWithAPIBan extends MockServiceWorkerContainer {
+  constructor() {
+    super();
+  }
+  
+  get controller(): ServiceWorker | null {
+    throw new Error("Don't use, assumes page control!");
+  }
+
+  getControllerForTests(): ServiceWorker | null {
+    return this._controller;
+  }
+
+  static getControllerForTests(): ServiceWorker | null {
+    return (navigator.serviceWorker as MockServiceWorkerContainerWithAPIBan).getControllerForTests();
+  }
+
+  get ready(): Promise<ServiceWorkerRegistration> {
+    throw new Error("Don't use, assumes page control!");
+  }
+
+  async getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined> {
+    if (!clientURL) {
+      throw new Error("Must include clientURL to get the SW of the scope we registered, not the current page being viewed.")
+    }
+    return super.getRegistration(clientURL);
+  }
+
+  set oncontrollerchange(_event: ((this: ServiceWorkerContainer, ev: Event) => any) | null) {
+    throw new Error("Don't use, assumes page control!");
+  }
+
+  addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, _listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, _options?: boolean | AddEventListenerOptions): void {
+    if (type == 'controllerchange') {
+      throw new Error("Don't use, assumes page control!");
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/support/sdk/TestEnvironment.ts b/test/support/sdk/TestEnvironment.ts
index 3f3b9747b..4f9b005af 100644
--- a/test/support/sdk/TestEnvironment.ts
+++ b/test/support/sdk/TestEnvironment.ts
@@ -22,7 +22,7 @@ import { RawPushSubscription } from '../../../src/models/RawPushSubscription';
 import { MockServiceWorkerGlobalScope } from "../mocks/service-workers/models/MockServiceWorkerGlobalScope";
 import { MockServiceWorker } from "../mocks/service-workers/models/MockServiceWorker";
 import { MockPushManager } from "../mocks/service-workers/models/MockPushManager";
-import { MockServiceWorkerContainer } from "../mocks/service-workers/models/MockServiceWorkerContainer";
+import { MockServiceWorkerContainerWithAPIBan } from "../mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan";
 import { addServiceWorkerGlobalScopeToGlobal } from "../polyfills/polyfills";
 import deepmerge = require("deepmerge");
 import { RecursivePartial } from '../../../src/context/shared/utils/Utils';
@@ -256,7 +256,7 @@ export class TestEnvironment {
     });
     // Node has its own console; overwriting it will cause issues
     delete (windowDef as any)['console'];
-    (windowDef as any).navigator.serviceWorker = new MockServiceWorkerContainer();
+    (windowDef as any).navigator.serviceWorker = new MockServiceWorkerContainerWithAPIBan();
     (windowDef as any).localStorage = new DOMStorage(null);
     (windowDef as any).sessionStorage = new DOMStorage(null);
     const { TextEncoder, TextDecoder } = require('text-encoding');
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index c7012d60c..dea1d3357 100644
--- a/test/unit/managers/ServiceWorkerManager.ts
+++ b/test/unit/managers/ServiceWorkerManager.ts
@@ -29,6 +29,7 @@ import { MockServiceWorkerRegistration } from "../../support/mocks/service-worke
 import { MockServiceWorker } from "../../support/mocks/service-workers/models/MockServiceWorker";
 import { ConfigIntegrationKind } from "../../../src/models/AppConfig";
 import Environment from '../../../src/Environment';
+import { MockServiceWorkerContainerWithAPIBan } from '../../support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan';
 
 class LocalHelpers {
   static getServiceWorkerManager(): ServiceWorkerManager {
@@ -184,12 +185,11 @@ test('installWorker() installs worker A with the correct file name and query par
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.None);
   await manager.installWorker();
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.WorkerA);
-  t.not(navigator.serviceWorker.controller, null);
-  if (navigator.serviceWorker.controller !== null) {
-    t.true(navigator.serviceWorker.controller.scriptURL.endsWith(
-      `/Worker-A.js?appId=${OneSignal.context.appConfig.appId}`)
-    );
-  }
+
+  const serviceWorker = MockServiceWorkerContainerWithAPIBan.getControllerForTests();
+  t.true(serviceWorker!.scriptURL.endsWith(
+    `/Worker-A.js?appId=${OneSignal.context.appConfig.appId}`)
+  );
 });
 
 test('installWorker() does NOT install ServiceWorker when permission has NOT been granted', async t => {
@@ -202,7 +202,7 @@ test('installWorker() does NOT install ServiceWorker when permission has NOT bee
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.None);
   await manager.installWorker();
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.None);
-  t.is(navigator.serviceWorker.controller, null);
+  t.is(MockServiceWorkerContainerWithAPIBan.getControllerForTests(), null);
 });
 
 test('installWorker() installs worker A when a third party service worker exists', async t => {
diff --git a/test/unit/meta/mockPushManager.ts b/test/unit/meta/mockPushManager.ts
index cf2d215fc..3d9e9dc15 100644
--- a/test/unit/meta/mockPushManager.ts
+++ b/test/unit/meta/mockPushManager.ts
@@ -7,6 +7,10 @@ import Random from "../../support/tester/Random";
 import { MockPushManager } from "../../support/mocks/service-workers/models/MockPushManager";
 import { MockPushSubscription } from "../../support/mocks/service-workers/models/MockPushSubscription";
 
+async function getServiceWorkerRegistration(): Promise<ServiceWorkerRegistration | undefined> {
+  return await navigator.serviceWorker.getRegistration("/");
+}
+
 test.beforeEach(async t => {
   await TestEnvironment.initialize({
     httpOrHttps: HttpHttpsEnvironment.Https
@@ -16,28 +20,28 @@ test.beforeEach(async t => {
 });
 
 test('mock push manager properties should exist', async t => {
-  const registration: ServiceWorkerRegistration = await navigator.serviceWorker.getRegistration() as any;
+  const registration = await getServiceWorkerRegistration();
 
-  t.true(registration.pushManager instanceof MockPushManager);
-  t.true(registration.pushManager.getSubscription instanceof Function);
-  t.true(registration.pushManager.subscribe instanceof Function);
+  t.true(registration!.pushManager instanceof MockPushManager);
+  t.true(registration!.pushManager.getSubscription instanceof Function);
+  t.true(registration!.pushManager.subscribe instanceof Function);
 });
 
 test('mock push manager should not return an existing subscription for a clean run', async t => {
-  const registration: ServiceWorkerRegistration = await navigator.serviceWorker.getRegistration() as any;
+  const registration = await getServiceWorkerRegistration();
 
-  const subscription = await registration.pushManager.getSubscription();
+  const subscription = await registration!.pushManager.getSubscription();
   t.is(subscription, null);
 });
 
 test('mock push manager should subscribe successfully', async t => {
-  const registration: ServiceWorkerRegistration = await navigator.serviceWorker.getRegistration() as any;
+  const registration = await getServiceWorkerRegistration();
 
   const subscriptionOptions: PushSubscriptionOptions = {
     userVisibleOnly: true,
     applicationServerKey: Random.getRandomUint8Array(64).buffer
   };
-  const subscription = await registration.pushManager.subscribe(subscriptionOptions);
+  const subscription = await registration!.pushManager.subscribe(subscriptionOptions);
 
   t.true(subscription instanceof MockPushSubscription);
   t.is(typeof subscription.endpoint, typeof '');
@@ -48,14 +52,14 @@ test('mock push manager should subscribe successfully', async t => {
 });
 
 test('mock push manager should unsubscribe successfully', async t => {
-  const registration: ServiceWorkerRegistration = await navigator.serviceWorker.getRegistration() as any;
+  const registration = await getServiceWorkerRegistration();
 
-  let subscription = await registration.pushManager.subscribe({
+  const subscribedSubscription = await registration!.pushManager.subscribe({
     userVisibleOnly: true,
     applicationServerKey: Random.getRandomUint8Array(64).buffer
   });
-  await subscription.unsubscribe();
-  subscription = await registration.pushManager.getSubscription();
+  await subscribedSubscription.unsubscribe();
+  const subscription = await registration!.pushManager.getSubscription();
   t.is(subscription, null);
 });
 
diff --git a/test/unit/meta/mockServiceWorker.ts b/test/unit/meta/mockServiceWorker.ts
index 33cc0ed22..88665d9fb 100644
--- a/test/unit/meta/mockServiceWorker.ts
+++ b/test/unit/meta/mockServiceWorker.ts
@@ -7,10 +7,14 @@ import { MockServiceWorkerContainer } from "../../support/mocks/service-workers/
 import { MockServiceWorker } from "../../support/mocks/service-workers/models/MockServiceWorker";
 import { MockServiceWorkerRegistration } from "../../support/mocks/service-workers/models/MockServiceWorkerRegistration";
 
+class TestMockServiceWorkerContainer extends MockServiceWorkerContainer {
+}
+
 test.beforeEach(async t => {
   await TestEnvironment.initialize({
     httpOrHttps: HttpHttpsEnvironment.Https
   });
+  (global as any).navigator.serviceWorker = new TestMockServiceWorkerContainer();
 });
 
 test('mock service worker browser API properties should exist', async t => {
diff --git a/test/unit/meta/mockServiceWorkerContainerWithAPIBan.ts b/test/unit/meta/mockServiceWorkerContainerWithAPIBan.ts
new file mode 100644
index 000000000..cc5c62b8f
--- /dev/null
+++ b/test/unit/meta/mockServiceWorkerContainerWithAPIBan.ts
@@ -0,0 +1,91 @@
+import test from 'ava';
+
+import { TestEnvironment, HttpHttpsEnvironment } from '../../support/sdk/TestEnvironment';
+import { MockServiceWorkerContainerWithAPIBan } from "../../support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan";
+
+test.beforeEach(async t => {
+  await TestEnvironment.initialize({
+    httpOrHttps: HttpHttpsEnvironment.Https
+  });
+});
+
+test('mock service worker browser API properties should exist', async t => {
+  t.true(navigator.serviceWorker instanceof MockServiceWorkerContainerWithAPIBan);
+  t.true(navigator.serviceWorker.addEventListener instanceof Function);
+});
+
+test('mock service worker should not return an existing registration for a clean run', async t => {
+  const registration = await navigator.serviceWorker.getRegistration("/");
+  t.is(registration, undefined);
+
+  const registrations = await navigator.serviceWorker.getRegistrations();
+  t.deepEqual(registrations, []);
+});
+
+test('mock service worker unregistration should return no registered workers', async t => {
+  await navigator.serviceWorker.register('/worker.js', { scope: '/' });
+
+  const initialRegistration = await navigator.serviceWorker.getRegistration("/");
+  await initialRegistration!.unregister();
+
+  const postUnsubscribeRegistration = await navigator.serviceWorker.getRegistration("/");
+  t.is(postUnsubscribeRegistration, undefined);
+
+  const registrations = await navigator.serviceWorker.getRegistrations();
+  t.deepEqual(registrations, []);
+});
+
+test('Should thow when calling navigator.serviceWorker.controller', async t => {
+  try {
+    navigator.serviceWorker!.controller;
+    t.fail("Should have thrown!")
+  } catch (e) {
+    t.deepEqual(e, new Error("Don't use, assumes page control!"));
+  }
+});
+
+test('Should thow when calling navigator.serviceWorker.ready', async t => {
+  try {
+    await navigator.serviceWorker!.ready;
+    t.fail("Should have thrown!")
+  } catch (e) {
+    t.deepEqual(e, new Error("Don't use, assumes page control!"));
+  }
+});
+
+test('Should thow when calling navigator.serviceWorker.getRegistration without a url', async t => {
+  try {
+    await navigator.serviceWorker!.getRegistration();
+    t.fail("Should have thrown!")
+  } catch (e) {
+    t.deepEqual(e, new Error("Must include clientURL to get the SW of the scope we registered, not the current page being viewed."));
+  }
+});
+
+test('Should thow when setting navigator.serviceWorker.oncontrollerchange', async t => {
+  try {
+    navigator.serviceWorker.oncontrollerchange = function(){};
+    t.fail("Should have thrown!")
+  } catch (e) {
+    t.deepEqual(e, new Error("Don't use, assumes page control!"));
+  }
+});
+
+test('Should thow when setting navigator.serviceWorker.addEventListener(controllerchange, ...)', async t => {
+  try {
+    navigator.serviceWorker.addEventListener('controllerchange', function(){});
+    t.fail("Should have thrown!")
+  } catch (e) {
+    t.deepEqual(e, new Error("Don't use, assumes page control!"));
+  }
+});
+
+test('Should not thow when setting navigator.serviceWorker.addEventListener(message, ...)', async t => {
+  navigator.serviceWorker.addEventListener('message', function(){});
+  t.pass();
+});
+
+test('Should not thow when setting navigator.serviceWorker.addEventListener(messageerror, ...)', async t => {
+  navigator.serviceWorker.addEventListener('messageerror', function(){});
+  t.pass();
+});
\ No newline at end of file

From b3de7427540f33510d2067e28f5ef076ae21e8f9 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 18 Feb 2021 18:08:16 -0800
Subject: [PATCH 23/26] Added ServiceWorkerUtilHelper tests

---
 .../models/MockServiceWorkerRegistration.ts   |  3 +-
 .../helpers/page/ServiceWorkerUtilHelper.ts   | 34 +++++++++++++++++++
 test/unit/managers/ServiceWorkerManager.ts    | 11 ++++++
 3 files changed, 47 insertions(+), 1 deletion(-)
 create mode 100644 test/unit/helpers/page/ServiceWorkerUtilHelper.ts

diff --git a/test/support/mocks/service-workers/models/MockServiceWorkerRegistration.ts b/test/support/mocks/service-workers/models/MockServiceWorkerRegistration.ts
index f6ba39ec3..087177d93 100644
--- a/test/support/mocks/service-workers/models/MockServiceWorkerRegistration.ts
+++ b/test/support/mocks/service-workers/models/MockServiceWorkerRegistration.ts
@@ -4,16 +4,17 @@ import { MockServiceWorkerContainer } from "./MockServiceWorkerContainer";
 export class MockServiceWorkerRegistration implements ServiceWorkerRegistration {
   active: ServiceWorker | null;
   installing: ServiceWorker | null;
+  waiting: ServiceWorker | null;
   onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
   readonly pushManager: PushManager;
   readonly sync: SyncManager;
-  readonly waiting: ServiceWorker | null;
   navigationPreload: NavigationPreloadManager;
   updateViaCache: ServiceWorkerUpdateViaCache;
 
   constructor() {
     this.active = null;
     this.installing = null;
+    this.waiting = null;
     this.pushManager = new MockPushManager();
   }
 
diff --git a/test/unit/helpers/page/ServiceWorkerUtilHelper.ts b/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
new file mode 100644
index 000000000..98e776782
--- /dev/null
+++ b/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
@@ -0,0 +1,34 @@
+
+import test from 'ava';
+import ServiceWorkerUtilHelper from '../../../../src/helpers/page/ServiceWorkerUtilHelper';
+import { MockServiceWorker } from '../../../support/mocks/service-workers/models/MockServiceWorker';
+import { MockServiceWorkerRegistration } from "../../../support/mocks/service-workers/models/MockServiceWorkerRegistration";
+
+test('getAvailableServiceWorker() - returns instance - when only active', async t => {
+  const serviceWorkerRegistration = new MockServiceWorkerRegistration();
+  serviceWorkerRegistration.active = new MockServiceWorker();
+
+  t.truthy(ServiceWorkerUtilHelper.getAvailableServiceWorker(serviceWorkerRegistration))
+});
+
+test('getAvailableServiceWorker() - returns instance - when only waiting', async t => {
+  const serviceWorkerRegistration = new MockServiceWorkerRegistration();
+  serviceWorkerRegistration.waiting = new MockServiceWorker();
+
+  t.truthy(ServiceWorkerUtilHelper.getAvailableServiceWorker(serviceWorkerRegistration))
+});
+
+test('getAvailableServiceWorker() - returns instance - when only installing', async t => {
+  const serviceWorkerRegistration = new MockServiceWorkerRegistration();
+  serviceWorkerRegistration.installing = new MockServiceWorker();
+
+  t.truthy(ServiceWorkerUtilHelper.getAvailableServiceWorker(serviceWorkerRegistration))
+});
+
+
+test('getAvailableServiceWorker() - returns null - when no ServiceWorker', async t => {
+  const serviceWorkerRegistration = new MockServiceWorkerRegistration();
+  t.falsy(ServiceWorkerUtilHelper.getAvailableServiceWorker(serviceWorkerRegistration))
+});
+
+// See test/unit/manager/ServiceWorkerManager.ts for other tests that cover this class
\ No newline at end of file
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index dea1d3357..29fe2cd17 100644
--- a/test/unit/managers/ServiceWorkerManager.ts
+++ b/test/unit/managers/ServiceWorkerManager.ts
@@ -385,6 +385,17 @@ test('installWorker() should not install when on an HTTPS site with a subdomain
   t.is(await manager.getActiveState(), ServiceWorkerActiveState.Indeterminate);
 });
 
+test('ServiceWorkerManager.getRegistration() returns valid instance when sw is registered', async t => {
+  await navigator.serviceWorker.register('/Worker-A.js');
+  const result = await OneSignal.context.serviceWorkerManager.getRegistration();
+  t.truthy(result);
+});
+
+test('ServiceWorkerManager.getRegistration() returns undefined when sw is not registered ', async t => {
+  const result = await OneSignal.context.serviceWorkerManager.getRegistration();
+  t.is(result, undefined);
+});
+
 test('ServiceWorkerManager.getRegistration() handles throws by returning null', async t => {
   getRegistrationStub.restore();
   getRegistrationStub = sandbox.stub(navigator.serviceWorker, 'getRegistration');

From 0b6b420d61d6387ee5ab0979b978a6e99397910a Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Thu, 18 Feb 2021 19:08:31 -0800
Subject: [PATCH 24/26] Moved OneSignal.context access down a level

* Clean up - Moved access to OneSignal.context.serviceWorkerManager
down one call
stack from getRawPushSubscriptionFromServiceWorkerRegistration
to getRawPushSubscription
---
 src/helpers/SubscriptionHelper.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/helpers/SubscriptionHelper.ts b/src/helpers/SubscriptionHelper.ts
index e294cc903..1d3d254ba 100755
--- a/src/helpers/SubscriptionHelper.ts
+++ b/src/helpers/SubscriptionHelper.ts
@@ -161,8 +161,7 @@ export default class SubscriptionHelper {
     return subscription;
   }
 
-  static async getRawPushSubscriptionFromServiceWorkerRegistration(): Promise<RawPushSubscription | null> {
-    const registration = await OneSignal.context.serviceWorkerManager.getRegistration();
+  static async getRawPushSubscriptionFromServiceWorkerRegistration(registration?: ServiceWorkerRegistration): Promise<RawPushSubscription | null> {
     if (!registration) {
       return null;
     }
@@ -190,7 +189,8 @@ export default class SubscriptionHelper {
     }
 
     if (environmentInfo.isBrowserAndSupportsServiceWorkers) {
-      return await SubscriptionHelper.getRawPushSubscriptionFromServiceWorkerRegistration();
+      const registration = await OneSignal.context.serviceWorkerManager.getRegistration();
+      return await SubscriptionHelper.getRawPushSubscriptionFromServiceWorkerRegistration(registration);
     }
 
     return null;

From 46fca9acb49432c619341fc423dec750570d89e9 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 19 Feb 2021 00:21:43 -0800
Subject: [PATCH 25/26] rm sw checks before establishServiceWorkerChannel

* establishServiceWorkerChannel already internally handles if the
ServiceWorker exists already and doesn't require active status.
---
 src/helpers/InitHelper.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/helpers/InitHelper.ts b/src/helpers/InitHelper.ts
index 09aae8062..231cfce3d 100755
--- a/src/helpers/InitHelper.ts
+++ b/src/helpers/InitHelper.ts
@@ -260,10 +260,7 @@ export default class InitHelper {
       !await SdkEnvironment.isFrameContextInsecure()
     ) {
       try {
-        const registration = await OneSignal.context.serviceWorkerManager.getRegistration();
-        if (registration && registration.active) {
-          await OneSignal.context.serviceWorkerManager.establishServiceWorkerChannel();
-        }
+        await OneSignal.context.serviceWorkerManager.establishServiceWorkerChannel();
       } catch (e) { 
         Log.error(e);
       }

From 4516c35fc0fffcf52a0feaa4f81f0c51264d7416 Mon Sep 17 00:00:00 2001
From: Josh Kasten <josh@onesignal.com>
Date: Fri, 19 Feb 2021 11:33:44 -0800
Subject: [PATCH 26/26] Small formating and naming cleanup

---
 src/managers/ServiceWorkerManager.ts                  |  2 +-
 .../models/MockServiceWorkerContainer.ts              |  2 +-
 .../models/MockServiceWorkerContainerWithAPIBan.ts    |  4 ++--
 test/unit/helpers/page/ServiceWorkerUtilHelper.ts     |  2 +-
 test/unit/meta/mockPushManager.ts                     | 11 +++++------
 5 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index 2ed0b7470..13f9c07c6 100644
--- a/src/managers/ServiceWorkerManager.ts
+++ b/src/managers/ServiceWorkerManager.ts
@@ -86,7 +86,7 @@ export class ServiceWorkerManager {
     if (!serviceWorker) {
       return null;
     }
-    
+
     const workerScriptPath = new URL(serviceWorker.scriptURL).pathname;
     const swFileName = new Path(workerScriptPath).getFileName();
 
diff --git a/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts b/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
index b19d2b5bd..27d4631f5 100644
--- a/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
+++ b/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
@@ -4,7 +4,7 @@ import { MockServiceWorkerRegistration } from "./MockServiceWorkerRegistration";
 
 // abstract to indicate this isn't designed to be used directly as part of the tests. (expect for the meta one)
 // This is a generic mock.
-//   - no OneSignal specifics, see MockServiceWorkerContainerWithAPIBan 
+//   - no OneSignal specifics, see MockServiceWorkerContainerWithAPIBan
 export abstract class MockServiceWorkerContainer implements ServiceWorkerContainer {
   protected _controller: ServiceWorker | null;
   get controller(): ServiceWorker | null {
diff --git a/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts b/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
index f2c8313d0..aa6b87279 100644
--- a/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
+++ b/test/support/mocks/service-workers/models/MockServiceWorkerContainerWithAPIBan.ts
@@ -10,7 +10,7 @@ export class MockServiceWorkerContainerWithAPIBan extends MockServiceWorkerConta
   constructor() {
     super();
   }
-  
+
   get controller(): ServiceWorker | null {
     throw new Error("Don't use, assumes page control!");
   }
@@ -43,4 +43,4 @@ export class MockServiceWorkerContainerWithAPIBan extends MockServiceWorkerConta
       throw new Error("Don't use, assumes page control!");
     }
   }
-}
\ No newline at end of file
+}
diff --git a/test/unit/helpers/page/ServiceWorkerUtilHelper.ts b/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
index 98e776782..7cacce4f8 100644
--- a/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
+++ b/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
@@ -31,4 +31,4 @@ test('getAvailableServiceWorker() - returns null - when no ServiceWorker', async
   t.falsy(ServiceWorkerUtilHelper.getAvailableServiceWorker(serviceWorkerRegistration))
 });
 
-// See test/unit/manager/ServiceWorkerManager.ts for other tests that cover this class
\ No newline at end of file
+// See test/unit/manager/ServiceWorkerManager.ts for other tests that cover this class
diff --git a/test/unit/meta/mockPushManager.ts b/test/unit/meta/mockPushManager.ts
index 3d9e9dc15..92a13a1b5 100644
--- a/test/unit/meta/mockPushManager.ts
+++ b/test/unit/meta/mockPushManager.ts
@@ -53,13 +53,12 @@ test('mock push manager should subscribe successfully', async t => {
 
 test('mock push manager should unsubscribe successfully', async t => {
   const registration = await getServiceWorkerRegistration();
-
-  const subscribedSubscription = await registration!.pushManager.subscribe({
+  const subscription = await registration!.pushManager.subscribe({
     userVisibleOnly: true,
     applicationServerKey: Random.getRandomUint8Array(64).buffer
   });
-  await subscribedSubscription.unsubscribe();
-  const subscription = await registration!.pushManager.getSubscription();
-  t.is(subscription, null);
-});
+  await subscription.unsubscribe();
 
+  const subscriptionToCheck = await registration!.pushManager.getSubscription();
+  t.is(subscriptionToCheck, null);
+});
