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;
diff --git a/src/helpers/InitHelper.ts b/src/helpers/InitHelper.ts
index d2c901455..231cfce3d 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,10 +260,7 @@ export default class InitHelper {
       !await SdkEnvironment.isFrameContextInsecure()
     ) {
       try {
-        const registration = await ServiceWorkerManager.getRegistration();
-        if (registration && registration.active) {
-          await OneSignal.context.serviceWorkerManager.establishServiceWorkerChannel();
-        }
+        await OneSignal.context.serviceWorkerManager.establishServiceWorkerChannel();
       } catch (e) { 
         Log.error(e);
       }
diff --git a/src/helpers/ServiceWorkerHelper.ts b/src/helpers/ServiceWorkerHelper.ts
index 1f7732d47..afe2dde7c 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 {
@@ -33,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;
   }
@@ -258,21 +243,10 @@ 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.
    */
   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/helpers/SubscriptionHelper.ts b/src/helpers/SubscriptionHelper.ts
index 0eae84ee2..1d3d254ba 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";
 
@@ -162,8 +161,7 @@ export default class SubscriptionHelper {
     return subscription;
   }
 
-  static async getRawPushSubscriptionFromServiceWorkerRegistration(): Promise<RawPushSubscription | null> {
-    const registration = await PageServiceWorkerHelper.getRegistration();
+  static async getRawPushSubscriptionFromServiceWorkerRegistration(registration?: ServiceWorkerRegistration): Promise<RawPushSubscription | null> {
     if (!registration) {
       return null;
     }
@@ -191,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;
diff --git a/src/helpers/page/ServiceWorkerHelper.ts b/src/helpers/page/ServiceWorkerHelper.ts
deleted file mode 100644
index f261586bd..000000000
--- a/src/helpers/page/ServiceWorkerHelper.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-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> {
-    try {
-      // location.href is used for <base> tag compatibility when it is set to a different origin
-      return await navigator.serviceWorker.getRegistration(location.href);
-    } 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);
-      return null;
-    }
-  }
-}
diff --git a/src/helpers/page/ServiceWorkerUtilHelper.ts b/src/helpers/page/ServiceWorkerUtilHelper.ts
new file mode 100644
index 000000000..1839c3f95
--- /dev/null
+++ b/src/helpers/page/ServiceWorkerUtilHelper.ts
@@ -0,0 +1,24 @@
+import Log from "../../libraries/Log";
+
+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 {
+      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", scope, e);
+      return null;
+    }
+  }
+
+  // A ServiceWorkerRegistration will have a ServiceWorker in 1 of 3 states, get which ever is available.
+  static getAvailableServiceWorker(registration: ServiceWorkerRegistration): ServiceWorker | null {
+    const availableWorker = registration.active || registration.installing || registration.waiting;
+    // This never be null unless ServiceWorkerRegistration is pointing to a worker that is completely gone.
+    if (!availableWorker) {
+      Log.warn("Could not find an available ServiceWorker instance!");
+    }
+    return availableWorker;
+  }
+}
diff --git a/src/libraries/WorkerMessenger.ts b/src/libraries/WorkerMessenger.ts
index b262645b6..8db88122d 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
@@ -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();
@@ -140,18 +138,28 @@ 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();
       Log.debug(`[Worker Messenger] [Page -> SW] Unicasting '${command.toString()}' to service worker.`)
       this.directPostMessageToSW(command, payload);
     }
   }
 
-  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 workerRegistration = await this.context.serviceWorkerManager.getRegistration();
+    if (!workerRegistration) {
+      Log.error("`[Worker Messenger] [Page -> SW] Could not get ServiceWorkerRegistration to postMessage!");
+      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.
+    availableWorker.postMessage({
       command: command,
       payload: payload
     });
@@ -161,13 +169,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;
 
@@ -178,24 +181,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) {
-      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.`);
-    }
-
+  private async listenForPage() {
     navigator.serviceWorker.addEventListener('message', this.onPageMessageReceivedFromServiceWorker.bind(this));
     Log.debug(`(${location.origin}) [Worker Messenger] Page is now listening for messages.`);
   }
@@ -301,58 +293,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;
-    }
-  }
-
-  /**
-   * 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();
-          });
-        }
-      }
-    });
-  }
 }
diff --git a/src/managers/SdkEnvironment.ts b/src/managers/SdkEnvironment.ts
index f9be3daa0..17779d0e7 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;
   }
 
@@ -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";
   }
diff --git a/src/managers/ServiceWorkerManager.ts b/src/managers/ServiceWorkerManager.ts
index fdac2f3dd..13f9c07c6 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 ServiceWorkerUtilHelper from "../helpers/page/ServiceWorkerUtilHelper";
 
 export class ServiceWorkerManager {
   private context: ContextSWInterface;
@@ -27,9 +28,9 @@ export class ServiceWorkerManager {
     this.config = config;
   }
 
-  // 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();
+  // Gets details on the OneSignal service-worker (if any)
+  public async getRegistration(): Promise<ServiceWorkerRegistration | null | undefined> {
+    return await ServiceWorkerUtilHelper.getRegistration(this.config.registrationOptions.scope);
   }
 
   public async getActiveState(): Promise<ServiceWorkerActiveState> {
@@ -38,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 */
@@ -87,70 +69,31 @@ 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
-        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;
     }
-    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
-        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.
     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;
   }
 
   // Get the file name of the active ServiceWorker
   private static activeSwFileName(workerRegistration: ServiceWorkerRegistration): string | null {
-    if (!workerRegistration.active)
+    const serviceWorker = ServiceWorkerUtilHelper.getAvailableServiceWorker(workerRegistration);
+    if (!serviceWorker) {
       return null;
+    }
 
-    const workerScriptPath = new URL(workerRegistration.active.scriptURL).pathname;
+    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);
@@ -297,36 +240,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();
diff --git a/src/managers/SubscriptionManager.ts b/src/managers/SubscriptionManager.ts
index 539aa104f..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);
   }
@@ -639,7 +642,7 @@ export class SubscriptionManager {
         return false;
     }
 
-    const serviceWorkerRegistration = await ServiceWorkerManager.getRegistration();
+    const serviceWorkerRegistration = await this.context.serviceWorkerManager.getRegistration();
     if (!serviceWorkerRegistration)
       return false;
 
@@ -743,7 +746,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 = (
diff --git a/src/service-worker/ServiceWorker.ts b/src/service-worker/ServiceWorker.ts
index 1d316d7b5..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.
    */
@@ -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))
     });
@@ -441,7 +439,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) {
@@ -751,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();
@@ -888,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+.
@@ -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);
 
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/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/mocks/service-workers/models/MockServiceWorkerContainer.ts b/test/support/mocks/service-workers/models/MockServiceWorkerContainer.ts
index 78b9ae575..27d4631f5 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..aa6b87279
--- /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!");
+    }
+  }
+}
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/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/support/tester/sinonSandboxUtils.ts b/test/support/tester/sinonSandboxUtils.ts
index 6c66d896b..d68aeb158 100644
--- a/test/support/tester/sinonSandboxUtils.ts
+++ b/test/support/tester/sinonSandboxUtils.ts
@@ -51,11 +51,9 @@ 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, "getRegistration")
+  sinonSandbox.stub(ServiceWorkerManager.prototype, "getRegistration")
     .resolves(swRegistration);
   sinonSandbox.stub(WorkerMessenger.prototype, "unicast").resolves();
 }
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'])
 });
 
 /*
diff --git a/test/unit/helpers/page/ServiceWorkerUtilHelper.ts b/test/unit/helpers/page/ServiceWorkerUtilHelper.ts
new file mode 100644
index 000000000..7cacce4f8
--- /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
diff --git a/test/unit/managers/ServiceWorkerManager.ts b/test/unit/managers/ServiceWorkerManager.ts
index af4d3c99f..29fe2cd17 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 {
@@ -57,8 +58,6 @@ test.beforeEach(async function() {
 });
 
 test.afterEach(function () {
-  if (getRegistrationStub.callCount > 0)
-    sandbox.assert.alwaysCalledWithExactly(getRegistrationStub, location.href);
   sandbox.restore();
 });
 
@@ -97,17 +96,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');
 
@@ -115,32 +103,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');
 
@@ -223,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 => {
@@ -241,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 => {
@@ -424,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');
@@ -431,6 +403,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/meta/mockPushManager.ts b/test/unit/meta/mockPushManager.ts
index cf2d215fc..92a13a1b5 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,13 @@ 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;
-
-  let subscription = await registration.pushManager.subscribe({
+  const registration = await getServiceWorkerRegistration();
+  const subscription = await registration!.pushManager.subscribe({
     userVisibleOnly: true,
     applicationServerKey: Random.getRandomUint8Array(64).buffer
   });
   await subscription.unsubscribe();
-  subscription = await registration.pushManager.getSubscription();
-  t.is(subscription, null);
-});
 
+  const subscriptionToCheck = await registration!.pushManager.getSubscription();
+  t.is(subscriptionToCheck, null);
+});
diff --git a/test/unit/meta/mockServiceWorker.ts b/test/unit/meta/mockServiceWorker.ts
index b904996e3..88665d9fb 100644
--- a/test/unit/meta/mockServiceWorker.ts
+++ b/test/unit/meta/mockServiceWorker.ts
@@ -7,17 +7,20 @@ 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 => {
   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);
 });
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
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");
