[tbb-commits] [tor-browser/tor-browser-78.12.0esr-11.0-1] fixup! Bug 27476: Implement about:torconnect captive portal within Tor Browser

sysrqb at torproject.org sysrqb at torproject.org
Thu Jul 22 17:46:25 UTC 2021


commit 73d57c01c2bfe398c02586ae76dab677d843df22
Author: Richard Pospesel <richard at torproject.org>
Date:   Fri Jul 16 17:32:01 2021 +0200

    fixup! Bug 27476: Implement about:torconnect captive portal within Tor Browser
---
 browser/actors/NetErrorParent.jsm                  |   6 +-
 browser/base/content/browser.js                    |   5 +-
 browser/components/BrowserGlue.jsm                 |  32 +-
 browser/components/torconnect/TorConnectParent.jsm | 200 +++++----
 .../torconnect/content/aboutTorConnect.js          | 466 +++++++++-----------
 .../torconnect/content/aboutTorConnect.xhtml       |   9 -
 .../torconnect/content/torBootstrapUrlbar.js       | 195 ++++-----
 .../components/torpreferences/content/torPane.js   |   8 +-
 browser/components/urlbar/UrlbarInput.jsm          |   6 +-
 browser/modules/TorConnect.jsm                     | 477 +++++++++++++++++++--
 browser/modules/TorProtocolService.jsm             | 101 +++--
 .../processsingleton/MainProcessSingleton.jsm      |   5 +
 toolkit/modules/RemotePageAccessManager.jsm        |  28 +-
 13 files changed, 941 insertions(+), 597 deletions(-)

diff --git a/browser/actors/NetErrorParent.jsm b/browser/actors/NetErrorParent.jsm
index fa3cbf23fcb7..6dce9af5aad0 100644
--- a/browser/actors/NetErrorParent.jsm
+++ b/browser/actors/NetErrorParent.jsm
@@ -17,8 +17,8 @@ const { SessionStore } = ChromeUtils.import(
 );
 const { HomePage } = ChromeUtils.import("resource:///modules/HomePage.jsm");
 
-const { TorProtocolService } = ChromeUtils.import(
-  "resource:///modules/TorProtocolService.jsm"
+const { TorConnect } = ChromeUtils.import(
+  "resource:///modules/TorConnect.jsm"
 );
 
 const PREF_SSL_IMPACT_ROOTS = [
@@ -324,7 +324,7 @@ class NetErrorParent extends JSWindowActorParent {
         }
         break;
       case "ShouldShowTorConnect":
-        return TorProtocolService.shouldShowTorConnect();
+        return TorConnect.shouldShowTorConnect;
     }
     return undefined;
   }
diff --git a/browser/base/content/browser.js b/browser/base/content/browser.js
index 916cd69320cb..996ef6dcdd7f 100644
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -77,7 +77,7 @@ XPCOMUtils.defineLazyModuleGetters(this, {
   TabModalPrompt: "chrome://global/content/tabprompts.jsm",
   TabCrashHandler: "resource:///modules/ContentCrashHandlers.jsm",
   TelemetryEnvironment: "resource://gre/modules/TelemetryEnvironment.jsm",
-  TorProtocolService: "resource:///modules/TorProtocolService.jsm",
+  TorConnect: "resource:///modules/TorConnect.jsm",
   Translation: "resource:///modules/translation/TranslationParent.jsm",
   OnionAliasStore: "resource:///modules/OnionAliasStore.jsm",
   UITour: "resource:///modules/UITour.jsm",
@@ -2494,7 +2494,8 @@ var gBrowserInit = {
       let uri = window.arguments[0];
       let defaultArgs = BrowserHandler.defaultArgs;
 
-      if (TorProtocolService.shouldShowTorConnect()) {
+      if (TorConnect.shouldShowTorConnect) {
+        TorConnect.setURIsToLoad(uri);
         return "about:torconnect";
       }
 
diff --git a/browser/components/BrowserGlue.jsm b/browser/components/BrowserGlue.jsm
index 8735783cee2b..cb77f4d82a3e 100644
--- a/browser/components/BrowserGlue.jsm
+++ b/browser/components/BrowserGlue.jsm
@@ -17,31 +17,6 @@ const { AppConstants } = ChromeUtils.import(
   "resource://gre/modules/AppConstants.jsm"
 );
 
-// TorProtocolService and TorConnect modules need to be lazily-loaded
-// here because they will trigger generation of the random password used
-// to talk to the tor daemon in tor-launcher. Generating the random
-// password will initialize the cryptographic service ( nsNSSComponent )
-//
-// If this service is init'd before the profile has been setup, it will
-// use the fallback init path which behaves as if security.nocertdb=true
-//
-// We make these module getters so init happens when they are needed
-// (when init'ing the OnionAliasStore). With theze getters, the password
-// generation is triggered in torbutton after the 'profile-after-change'
-// topic (so after the profile is initialized)
-
-ChromeUtils.defineModuleGetter(
-  this,
-  "TorProtocolService",
-  "resource:///modules/TorProtocolService.jsm"
-);
-
-ChromeUtils.defineModuleGetter(
-  this,
-  "TorConnect",
-  "resource:///modules/TorConnect.jsm"
-);
-
 ChromeUtils.defineModuleGetter(
   this,
   "ActorManagerParent",
@@ -2531,14 +2506,17 @@ BrowserGlue.prototype = {
 
       {
         task: () => {
-          if (TorProtocolService.isBootstrapDone() || !TorProtocolService.ownsTorDaemon) {
+          const { TorConnect, TorConnectTopics } = ChromeUtils.import(
+            "resource:///modules/TorConnect.jsm"
+          );
+          if (!TorConnect.shouldShowTorConnect) {
             // we will take this path when the user is using the legacy tor launcher or
             // when Tor Browser didn't launch its own tor.
             OnionAliasStore.init();
           } else {
             // this path is taken when using about:torconnect, we wait to init
             // after we are bootstrapped and connected to tor
-            const topic = "torconnect:bootstrap-complete";
+            const topic = TorConnectTopics.BootstrapComplete;
             let bootstrapObserver = {
               observe(aSubject, aTopic, aData) {
                 if (aTopic === topic) {
diff --git a/browser/components/torconnect/TorConnectParent.jsm b/browser/components/torconnect/TorConnectParent.jsm
index c34fab76ddbb..3937bf3ebcf8 100644
--- a/browser/components/torconnect/TorConnectParent.jsm
+++ b/browser/components/torconnect/TorConnectParent.jsm
@@ -3,123 +3,139 @@
 var EXPORTED_SYMBOLS = ["TorConnectParent"];
 
 const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
-const { TorProtocolService } = ChromeUtils.import(
-  "resource:///modules/TorProtocolService.jsm"
-);
 const { TorStrings } = ChromeUtils.import("resource:///modules/TorStrings.jsm");
-const { TorLauncherUtil } = ChromeUtils.import(
-  "resource://torlauncher/modules/tl-util.jsm"
-);
-
-const { TorConnect } = ChromeUtils.import(
+const { TorConnect, TorConnectTopics, TorConnectState } = ChromeUtils.import(
   "resource:///modules/TorConnect.jsm"
 );
 
-const kTorProcessReadyTopic = "TorProcessIsReady";
-const kTorProcessExitedTopic = "TorProcessExited";
-const kTorProcessDidNotStartTopic = "TorProcessDidNotStart";
-const kTorShowProgressPanelTopic = "TorShowProgressPanel";
-const kTorBootstrapStatusTopic = "TorBootstrapStatus";
-const kTorBootstrapErrorTopic = "TorBootstrapError";
-const kTorLogHasWarnOrErrTopic = "TorLogHasWarnOrErr";
-
-const gActiveTopics = [
-  kTorProcessReadyTopic,
-  kTorProcessExitedTopic,
-  kTorProcessDidNotStartTopic,
-  kTorShowProgressPanelTopic,
-  kTorBootstrapStatusTopic,
-  kTorBootstrapErrorTopic,
-  kTorLogHasWarnOrErrTopic,
-  "torconnect:bootstrap-complete",
-];
-
-const gTorLauncherPrefs = {
+const TorLauncherPrefs = Object.freeze({
   quickstart: "extensions.torlauncher.quickstart",
-}
+});
+
+/*
+This object is basically a marshalling interface between the TorConnect module
+and a particular about:torconnect page
+*/
 
 class TorConnectParent extends JSWindowActorParent {
   constructor(...args) {
     super(...args);
 
     const self = this;
-    this.gObserver = {
-      observe(aSubject, aTopic, aData) {
-        const obj = aSubject?.wrappedJSObject;
-        if (obj) {
-          obj.handled = true;
-        }
-        self.sendAsyncMessage(aTopic, obj);
-      },
-    };
 
-    for (const topic of gActiveTopics) {
-      Services.obs.addObserver(this.gObserver, topic);
-    }
+    this.state = {
+      State: TorConnect.state,
+      ErrorMessage: TorConnect.errorMessage,
+      ErrorDetails: TorConnect.errorDetails,
+      BootstrapProgress: TorConnect.bootstrapProgress,
+      BootstrapStatus: TorConnect.bootstrapStatus,
+      ShowCopyLog: TorConnect.logHasWarningOrError,
+      QuickStartEnabled: Services.prefs.getBoolPref(TorLauncherPrefs.quickstart, false),
+    };
 
-    this.quickstartObserver = {
+    // JSWindowActiveParent derived objects cannot observe directly, so create a member
+    // object to do our observing for us
+    //
+    // This object converts the various lifecycle events from the TorConnect module, and
+    // maintains a state object which we pass down to our about:torconnect page, which uses
+    // the state object to update its UI
+    this.torConnectObserver = {
       observe(aSubject, aTopic, aData) {
-        if (aTopic === "nsPref:changed" &&
-            aData == gTorLauncherPrefs.quickstart) {
-          self.sendAsyncMessage("TorQuickstartPrefChanged", Services.prefs.getBoolPref(gTorLauncherPrefs.quickstart));
+        let obj = aSubject?.wrappedJSObject;
+
+        // update our state struct based on received torconnect topics and forward on
+        // to aboutTorConnect.js
+        switch(aTopic) {
+          case TorConnectTopics.StateChange: {
+            self.state.State = obj.state;
+            // clear any previous error information if we are bootstrapping
+            if (self.state.State === TorConnectState.Bootstrapping) {
+              self.state.ErrorMessage = null;
+              self.state.ErrorDetails = null;
+            }
+            break;
+          }
+          case TorConnectTopics.BootstrapProgress: {
+            self.state.BootstrapProgress = obj.progress;
+            self.state.BootstrapStatus = obj.status;
+            self.state.ShowCopyLog = obj.hasWarnings;
+            break;
+          }
+          case TorConnectTopics.BootstrapComplete: {
+            // tells about:torconnect pages to close themselves
+            // this flag will only be set if an about:torconnect page
+            // reaches the Bootstrapped state, so if a user
+            // navigates to about:torconnect manually after bootstrap, the page
+            // will not auto-close on them
+            self.state.Close = true;
+            break;
+          }
+          case TorConnectTopics.BootstrapError: {
+            self.state.ErrorMessage = obj.message;
+            self.state.ErrorDetails = obj.details;
+            self.state.ShowCopyLog = true;
+            break;
+          }
+          case TorConnectTopics.FatalError: {
+            // TODO: handle
+            break;
+          }
+          case "nsPref:changed": {
+            if (aData === TorLauncherPrefs.quickstart) {
+              self.state.QuickStartEnabled = Services.prefs.getBoolPref(TorLauncherPrefs.quickstart);
+            }
+            break;
+          }
+          default: {
+            console.log(`TorConnect: unhandled observe topic '${aTopic}'`);
+          }
         }
+
+        self.sendAsyncMessage("torconnect:state-change", self.state);
       },
+    };
+
+    // observe all of the torconnect:.* topics
+    for (const key in TorConnectTopics) {
+      const topic = TorConnectTopics[key];
+      Services.obs.addObserver(this.torConnectObserver, topic);
     }
-    Services.prefs.addObserver(gTorLauncherPrefs.quickstart, this.quickstartObserver);
+    Services.prefs.addObserver(TorLauncherPrefs.quickstart, this.torConnectObserver);
   }
 
   willDestroy() {
-    for (const topic of gActiveTopics) {
-      Services.obs.removeObserver(this.gObserver, topic);
+    // stop observing all of our torconnect:.* topics
+    for (const key in TorConnectTopics) {
+      const topic = TorConnectTopics[key];
+      Services.obs.removeObserver(this.torConnectObserver, topic);
     }
-  }
-
-
-  _OpenTorAdvancedPreferences() {
-    const win = this.browsingContext.top.embedderElement.ownerGlobal;
-    win.openTrustedLinkIn("about:preferences#tor", "tab");
-  }
-
-  _TorCopyLog() {
-    // Copy tor log messages to the system clipboard.
-    const chSvc = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(
-      Ci.nsIClipboardHelper
-    );
-    const countObj = { value: 0 };
-    chSvc.copyString(TorProtocolService.getLog(countObj));
-    const count = countObj.value;
-    return TorLauncherUtil.getFormattedLocalizedString(
-      "copiedNLogMessagesShort",
-      [count],
-      1
-    );
+    Services.prefs.removeObserver(TorLauncherPrefs.quickstart, this.torConnectObserver);
   }
 
   receiveMessage(message) {
     switch (message.name) {
-      case "TorBootstrapErrorOccurred":
-        return TorProtocolService.torBootstrapErrorOccurred();
-      case "TorRetrieveBootstrapStatus":
-        return TorProtocolService.retrieveBootstrapStatus();
-      case "OpenTorAdvancedPreferences":
-        return this._OpenTorAdvancedPreferences();
-      case "GetLocalizedBootstrapStatus":
-        const { status, keyword } = message.data;
-        return TorLauncherUtil.getLocalizedBootstrapStatus(status, keyword);
-      case "TorCopyLog":
-        return this._TorCopyLog();
-      case "TorIsNetworkDisabled":
-        return TorProtocolService.isNetworkDisabled();
-      case "TorStopBootstrap":
-        return TorProtocolService.torStopBootstrap();
-      case "TorConnect":
-        return TorProtocolService.connect();
-      case "GetDirection":
-        return Services.locale.isAppLocaleRTL ? "rtl" : "ltr";
-      case "GetTorStrings":
-        return TorStrings;
-      case "TorLogHasWarnOrErr":
-        return TorProtocolService.torLogHasWarnOrErr();
+      case "torconnect:set-quickstart":
+        Services.prefs.setBoolPref(TorLauncherPrefs.quickstart, message.data);
+        break;
+      case "torconnect:open-tor-preferences":
+        TorConnect.openTorPreferences();
+        break;
+      case "torconnect:copy-tor-logs":
+        return TorConnect.copyTorLogs();
+      case "torconnect:cancel-bootstrap":
+        TorConnect.cancelBootstrap();
+        break;
+      case "torconnect:begin-bootstrap":
+        TorConnect.beginBootstrap();
+        break;
+      case "torconnect:get-init-args":
+        // called on AboutTorConnect.init(), pass down all state data it needs to init
+        return {
+            TorStrings: TorStrings,
+            TorConnectState: TorConnectState,
+            Direction: Services.locale.isAppLocaleRTL ? "rtl" : "ltr",
+            State: this.state,
+        };
     }
     return undefined;
   }
diff --git a/browser/components/torconnect/content/aboutTorConnect.js b/browser/components/torconnect/content/aboutTorConnect.js
index 19fd335ccd13..8b269d2fc82b 100644
--- a/browser/components/torconnect/content/aboutTorConnect.js
+++ b/browser/components/torconnect/content/aboutTorConnect.js
@@ -2,299 +2,258 @@
 
 /* eslint-env mozilla/frame-script */
 
-const kTorProcessReadyTopic = "TorProcessIsReady";
-const kTorProcessExitedTopic = "TorProcessExited";
-const kTorProcessDidNotStartTopic = "TorProcessDidNotStart";
-const kTorBootstrapStatusTopic = "TorBootstrapStatus";
-const kTorBootstrapErrorTopic = "TorBootstrapError";
-const kTorLogHasWarnOrErrTopic = "TorLogHasWarnOrErr";
-const kTorQuickstartPrefChanged = "TorQuickstartPrefChanged";
-
-const TorLauncherPrefs = {
-  quickstart: "extensions.torlauncher.quickstart",
-  prompt_at_startup: "extensions.torlauncher.prompt_at_startup",
-}
+// populated in AboutTorConnect.init()
+let TorStrings = {};
+let TorConnectState = {};
 
 class AboutTorConnect {
-  log(...args) {
-    console.log(...args);
-  }
-
-  logError(...args) {
-    console.error(...args);
-  }
+  selectors = Object.freeze({
+    textContainer: {
+      title: "div.title",
+      titleText: "h1.title-text",
+    },
+    progress: {
+      description: "p#connectShortDescText",
+      meter: "div#progressBackground",
+    },
+    copyLog: {
+      link: "span#copyLogLink",
+      tooltip: "div#copyLogTooltip",
+      tooltipText: "span#copyLogTooltipText",
+    },
+    quickstart: {
+      checkbox: "input#quickstartCheckbox",
+      label: "label#quickstartCheckboxLabel",
+    },
+    buttons: {
+      connect: "button#connectButton",
+      cancel: "button#cancelButton",
+      advanced: "button#advancedButton",
+    },
+  })
+
+  elements = Object.freeze({
+    title: document.querySelector(this.selectors.textContainer.title),
+    titleText: document.querySelector(this.selectors.textContainer.titleText),
+    progressDescription: document.querySelector(this.selectors.progress.description),
+    progressMeter: document.querySelector(this.selectors.progress.meter),
+    copyLogLink: document.querySelector(this.selectors.copyLog.link),
+    copyLogTooltip: document.querySelector(this.selectors.copyLog.tooltip),
+    copyLogTooltipText: document.querySelector(this.selectors.copyLog.tooltipText),
+    quickstartCheckbox: document.querySelector(this.selectors.quickstart.checkbox),
+    quickstartLabel: document.querySelector(this.selectors.quickstart.label),
+    connectButton: document.querySelector(this.selectors.buttons.connect),
+    cancelButton: document.querySelector(this.selectors.buttons.cancel),
+    advancedButton: document.querySelector(this.selectors.buttons.advanced),
+  })
+
+  beginBootstrap() {
+    this.hide(this.elements.connectButton);
+    this.show(this.elements.cancelButton);
+    this.elements.cancelButton.focus();
+    RPMSendAsyncMessage("torconnect:begin-bootstrap");
+  }
+
+  cancelBootstrap() {
+    RPMSendAsyncMessage("torconnect:cancel-bootstrap");
+  }
+
+  /*
+  Element helper methods
+  */
+
+  show(element) {
+    element.removeAttribute("hidden");
+  }
+
+  hide(element) {
+    element.setAttribute("hidden", "true");
+  }
+
+  setTitle(title, error) {
+    this.elements.titleText.textContent = title;
+    document.title = title;
 
-  logDebug(...args) {
-    console.debug(...args);
+    if (error) {
+      this.elements.title.classList.add("error");
+    } else {
+      this.elements.title.classList.remove("error");
+    }
   }
 
-  getElem(id) {
-    return document.getElementById(id);
-  }
-  get elemProgressContent() {
-    return this.getElem("progressContent");
-  }
-  get elemProgressDesc() {
-    return this.getElem("connectShortDescText");
-  }
-  get elemProgressMeter() {
-    return this.getElem("progressBackground");
-  }
-  get elemCopyLogLink() {
-    return this.getElem("copyLogLink");
-  }
-  get elemCopyLogTooltip() {
-    return this.getElem("copyLogTooltip");
-  }
-  get elemCopyLogTooltipText() {
-    return this.getElem("copyLogTooltipText");
-  }
-  get elemQuickstartCheckbox() {
-    return this.getElem("quickstartCheckbox");
-  }
-  get elemQuickstartLabel() {
-    return this.getElem("quickstartCheckboxLabel");
-  }
-  get elemConnectButton() {
-    return this.getElem("connectButton");
-  }
-  get elemAdvancedButton() {
-    return this.getElem("advancedButton");
-  }
-  get elemCancelButton() {
-    return this.getElem("cancelButton");
-  }
-  get elemTextContainer() {
-    return this.getElem("text-container");
-  }
-  get elemTitle() {
-    return this.elemTextContainer.getElementsByClassName("title")[0];
+  setProgress(description, visible, percent) {
+    this.elements.progressDescription.textContent = description;
+    if (visible) {
+      this.show(this.elements.progressMeter);
+      this.elements.progressMeter.style.width = `${percent}%`;
+    } else {
+      this.hide(this.elements.progressMeter);
+    }
   }
 
-  static get STATE_INITIAL() {
-    return "STATE_INITIAL";
-  }
+  /*
+  These methods update the UI based on the current TorConnect state
+  */
 
-  static get STATE_BOOTSTRAPPING() {
-    return "STATE_BOOTSTRAPPING";
-  }
+  updateUI(state) {
+    console.log(state);
 
-  static get STATE_BOOTSTRAPPED() {
-    return "STATE_BOOTSTRAPPED";
-  }
+    // calls update_$state()
+    this[`update_${state.State}`](state);
 
-  static get STATE_BOOTSTRAP_ERROR() {
-    return "STATE_BOOTSTRAP_ERROR";
+    if (state.ShowCopyLog) {
+      this.showCopyLog();
+    }
+    this.elements.quickstartCheckbox.checked = state.QuickStartEnabled;
   }
 
-  get state() {
-    return this._state;
-  }
+  /* Per-state updates */
 
-  setInitialUI() {
-    this.setTitle(this.torStrings.torConnect.torConnect);
-    this.elemProgressDesc.textContent =
-      this.torStrings.settings.torPreferencesDescription;
-    this.showElem(this.elemConnectButton);
-    this.elemConnectButton.focus();
-    this.showElem(this.elemAdvancedButton);
-    this.hideElem(this.elemCopyLogLink);
-    this.hideElem(this.elemCancelButton);
-    this.hideElem(this.elemProgressContent);
-    this.hideElem(this.elemProgressMeter);
-    this.elemTitle.classList.remove("error");
-  }
+  update_Initial(state) {
+    const hasError = false;
+    const showProgressbar = false;
 
-  setBootstrappingUI() {
-    this.setTitle(this.torStrings.torConnect.torConnecting);
-    this.hideElem(this.elemConnectButton);
-    this.hideElem(this.elemAdvancedButton);
-    this.hideElem(this.elemCopyLogLink);
-    this.showElem(this.elemCancelButton);
-    this.elemCancelButton.focus();
-    this.showElem(this.elemProgressContent);
-    this.showElem(this.elemProgressMeter);
-    this.elemTitle.classList.remove("error");
+    this.setTitle(TorStrings.torConnect.torConnect, hasError);
+    this.setProgress(TorStrings.settings.torPreferencesDescription, showProgressbar);
+    this.hide(this.elements.copyLogLink);
+    this.hide(this.elements.connectButton);
+    this.hide(this.elements.advancedButton);
+    this.hide(this.elements.cancelButton);
   }
 
-  setBootstrapErrorUI() {
-    this.setTitle(this.torStrings.torConnect.torBootstrapFailed);
-    this.elemConnectButton.textContent = this.torStrings.torConnect.tryAgain;
-    this.showElem(this.elemConnectButton);
-    this.hideElem(this.elemCancelButton);
-    this.showElem(this.elemAdvancedButton);
-    this.elemAdvancedButton.focus();
-    this.showElem(this.elemProgressContent);
-    this.hideElem(this.elemProgressMeter);
-    this.elemTitle.classList.add("error");
-  }
+  update_Configuring(state) {
+    const hasError = state.ErrorMessage != null;
+    const showProgressbar = false;
 
-  set state(state) {
-    const oldState = this.state;
-    if (oldState === state) {
-      return;
-    }
-    this._state = state;
-    switch (this.state) {
-      case AboutTorConnect.STATE_INITIAL:
-        this.setInitialUI();
-        break;
-      case AboutTorConnect.STATE_BOOTSTRAPPING:
-        this.setBootstrappingUI();
-        break;
-      case AboutTorConnect.STATE_BOOTSTRAP_ERROR:
-        this.setBootstrapErrorUI();
-        break;
-      case AboutTorConnect.STATE_BOOTSTRAPPED:
-        window.close();
-        break;
+    if (hasError) {
+      this.setTitle(state.ErrorMessage, hasError);
+      this.setProgress(state.ErrorDetails, showProgressbar);
+      this.show(this.elements.copyLogLink);
+      this.elements.connectButton.textContent = TorStrings.torConnect.tryAgain;
+    } else {
+      this.setTitle(TorStrings.torConnect.torConnect, hasError);
+      this.setProgress(TorStrings.settings.torPreferencesDescription, showProgressbar);
+      this.hide(this.elements.copyLogLink);
+      this.elements.connectButton.textContent = TorStrings.torConnect.torConnectButton;
     }
+    this.show(this.elements.connectButton);
+    this.elements.connectButton.focus();
+    this.show(this.elements.advancedButton);
+    this.hide(this.elements.cancelButton);
   }
 
-  async showErrorMessage(aErrorObj) {
-    if (aErrorObj && aErrorObj.message) {
-      this.setTitle(aErrorObj.message);
-      if (aErrorObj.details) {
-        this.elemProgressDesc.textContent = aErrorObj.details;
-      }
-    }
-
-    this.showCopyLog();
-    this.showElem(this.elemConnectButton);
+  update_AutoConfiguring(state) {
+    // TODO: noop until this state is used
   }
 
-  showElem(elem) {
-    elem.removeAttribute("hidden");
-  }
+  update_Bootstrapping(state) {
+    const hasError = false;
+    const showProgressbar = true;
 
-  hideElem(elem) {
-    elem.setAttribute("hidden", "true");
+    this.setTitle(state.BootstrapStatus ? state.BootstrapStatus : TorStrings.torConnect.torConnecting, hasError);
+    this.setProgress(TorStrings.settings.torPreferencesDescription, showProgressbar, state.BootstrapProgress);
+    if (state.ShowCopyLog) {
+      this.show(this.elements.copyLogLink);
+    } else {
+      this.hide(this.elements.copyLogLink);
+    }
+    this.hide(this.elements.connectButton);
+    this.hide(this.elements.advancedButton);
+    this.show(this.elements.cancelButton);
+    this.elements.cancelButton.focus();
   }
 
-  async connect() {
-    // reset the text to original description
-    // in case we are trying again after an error (clears out error text)
-    this.elemProgressDesc.textContent =
-      this.torStrings.settings.torPreferencesDescription;
+  update_Error(state) {
+    const hasError = true;
+    const showProgressbar = false;
 
-    this.state = AboutTorConnect.STATE_BOOTSTRAPPING;
-    const error = await RPMSendQuery("TorConnect");
-    if (error) {
-      if (error.details) {
-        this.showErrorMessage({ message: error.details }, true);
-        this.showSaveSettingsError(error.details);
-      }
-    }
+    this.setTitle(state.ErrorMessage, hasError);
+    this.setProgress(state.ErrorDetails, showProgressbar);
+    this.show(this.elements.copyLogLink);
+    this.elements.connectButton.textContent = TorStrings.torConnect.tryAgain;
+    this.show(this.elements.connectButton);
+    this.show(this.elements.advancedButton);
+    this.hide(this.elements.cancelButton);
   }
 
-  showCopyLog() {
-    this.elemCopyLogLink.removeAttribute("hidden");
+  update_FatalError(state) {
+    // TODO: noop until this state is used
   }
 
-  async updateBootstrapProgress(status) {
-    let labelText = await RPMSendQuery("GetLocalizedBootstrapStatus", {
-      status,
-      keyword: "TAG",
-    });
-    let percentComplete = status.PROGRESS ? status.PROGRESS : 0;
-    this.elemProgressMeter.style.width = `${percentComplete}%`;
-
-    if (await RPMSendQuery("TorBootstrapErrorOccurred")) {
-      this.state = AboutTorConnect.STATE_BOOTSTRAP_ERROR;
-      return;
-    } else if (await RPMSendQuery("TorIsNetworkDisabled")) {
-      // If tor network is not connected, let's go to the initial state, even
-      // if bootstrap state is greater than 0.
-      this.state = AboutTorConnect.STATE_INITIAL;
-      return;
-    } else if (percentComplete > 0) {
-      this.state = AboutTorConnect.STATE_BOOTSTRAPPING;
-    }
+  update_Bootstrapped(state) {
+    const hasError = false;
+    const showProgressbar = true;
 
-    // Due to async, status might have changed. Do not override desc if so.
-    if (this.state === AboutTorConnect.STATE_BOOTSTRAPPING) {
-      this.hideElem(this.elemConnectButton);
+    this.setTitle(TorStrings.torConnect.torConnected, hasError);
+    this.setProgress(TorStrings.settings.torPreferencesDescription, showProgressbar, 100);
+    this.hide(this.elements.connectButton);
+    this.hide(this.elements.advancedButton);
+    this.hide(this.elements.cancelButton);
+
+    // only close the window if directed
+    if (state.Close) {
+      window.close();
     }
   }
 
-  stopTorBootstrap() {
-    RPMSendAsyncMessage("TorStopBootstrap");
+  update_Disabled(state) {
+    // TODO: we should probably have some UX here if a user goes to about:torconnect when
+    // it isn't in use (eg using tor-launcher or system tor)
   }
 
-  setTitle(title) {
-    const titleElement = document.querySelector(".title-text");
-    titleElement.textContent = title;
-    document.title = title;
-  }
+  async initElements(direction, quickstart) {
 
-  async initElements() {
-    this.elemAdvancedButton.textContent = this.torStrings.torConnect.torConfigure;
-    this.elemAdvancedButton.addEventListener("click", () => {
-      RPMSendAsyncMessage("OpenTorAdvancedPreferences");
-    });
+    document.documentElement.setAttribute("dir", direction);
 
-    // sets the text content while keping the child elements intact
-    this.elemCopyLogLink.childNodes[0].nodeValue =
-      this.torStrings.torConnect.copyLog;
-    this.elemCopyLogLink.addEventListener("click", async (event) => {
-      const copiedMessage = await RPMSendQuery("TorCopyLog");
-      aboutTorConnect.elemCopyLogTooltipText.textContent = copiedMessage;
-      aboutTorConnect.elemCopyLogTooltip.style.visibility = "visible";
+    // sets the text content while keeping the child elements intact
+    this.elements.copyLogLink.childNodes[0].nodeValue =
+      TorStrings.torConnect.copyLog;
+    this.elements.copyLogLink.addEventListener("click", async (event) => {
+      const copiedMessage = await RPMSendQuery("torconnect:copy-tor-logs");
+      this.elements.copyLogTooltipText.textContent = copiedMessage;
+      this.elements.copyLogTooltipText.style.visibility = "visible";
 
       // clear previous timeout if one already exists
-      if (aboutTorConnect.copyLogTimeoutId) {
-        clearTimeout(aboutTorConnect.copyLogTimeoutId);
+      if (this.copyLogTimeoutId) {
+        clearTimeout(this.copyLogTimeoutId);
       }
 
       // hide tooltip after X ms
       const TOOLTIP_TIMEOUT = 2000;
-      aboutTorConnect.copyLogTimeoutId = setTimeout(function() {
-        aboutTorConnect.elemCopyLogTooltip.style.visibility = "hidden";
-        aboutTorConnect.copyLogTimeoutId = 0;
+      this.copyLogTimeoutId = setTimeout(function() {
+        this.elements.copyLogTooltipText.style.visibility = "hidden";
+        this.copyLogTimeoutId = 0;
       }, TOOLTIP_TIMEOUT);
     });
 
+    this.elements.quickstartCheckbox.checked = quickstart
+    this.elements.quickstartCheckbox.addEventListener("change", () => {
+      const quickstart = this.elements.quickstartCheckbox.checked;
+      RPMSendAsyncMessage("torconnect:set-quickstart", quickstart);
+    });
+    this.elements.quickstartLabel.textContent = TorStrings.settings.quickstartCheckbox;
 
-    this.elemQuickstartLabel.textContent = this.torStrings.settings.quickstartCheckbox;
-    this.elemQuickstartCheckbox.addEventListener("change", () => {
-      const quickstart = this.elemQuickstartCheckbox.checked;
-      RPMSetBoolPref(TorLauncherPrefs.quickstart, quickstart);
+    this.elements.connectButton.textContent =
+      TorStrings.torConnect.torConnectButton;
+    this.elements.connectButton.addEventListener("click", () => {
+      this.beginBootstrap();
     });
-    this.elemQuickstartCheckbox.checked = await RPMGetBoolPref(TorLauncherPrefs.quickstart);
 
-    this.elemConnectButton.textContent =
-      this.torStrings.torConnect.torConnectButton;
-    this.elemConnectButton.addEventListener("click", () => {
-      this.connect();
+    this.elements.advancedButton.textContent = TorStrings.torConnect.torConfigure;
+    this.elements.advancedButton.addEventListener("click", () => {
+      RPMSendAsyncMessage("torconnect:open-tor-preferences");
     });
 
-    this.elemCancelButton.textContent = this.torStrings.torConnect.cancel;
-    this.elemCancelButton.addEventListener("click", () => {
-      this.stopTorBootstrap();
+    this.elements.cancelButton.textContent = TorStrings.torConnect.cancel;
+    this.elements.cancelButton.addEventListener("click", () => {
+      this.cancelBootstrap();
     });
   }
 
   initObservers() {
-    RPMAddMessageListener(kTorBootstrapErrorTopic, ({ data }) => {
-      this.showCopyLog();
-      this.stopTorBootstrap();
-      this.showErrorMessage(data);
-    });
-    RPMAddMessageListener(kTorLogHasWarnOrErrTopic, () => {
-      this.showCopyLog();
-    });
-    RPMAddMessageListener(kTorProcessDidNotStartTopic, ({ data }) => {
-      this.showErrorMessage(data);
-    });
-    RPMAddMessageListener(kTorBootstrapStatusTopic, ({ data }) => {
-      this.updateBootstrapProgress(data);
-    });
-    RPMAddMessageListener(kTorQuickstartPrefChanged, ({ data }) => {
-      // update checkbox with latest quickstart pref value
-      this.elemQuickstartCheckbox.checked = data;
-    });
-    RPMAddMessageListener("torconnect:bootstrap-complete", () => {
-      this.state = AboutTorConnect.STATE_BOOTSTRAPPED;
+    // TorConnectParent feeds us state blobs to we use to update our UI
+    RPMAddMessageListener("torconnect:state-change", ({ data }) => {
+      this.updateUI(data);
     });
   }
 
@@ -304,34 +263,25 @@ class AboutTorConnect {
       // integers, so we must resort to a string compare here :(
       // see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code for relevant documentation
       if (evt.code === "Escape") {
-        this.stopTorBootstrap();
+        this.cancelBootstrap();
       }
     };
   }
 
   async init() {
-    this.torStrings = await RPMSendQuery("GetTorStrings");
-    document.documentElement.setAttribute(
-      "dir",
-      await RPMSendQuery("GetDirection")
-    );
-    this.initElements();
+
+    let args = await RPMSendQuery("torconnect:get-init-args");
+
+    // various constants
+    TorStrings = Object.freeze(args.TorStrings);
+    TorConnectState = Object.freeze(args.TorConnectState);
+
+    this.initElements(args.Direction);
     this.initObservers();
     this.initKeyboardShortcuts();
-    this.state = AboutTorConnect.STATE_INITIAL;
-
-    // Request the most recent bootstrap status info so that a
-    // TorBootstrapStatus notification is generated as soon as possible.
-    RPMSendAsyncMessage("TorRetrieveBootstrapStatus");
-
-    // quickstart is the user set pref for starting tor automatically
-    // prompt_at_startup will be set to false after successful bootstrap, and true on error
-    // by tor-launcher, so we want to keep the connect screen up when prompt_at_startup is true
-    ///  even if quickstart is enabled so user can potentially resolve errors on next launch
-    if (await RPMGetBoolPref(TorLauncherPrefs.quickstart) &&
-       !await RPMGetBoolPref(TorLauncherPrefs.prompt_at_startup)) {
-      this.connect();
-    }
+
+    // populate UI based on current state
+    this.updateUI(args.State);
   }
 }
 
diff --git a/browser/components/torconnect/content/aboutTorConnect.xhtml b/browser/components/torconnect/content/aboutTorConnect.xhtml
index 0a0721afb7db..595bbdf9a70a 100644
--- a/browser/components/torconnect/content/aboutTorConnect.xhtml
+++ b/browser/components/torconnect/content/aboutTorConnect.xhtml
@@ -19,15 +19,6 @@
           </div>
         </div>
 
-        <div id="progressContent" hidden="true">
-          <div class="tbb-header" pack="center">
-            <image class="tbb-logo"/>
-          </div>
-          <div flex="1">
-            <div id="progressDesc"/>
-          </div>
-        </div>
-
         <div id="copyLogContainer">
           <span id="copyLogLink" hidden="true">
             <div id="copyLogTooltip">
diff --git a/browser/components/torconnect/content/torBootstrapUrlbar.js b/browser/components/torconnect/content/torBootstrapUrlbar.js
index 55a595b2dbab..e4fd6f5ab910 100644
--- a/browser/components/torconnect/content/torBootstrapUrlbar.js
+++ b/browser/components/torconnect/content/torBootstrapUrlbar.js
@@ -2,135 +2,88 @@
 
 "use strict";
 
- const TorConnectionStatus = {
-   invalid: -1,
-   offline: 0,
-   connecting: 1,
-   connected: 2,
-   failure: 3,
- };
-var TorBootstrapUrlbar;
+const { TorConnect, TorConnectTopics, TorConnectState } = ChromeUtils.import(
+  "resource:///modules/TorConnect.jsm"
+);
+const { TorStrings } = ChromeUtils.import(
+  "resource:///modules/TorStrings.jsm"
+);
 
-{
-  const { TorProtocolService } = ChromeUtils.import(
-    "resource:///modules/TorProtocolService.jsm"
-  );
-  const { TorLauncherUtil } = ChromeUtils.import(
-    "resource://torlauncher/modules/tl-util.jsm"
-  );
-  const { TorStrings } = ChromeUtils.import(
-    "resource:///modules/TorStrings.jsm"
-  );
-
-  const kTorProcessReadyTopic = "TorProcessIsReady";
-  const kTorProcessExitedTopic = "TorProcessExited";
-  const kTorProcessDidNotStartTopic = "TorProcessDidNotStart";
-  const kTorBootstrapStatusTopic = "TorBootstrapStatus";
-  const kTorBootstrapErrorTopic = "TorBootstrapError";
-
-  const gActiveTopics = [
-    kTorProcessReadyTopic,
-    kTorProcessExitedTopic,
-    kTorProcessDidNotStartTopic,
-    kTorBootstrapStatusTopic,
-    kTorBootstrapErrorTopic,
-  ];
-
-  TorBootstrapUrlbar = {
-    _connectionStatus: TorConnectionStatus.invalid,
-    get ConnectionStatus() {
-      return this._connectionStatus;
+var TorBootstrapUrlbar = {
+  selectors: Object.freeze({
+    torConnect: {
+      box: "hbox#torconnect-box",
+      label: "label#torconnect-label",
     },
+  }),
 
-    _torConnectBox : null,
-    get TorConnectBox() {
-      if (!this._torConnectBox) {
-        this._torConnectBox =
-          browser.ownerGlobal.document.getElementById("torconnect-box");
-      }
-      return this._torConnectBox;
-    },
+  elements: null,
 
-    _torConnectLabel : null,
-    get TorConnectLabel() {
-      if (!this._torConnectLabel) {
-        this._torConnectLabel =
-          browser.ownerGlobal.document.getElementById("torconnect-label");
+  updateTorConnectBox: function(state) {
+    switch(state)
+    {
+      case TorConnectState.Initial:
+      case TorConnectState.Configuring:
+      case TorConnectState.AutoConfiguring:
+      case TorConnectState.Error:
+      case TorConnectState.FatalError: {
+        this.elements.torConnectBox.removeAttribute("hidden");
+        this.elements.torConnectLabel.textContent = TorStrings.torConnect.offline;
+        this.elements.inputContainer.setAttribute("torconnect", "offline");
+        break;
       }
-      return this._torConnectLabel;
-    },
-
-    _updateConnectionStatus(percentComplete = 0) {
-      if (TorProtocolService.ownsTorDaemon &&
-          !TorLauncherUtil.useLegacyLauncher) {
-        if (TorProtocolService.isNetworkDisabled()) {
-            if (TorProtocolService.torBootstrapErrorOccurred()) {
-              this._connectionStatus = TorConnectionStatus.failure;
-            } else {
-              this._connectionStatus = TorConnectionStatus.offline;
-            }
-        } else if (percentComplete < 100) {
-          this._connectionStatus = TorConnectionStatus.connecting;
-        } else if (percentComplete === 100) {
-          this._connectionStatus = TorConnectionStatus.connected;
-        }
+      case TorConnectState.Bootstrapping: {
+        this.elements.torConnectBox.removeAttribute("hidden");
+        this.elements.torConnectLabel.textContent =
+          TorStrings.torConnect.torConnectingConcise;
+        this.elements.inputContainer.setAttribute("torconnect", "connecting");
+        break;
       }
-      else
-      {
-        this._connectionStatus = TorConnectionStatus.invalid;
+      case TorConnectState.Bootstrapped: {
+        this.elements.torConnectBox.removeAttribute("hidden");
+        this.elements.torConnectLabel.textContent =
+          TorStrings.torConnect.torConnectedConcise;
+        this.elements.inputContainer.setAttribute("torconnect", "connected");
+        // hide torconnect box after 5 seconds
+        setTimeout(() => {
+          this.elements.torConnectBox.setAttribute("hidden", "true");
+        }, 5000);
+        break;
       }
-
-      switch(this._connectionStatus)
-      {
-        case TorConnectionStatus.failure:
-        case TorConnectionStatus.offline:
-          this.TorConnectBox.removeAttribute("hidden");
-          this.TorConnectLabel.textContent = TorStrings.torConnect.offline;
-          gURLBar._inputContainer.setAttribute("torconnect", "offline");
-          break;
-        case TorConnectionStatus.connecting:
-          this.TorConnectLabel.textContent =
-            TorStrings.torConnect.torConnectingConcise;
-          gURLBar._inputContainer.setAttribute("torconnect", "connecting");
-          break;
-        case TorConnectionStatus.connected:
-          this.TorConnectLabel.textContent =
-            TorStrings.torConnect.torConnectedConcise;
-          gURLBar._inputContainer.setAttribute("torconnect", "connected");
-          // hide torconnect box after 5 seconds
-          let self = this;
-          setTimeout(function() {
-            self.TorConnectBox.setAttribute("hidden", "true");
-          }, 5000);
-          break;
+      case TorConnectState.Disabled: {
+        this.elements.torConnectBox.setAttribute("hidden", "true");
+        break;
       }
-    },
+      default:
+        break;
+    }
+  },
 
-    observe(aSubject, aTopic, aData) {
+  observe: function(aSubject, aTopic, aData) {
+    if (aTopic === TorConnectTopics.StateChange) {
       const obj = aSubject?.wrappedJSObject;
+      this.updateTorConnectBox(obj?.state);
+    }
+  },
+
+  init: function() {
+    if (TorConnect.shouldShowTorConnect) {
+      // browser isn't populated until init
+      this.elements = Object.freeze({
+        torConnectBox: browser.ownerGlobal.document.querySelector(this.selectors.torConnect.box),
+        torConnectLabel: browser.ownerGlobal.document.querySelector(this.selectors.torConnect.label),
+        inputContainer: gURLBar._inputContainer,
+      })
+      Services.obs.addObserver(this, TorConnectTopics.StateChange);
+      this.observing = true;
+      this.updateTorConnectBox(TorConnect.state);
+    }
+  },
+
+  uninit: function() {
+    if (this.observing) {
+      Services.obs.removeObserver(this, TorConnectTopics.StateChange);
+    }
+  },
+};
 
-      switch (aTopic) {
-        case kTorProcessReadyTopic:
-        case kTorProcessExitedTopic:
-        case kTorProcessDidNotStartTopic:
-        case kTorBootstrapErrorTopic:
-          this._updateConnectionStatus();
-          break;
-        case kTorBootstrapStatusTopic:
-          let percentComplete = obj.PROGRESS ? obj.PROGRESS : 0;
-          this._updateConnectionStatus(percentComplete);
-          break;
-      }
-    },
-    init() {
-      for (const topic of gActiveTopics) {
-        Services.obs.addObserver(this, topic);
-      }
-    },
-    uninit() {
-      for (const topic of gActiveTopics) {
-        Services.obs.removeObserver(this, topic);
-      }
-    },
-  };
-}
diff --git a/browser/components/torpreferences/content/torPane.js b/browser/components/torpreferences/content/torPane.js
index 01609ddda090..59ecdec6d1d9 100644
--- a/browser/components/torpreferences/content/torPane.js
+++ b/browser/components/torpreferences/content/torPane.js
@@ -6,6 +6,10 @@ const { TorProtocolService } = ChromeUtils.import(
   "resource:///modules/TorProtocolService.jsm"
 );
 
+const { TorConnect } = ChromeUtils.import(
+  "resource:///modules/TorConnect.jsm"
+);
+
 const {
   TorBridgeSource,
   TorBridgeSettings,
@@ -188,14 +192,14 @@ const gTorPane = (function() {
       this._messageBoxButton = prefpane.querySelector(selectors.messageBox.button);
       // wire up connect button
       this._messageBoxButton.addEventListener("click", () => {
-        TorProtocolService.connect();
+        TorConnect.beginBootstrap();
         let win = Services.wm.getMostRecentWindow("navigator:browser");
         // switch to existing about:torconnect tab or create a new one
         win.switchToTabHavingURI("about:torconnect", true);
       });
 
       let populateMessagebox = () => {
-        if (TorProtocolService.shouldShowTorConnect()) {
+        if (TorConnect.shouldShowTorConnect) {
           // set messagebox style and text
           if (TorProtocolService.torBootstrapErrorOccurred()) {
             this._messageBox.className = "error";
diff --git a/browser/components/urlbar/UrlbarInput.jsm b/browser/components/urlbar/UrlbarInput.jsm
index f727c386701c..60b5b9163d67 100644
--- a/browser/components/urlbar/UrlbarInput.jsm
+++ b/browser/components/urlbar/UrlbarInput.jsm
@@ -10,8 +10,8 @@ const { XPCOMUtils } = ChromeUtils.import(
   "resource://gre/modules/XPCOMUtils.jsm"
 );
 
-const { TorProtocolService } = ChromeUtils.import(
-  "resource:///modules/TorProtocolService.jsm"
+const { TorConnect } = ChromeUtils.import(
+  "resource:///modules/TorConnect.jsm"
 );
 
 // in certain scenarios we want user input uris to open in a new tab if they do so from the
@@ -24,7 +24,7 @@ function maybeUpdateOpenLocationForTorConnect(openUILinkWhere, currentURI, desti
         // we are trying to open in same tab
         openUILinkWhere === "current" &&
         // only if user still has not bootstrapped
-        TorProtocolService.shouldShowTorConnect() &&
+        TorConnect.shouldShowTorConnect &&
         // and user is not just navigating to about:torconnect
         destinationURI !== "about:torconnect") {
       return "tab";
diff --git a/browser/modules/TorConnect.jsm b/browser/modules/TorConnect.jsm
index 3125c84558db..5d2b826cfa10 100644
--- a/browser/modules/TorConnect.jsm
+++ b/browser/modules/TorConnect.jsm
@@ -1,6 +1,6 @@
 "use strict";
 
-var EXPORTED_SYMBOLS = ["TorConnect"];
+var EXPORTED_SYMBOLS = ["TorConnect", "TorConnectTopics", "TorConnectState"];
 
 const { Services } = ChromeUtils.import(
     "resource://gre/modules/Services.jsm"
@@ -10,53 +10,476 @@ const { BrowserWindowTracker } = ChromeUtils.import(
     "resource:///modules/BrowserWindowTracker.jsm"
 );
 
-const { TorProtocolService } = ChromeUtils.import(
+const { TorProtocolService, TorProcessStatus } = ChromeUtils.import(
     "resource:///modules/TorProtocolService.jsm"
 );
 
-// TODO: move the bootstrap state management out of each of the individual
-// about:torconnect pages and stick it here
-var TorConnect = (() => {
+const { TorLauncherUtil } = ChromeUtils.import(
+    "resource://torlauncher/modules/tl-util.jsm"
+);
+
+/* Browser observer topis */
+const BrowserTopics = Object.freeze({
+    ProfileAfterChange: "profile-after-change",
+});
+
+/* tor-launcher observer topics */
+const TorTopics = Object.freeze({
+    ProcessIsReady: "TorProcessIsReady",
+    BootstrapStatus: "TorBootstrapStatus",
+    BootstrapError: "TorBootstrapError",
+    ProcessExited: "TorProcessExited",
+    LogHasWarnOrErr: "TorLogHasWarnOrErr",
+});
+
+/* Relevant prefs used by tor-launcher */
+const TorLauncherPrefs = Object.freeze({
+  quickstart: "extensions.torlauncher.quickstart",
+  prompt_at_startup: "extensions.torlauncher.prompt_at_startup",
+});
+
+const TorConnectState = Object.freeze({
+    /* Our initial state */
+    Initial: "Initial",
+    /* In-between initial boot and bootstrapping, users can change tor network settings during this state */
+    Configuring: "Configuring",
+    /* Geo-location and setting bridges/etc */
+    AutoConfiguring: "AutoConfiguring",
+    /* Tor is bootstrapping */
+    Bootstrapping: "Bootstrapping",
+    /* Passthrough state back to Configuring or Fatal */
+    Error: "Error",
+    /* An unrecoverable error */
+    FatalError: "FatalError",
+    /* Final state, after successful bootstrap */
+    Bootstrapped: "Bootstrapped",
+    /* If we are using System tor or the legacy Tor-Launcher */
+    Disabled: "Disabled",
+});
+
+/*
+
+                                               TorConnect State Transitions
+
+                                              ┌──────────────────────┐
+                                              │       Disabled       │
+                                              └──────────────────────┘
+                                                â–²
+                                                │ legacyOrSystemTor()
+                                                │
+                                              ┌──────────────────────┐
+                      ┌────────────────────── │       Initial        │ ───────────────────────────┐
+                      │                       └──────────────────────┘                            │
+                      │                         │                                                 │
+                      │                         │ beginBootstrap()                                │
+                      │                         ▼                                                 │
+┌────────────────┐    │  bootstrapComplete()  ┌────────────────────────────────────────────────┐  │  beginBootstrap()
+│  Bootstrapped  │ ◀──┼────────────────────── │                 Bootstrapping                  │ ◀┼─────────────────┐
+└────────────────┘    │                       └────────────────────────────────────────────────┘  │                 │
+                      │                         │                       ▲                    │    │                 │
+                      │                         │ cancelBootstrap()     │ beginBootstrap()   └────┼─────────────┐   │
+                      │                         ▼                       │                         │             │   │
+                      │   beginConfigure()    ┌────────────────────────────────────────────────┐  │             │   │
+                      └─────────────────────▶ │                                                │  │             │   │
+                                              │                                                │  │             │   │
+                       beginConfigure()       │                                                │  │             │   │
+                 ┌──────────────────────────▶ │                  Configuring                   │  │             │   │
+                 │                            │                                                │  │             │   │
+                 │                            │                                                │  │             │   │
+                 │    ┌─────────────────────▶ │                                                │  │             │   │
+                 │    │                       └────────────────────────────────────────────────┘  │             │   │
+                 │    │                         │                       │                         │             │   │
+                 │    │ cancelAutoconfigure()   │ autoConfigure()       │                    ┌────┼─────────────┼───┘
+                 │    │                         ▼                       │                    │    │             │
+                 │    │                       ┌──────────────────────┐  │                    │    │             │
+                 │    └────────────────────── │   AutoConfiguring    │ ─┼────────────────────┘    │             │
+                 │                            └──────────────────────┘  │                         │             │
+                 │                              │                       │                         │ onError()   │
+                 │                              │ onError()             │ onError()               │             │
+                 │                              ▼                       ▼                         │             │
+                 │                            ┌────────────────────────────────────────────────┐  │             │
+                 └─────────────────────────── │                     Error                      │ ◀┘             │
+                                              └────────────────────────────────────────────────┘                │
+                                                │                                            ▲   onError()      │
+                                                │ onFatalError()                             └──────────────────┘
+                                                â–¼
+                                              ┌──────────────────────┐
+                                              │      FatalError      │
+                                              └──────────────────────┘
+
+*/
+
+
+/* Maps allowed state transitions
+   TorConnectStateTransitions[state] maps to an array of allowed states to transition to
+*/
+const TorConnectStateTransitions =
+    Object.freeze(new Map([
+        [TorConnectState.Initial,
+            [TorConnectState.Disabled,
+             TorConnectState.Bootstrapping,
+             TorConnectState.Configuring,
+             TorConnectState.Error]],
+        [TorConnectState.Configuring,
+            [TorConnectState.AutoConfiguring,
+             TorConnectState.Bootstrapping,
+             TorConnectState.Error]],
+        [TorConnectState.AutoConfiguring,
+            [TorConnectState.Configuring,
+             TorConnectState.Bootstrapping,
+             TorConnectState.Error]],
+        [TorConnectState.Bootstrapping,
+            [TorConnectState.Configuring,
+             TorConnectState.Bootstrapped,
+             TorConnectState.Error]],
+        [TorConnectState.Error,
+            [TorConnectState.Configuring,
+             TorConnectState.FatalError]],
+        // terminal states
+        [TorConnectState.FatalError, []],
+        [TorConnectState.Bootstrapped, []],
+        [TorConnectState.Disabled, []],
+    ]));
+
+/* Topics Notified by the TorConnect module */
+const TorConnectTopics = Object.freeze({
+    StateChange: "torconnect:state-change",
+    BootstrapProgress: "torconnect:bootstrap-progress",
+    BootstrapComplete: "torconnect:bootstrap-complete",
+    BootstrapError: "torconnect:bootstrap-error",
+    FatalError: "torconnect:fatal-error",
+});
+
+const TorConnect = (() => {
     let retval = {
-        init : function() {
-            let topics = [
-                "TorBootstrapStatus",
-            ];
 
-            for(const topic of topics) {
-                Services.obs.addObserver(this, topic);
+        _state: TorConnectState.Initial,
+        _bootstrapProgress: 0,
+        _bootstrapStatus: null,
+        _errorMessage: null,
+        _errorDetails: null,
+        _logHasWarningOrError: false,
+        // init to about:tor as fallback in case setURIsToLoad is somehow never called
+        _urisToLoad: ["about:tor"],
+
+        /* These functions are called after transitioning to a new state */
+        _transitionCallbacks: Object.freeze(new Map([
+            /* Initial is never transitioned to */
+            [TorConnectState.Initial, null],
+            /* Configuring */
+            [TorConnectState.Configuring, (self) => {
+                // TODO move this to the transition function
+                if (this._state === TorConnectState.Bootstrapping) {
+                    TorProtocolService.torStopBootstrap();
+                }
+            }],
+            /* AutoConfiguring */
+            [TorConnectState.AutoConfiguring, (self) => {
+
+            }],
+            /* Bootstrapping */
+            [TorConnectState.Bootstrapping, (self) => {
+                let error = TorProtocolService.connect();
+                if (error) {
+                    self.onError(error.message, error.details);
+                } else {
+                    self._errorMessage = self._errorDetails = null;
+                }
+            }],
+            /* Bootstrapped */
+            [TorConnectState.Bootstrapped, (self) => {
+                // open home page(s) in new tabs
+                const win = BrowserWindowTracker.getTopWindow()
+
+                let location="tab";
+                for (const uri of self._urisToLoad) {
+                    win.openTrustedLinkIn(uri, location);
+                    // open subsequent tabs behind first tab
+                    location = "tabshifted";
+                }
+                Services.obs.notifyObservers(null, TorConnectTopics.BootstrapComplete);
+            }],
+            /* Error */
+            [TorConnectState.Error, (self, errorMessage, errorDetails, fatal) => {
+                self._errorMessage = errorMessage;
+                self._errorDetails = errorDetails;
+
+                Services.obs.notifyObservers({message: errorMessage, details: errorDetails}, TorConnectTopics.BootstrapError);
+                if (fatal) {
+                    self.onFatalError();
+                } else {
+                    self.beginConfigure();
+                }
+            }],
+            /* FatalError */
+            [TorConnectState.FatalError, (self) => {
+                Services.obs.notifyObservers(null, TorConnectTopics.FatalError);
+            }],
+            /* Disabled */
+            [TorConnectState.Disabled, (self) => {
+
+            }],
+        ])),
+
+        _changeState: function(newState, ...args) {
+            const oldState = this._state;
+
+            // ensure this is a valid state transition
+            if (!TorConnectStateTransitions.get(oldState)?.includes(newState)) {
+                throw Error(`TorConnect: Attempted invalid state transition from ${oldState} to ${newState}`);
             }
+
+            console.log(`TorConnect: transitioning state from ${oldState} to ${newState}`);
+
+            // call our transition function and forward any args
+            this._transitionCallbacks.get(newState)(this, ...args);
+
+            // finally, set our new state
+            this._state = newState;
+
+            Services.obs.notifyObservers({state: newState}, TorConnectTopics.StateChange);
+        },
+
+        // init should be called on app-startup in MainProcessingSingleton.jsm
+        init : function() {
+            console.log("TorConnect: Init");
+
+            // delay remaining init until after profile-after-change
+            Services.obs.addObserver(this, BrowserTopics.ProfileAfterChange);
         },
 
         observe: function(subject, topic, data) {
+            console.log(`TorConnect: observed ${topic}`);
+
             switch(topic) {
-            case "TorBootstrapStatus":
-                const obj = subject?.wrappedJSObject;
-                if (obj?.PROGRESS === 100) {
-                    // open home page(s) in new tabs
-                    const win = BrowserWindowTracker.getTopWindow()
-                    const urls = Services.prefs.getStringPref("browser.startup.homepage").split('|');
-
-                    let location="tab";
-                    for(const url of urls) {
-                        win.openTrustedLinkIn(url, location);
-                        // open subsequent tabs behind first tab
-                        location = "tabshifted";
+
+            /* Determine which state to move to from Initial */
+            case BrowserTopics.ProfileAfterChange: {
+                if (TorLauncherUtil.useLegacyLauncher || !TorProtocolService.ownsTorDaemon) {
+                    // Disabled
+                    this.legacyOrSystemTor();
+                } else {
+                    // register the Tor topics we always care about
+                    for (const topicKey in TorTopics) {
+                        const topic = TorTopics[topicKey];
+                        Services.obs.addObserver(this, topic);
+                        console.log(`TorConnect: observing topic '${topic}'`);
                     }
 
-                    Services.obs.notifyObservers(null, "torconnect:bootstrap-complete");
+                    if (TorProtocolService.torProcessStatus == TorProcessStatus.Running) {
+                        if (this.shouldQuickStart) {
+                            // Quickstart
+                            this.beginBootstrap();
+                        } else {
+                            // Configuring
+                            this.beginConfigure();
+                        }
+                    }
                 }
+
+                Services.obs.removeObserver(this, topic);
                 break;
+            }
+            /* Transition out of Initial if Tor daemon wasn't running yet in BrowserTopics.ProfileAfterChange */
+            case TorTopics.ProcessIsReady: {
+                if (this.state === TorConnectState.Initial)
+                {
+                    if (this.shouldQuickStart) {
+                        // Quickstart
+                        this.beginBootstrap();
+                    } else {
+                        // Configuring
+                        this.beginConfigure();
+                    }
+                }
+                break;
+            }
+            /* Updates our bootstrap status */
+            case TorTopics.BootstrapStatus: {
+                if (this._state != TorConnectState.Bootstrapping) {
+                    console.log(`TorConnect: observed ${TorTopics.BootstrapStatus} topic while in state TorConnectState.${this._state}`);
+                    break;
+                }
+
+                const obj = subject?.wrappedJSObject;
+                if (obj) {
+                    this._bootstrapProgress= obj.PROGRESS;
+                    this._bootstrapStatus = TorLauncherUtil.getLocalizedBootstrapStatus(obj, "TAG");
+
+                    console.log(`TorConnect: Bootstrapping ${this._bootstrapProgress}% complete (${this._bootstrapStatus})`);
+                    Services.obs.notifyObservers({
+                        progress: this._bootstrapProgress,
+                        status: this._bootstrapStatus,
+                        hasWarnings: this._logHasWarningOrError
+                    }, TorConnectTopics.BootstrapProgress);
+
+                    if (this._bootstrapProgress === 100) {
+                        this.bootstrapComplete();
+                    }
+                }
+                break;
+            }
+            /* Handle bootstrap error*/
+            case TorTopics.BootstrapError: {
+                const obj = subject?.wrappedJSObject;
+                TorProtocolService.torStopBootstrap();
+                this.onError(obj.message, obj.details);
+                break;
+            }
+            case TorTopics.LogHasWarnOrErr: {
+                this._logHasWarningOrError = true;
+                break;
+            }
             default:
                 // ignore
                 break;
             }
         },
 
-        shouldShowTorConnect : function() {
-            return TorProtocolService.shouldShowTorConnect();
+        /*
+        Various getters
+        */
+
+        get shouldShowTorConnect() {
+                   // TorBrowser must control the daemon
+            return (TorProtocolService.ownsTorDaemon &&
+                   // and we're not using the legacy launcher
+                   !TorLauncherUtil.useLegacyLauncher &&
+                   // legacy checks, TODO: maybe this should be in terms of our own state?
+                   (TorProtocolService.isNetworkDisabled() || !TorProtocolService.isBootstrapDone()));
+        },
+
+        get shouldQuickStart() {
+                   // quickstart must be enabled
+            return Services.prefs.getBoolPref(TorLauncherPrefs.quickstart, false) &&
+                   // and the previous bootstrap attempt must have succeeded
+                   !Services.prefs.getBoolPref(TorLauncherPrefs.prompt_at_startup, true);
+        },
+
+        get state() {
+            return this._state;
+        },
+
+        get bootstrapProgress() {
+            return this._bootstrapProgress;
+        },
+
+        get bootstrapStatus() {
+            return this._bootstrapStatus;
+        },
+
+        get errorMessage() {
+            return this._errorMessage;
+        },
+
+        get errorDetails() {
+            return this._errorDetails;
+        },
+
+        get logHasWarningOrError() {
+            return this._logHasWarningOrError;
+        },
+
+        /*
+        These functions tell TorConnect to transition states
+        */
+
+        legacyOrSystemTor: function() {
+            console.log("TorConnect: legacyOrSystemTor()");
+            this._changeState(TorConnectState.Disabled);
+        },
+
+        beginBootstrap: function() {
+            console.log("TorConnect: beginBootstrap()");
+            this._changeState(TorConnectState.Bootstrapping);
+        },
+
+        beginConfigure: function() {
+            console.log("TorConnect: beginConfigure()");
+            this._changeState(TorConnectState.Configuring);
+        },
+
+        autoConfigure: function() {
+            console.log("TorConnect: autoConfigure()");
+            // TODO: implement
+            throw Error("TorConnect: not implemented");
+        },
+
+        cancelAutoConfigure: function() {
+            console.log("TorConnect: cancelAutoConfigure()");
+            // TODO: implement
+            throw Error("TorConnect: not implemented");
+        },
+
+        cancelBootstrap: function() {
+            console.log("TorConnect: cancelBootstrap()");
+            this._changeState(TorConnectState.Configuring);
+        },
+
+        bootstrapComplete: function() {
+            console.log("TorConnect: bootstrapComplete()");
+            this._changeState(TorConnectState.Bootstrapped);
+        },
+
+        onError: function(message, details) {
+            console.log("TorConnect: onError()");
+            this._changeState(TorConnectState.Error, message, details, false);
+        },
+
+        onFatalError: function() {
+            console.log("TorConnect: onFatalError()");
+            // TODO: implement
+            throw Error("TorConnect: not implemented");
+        },
+
+        /*
+        Further external commands and helper methods
+        */
+        openTorPreferences: function() {
+            const win = BrowserWindowTracker.getTopWindow()
+            win.openTrustedLinkIn("about:preferences#tor", "tab");
+        },
+
+        copyTorLogs: function() {
+            // Copy tor log messages to the system clipboard.
+            const chSvc = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(
+              Ci.nsIClipboardHelper
+            );
+            const countObj = { value: 0 };
+            chSvc.copyString(TorProtocolService.getLog(countObj));
+            const count = countObj.value;
+            return TorLauncherUtil.getFormattedLocalizedString(
+              "copiedNLogMessagesShort",
+              [count],
+              1
+            );
+        },
+
+        // called from browser.js on browser startup, passed in either the user's homepage(s)
+        // or uris passed via command-line
+        setURIsToLoad: function(uriVariant) {
+            // convert the object we get from browser.js
+            let uris = ((v) => {
+                if (v instanceof Ci.nsIArray) {
+                    // Transform the nsIArray of nsISupportsString's into a JS Array of
+                    // JS strings.
+                    return Array.from(
+                      v.enumerate(Ci.nsISupportsString),
+                      supportStr => supportStr.data
+                    );
+                } else if (v instanceof Ci.nsISupportsString) {
+                    return [v.data];
+                } else if (typeof v === "string") {
+                    return v.split("|");
+                }
+                // about:tor as safe fallback
+                return ["about:tor"];
+            })(uriVariant);
+
+            console.log(`TorConnect: will load after bootstrap => ${uris.join(", ")}`);
+            this._urisToLoad = uris;
         },
     };
     retval.init();
     return retval;
-})(); /* TorConnect */
\ No newline at end of file
+})(); /* TorConnect */
diff --git a/browser/modules/TorProtocolService.jsm b/browser/modules/TorProtocolService.jsm
index fc7f2c884aa2..e6c78b9a0eb1 100644
--- a/browser/modules/TorProtocolService.jsm
+++ b/browser/modules/TorProtocolService.jsm
@@ -2,26 +2,59 @@
 
 "use strict";
 
-var EXPORTED_SYMBOLS = ["TorProtocolService"];
+var EXPORTED_SYMBOLS = ["TorProtocolService", "TorProcessStatus"];
 
-const { TorLauncherUtil } = ChromeUtils.import(
-  "resource://torlauncher/modules/tl-util.jsm"
+const { Services } = ChromeUtils.import(
+    "resource://gre/modules/Services.jsm"
 );
 
-var TorProtocolService = {
-  _tlps: Cc["@torproject.org/torlauncher-protocol-service;1"].getService(
-    Ci.nsISupports
-  ).wrappedJSObject,
+// see tl-process.js
+const TorProcessStatus = Object.freeze({
+  Unknown: 0,
+  Starting: 1,
+  Running: 2,
+  Exited: 3,
+});
+
+/* Browser observer topis */
+const BrowserTopics = Object.freeze({
+    ProfileAfterChange: "profile-after-change",
+});
 
-  _tlproc: Cc["@torproject.org/torlauncher-process-service;1"].getService(
-    Ci.nsISupports
-  ).wrappedJSObject,
+var TorProtocolService = {
+  _TorLauncherUtil: function() {
+      let { TorLauncherUtil } = ChromeUtils.import(
+        "resource://torlauncher/modules/tl-util.jsm"
+      );
+      return TorLauncherUtil;
+    }(),
+  _TorLauncherProtocolService: null,
+  _TorProcessService: null,
 
   // maintain a map of tor settings set by Tor Browser so that we don't
   // repeatedly set the same key/values over and over
   // this map contains string keys to primitive or array values
   _settingsCache: new Map(),
 
+  init() {
+    Services.obs.addObserver(this, BrowserTopics.ProfileAfterChange);
+  },
+
+  observe(subject, topic, data) {
+    if (topic === BrowserTopics.ProfileAfterChange) {
+      // we have to delay init'ing this or else the crypto service inits too early without a profile
+      // which breaks the password manager
+      this._TorLauncherProtocolService = Cc["@torproject.org/torlauncher-protocol-service;1"].getService(
+        Ci.nsISupports
+      ).wrappedJSObject;
+      this._TorProcessService = Cc["@torproject.org/torlauncher-process-service;1"].getService(
+        Ci.nsISupports
+      ).wrappedJSObject,
+
+      Services.obs.removeObserver(this, topic);
+    }
+  },
+
   _typeof(aValue) {
     switch (typeof aValue) {
       case "boolean":
@@ -124,7 +157,7 @@ var TorProtocolService = {
       }
 
       let errorObject = {};
-      if (!this._tlps.TorSetConfWithReply(settingsObject, errorObject)) {
+      if (!this._TorLauncherProtocolService.TorSetConfWithReply(settingsObject, errorObject)) {
         throw new Error(errorObject.details);
       }
 
@@ -137,8 +170,8 @@ var TorProtocolService = {
 
   _readSetting(aSetting) {
     this._assertValidSettingKey(aSetting);
-    let reply = this._tlps.TorGetConf(aSetting);
-    if (this._tlps.TorCommandSucceeded(reply)) {
+    let reply = this._TorLauncherProtocolService.TorGetConf(aSetting);
+    if (this._TorLauncherProtocolService.TorCommandSucceeded(reply)) {
       return reply.lineArray;
     }
     throw new Error(reply.lineArray.join("\n"));
@@ -207,22 +240,22 @@ var TorProtocolService = {
 
   getLog(countObj) {
     countObj = countObj || { value: 0 };
-    let torLog = this._tlps.TorGetLog(countObj);
+    let torLog = this._TorLauncherProtocolService.TorGetLog(countObj);
     return torLog;
   },
 
   // true if we launched and control tor, false if using system tor
   get ownsTorDaemon() {
-    return TorLauncherUtil.shouldStartAndOwnTor;
+    return this._TorLauncherUtil.shouldStartAndOwnTor;
   },
 
   // Assumes `ownsTorDaemon` is true
   isNetworkDisabled() {
-    const reply = TorProtocolService._tlps.TorGetConfBool(
+    const reply = TorProtocolService._TorLauncherProtocolService.TorGetConfBool(
       "DisableNetwork",
       true
     );
-    if (TorProtocolService._tlps.TorCommandSucceeded(reply)) {
+    if (TorProtocolService._TorLauncherProtocolService.TorCommandSucceeded(reply)) {
       return reply.retVal;
     }
     return true;
@@ -232,22 +265,22 @@ var TorProtocolService = {
     let settings = {};
     settings.DisableNetwork = false;
     let errorObject = {};
-    if (!this._tlps.TorSetConfWithReply(settings, errorObject)) {
+    if (!this._TorLauncherProtocolService.TorSetConfWithReply(settings, errorObject)) {
       throw new Error(errorObject.details);
     }
   },
 
   sendCommand(cmd) {
-    return this._tlps.TorSendCommand(cmd);
+    return this._TorLauncherProtocolService.TorSendCommand(cmd);
   },
 
   retrieveBootstrapStatus() {
-    return this._tlps.TorRetrieveBootstrapStatus();
+    return this._TorLauncherProtocolService.TorRetrieveBootstrapStatus();
   },
 
   _GetSaveSettingsErrorMessage(aDetails) {
     try {
-      return TorLauncherUtil.getSaveSettingsErrorMessage(aDetails);
+      return this._TorLauncherUtil.getSaveSettingsErrorMessage(aDetails);
     } catch (e) {
       console.log("GetSaveSettingsErrorMessage error", e);
       return "Unexpected Error";
@@ -258,7 +291,7 @@ var TorProtocolService = {
     let result = false;
     const error = {};
     try {
-      result = this._tlps.TorSetConfWithReply(settings, error);
+      result = this._TorLauncherProtocolService.TorSetConfWithReply(settings, error);
     } catch (e) {
       console.log("TorSetConfWithReply error", e);
       error.details = this._GetSaveSettingsErrorMessage(e.message);
@@ -267,23 +300,15 @@ var TorProtocolService = {
   },
 
   isBootstrapDone() {
-    return this._tlproc.mIsBootstrapDone;
+    return this._TorProcessService.mIsBootstrapDone;
   },
 
   clearBootstrapError() {
-    return this._tlproc.TorClearBootstrapError();
-  },
-
-  shouldShowTorConnect() {
-    return (
-      this.ownsTorDaemon &&
-      !TorLauncherUtil.useLegacyLauncher &&
-      (this.isNetworkDisabled() || !this.isBootstrapDone())
-    );
+    return this._TorProcessService.TorClearBootstrapError();
   },
 
   torBootstrapErrorOccurred() {
-    return this._tlproc.TorBootstrapErrorOccurred;
+    return this._TorProcessService.TorBootstrapErrorOccurred;
   },
 
   // Resolves to null if ok, or an error otherwise
@@ -306,7 +331,7 @@ var TorProtocolService = {
   },
 
   torLogHasWarnOrErr() {
-    return this._tlps.TorLogHasWarnOrErr;
+    return this._TorLauncherProtocolService.TorLogHasWarnOrErr;
   },
 
   torStopBootstrap() {
@@ -327,4 +352,12 @@ var TorProtocolService = {
     }
     this.retrieveBootstrapStatus();
   },
+
+  get torProcessStatus() {
+    if (this._TorProcessService) {
+      return this._TorProcessService.TorProcessStatus;
+    }
+    return TorProcessStatus.Unknown;
+  },
 };
+TorProtocolService.init();
\ No newline at end of file
diff --git a/toolkit/components/processsingleton/MainProcessSingleton.jsm b/toolkit/components/processsingleton/MainProcessSingleton.jsm
index db1e2dc8f568..ea9288dccbb3 100644
--- a/toolkit/components/processsingleton/MainProcessSingleton.jsm
+++ b/toolkit/components/processsingleton/MainProcessSingleton.jsm
@@ -24,6 +24,11 @@ MainProcessSingleton.prototype = {
           null
         );
 
+        ChromeUtils.import(
+          "resource:///modules/TorConnect.jsm",
+          null
+        );
+
         // Load this script early so that console.* is initialized
         // before other frame scripts.
         Services.mm.loadFrameScript(
diff --git a/toolkit/modules/RemotePageAccessManager.jsm b/toolkit/modules/RemotePageAccessManager.jsm
index 0927391c2ba7..54230e1175ec 100644
--- a/toolkit/modules/RemotePageAccessManager.jsm
+++ b/toolkit/modules/RemotePageAccessManager.jsm
@@ -181,28 +181,18 @@ let RemotePageAccessManager = {
       RPMRemoveMessageListener: ["*"],
     },
     "about:torconnect": {
-      RPMAddMessageListener: ["*"],
+      RPMAddMessageListener: [
+        "torconnect:state-change",
+      ],
       RPMSendAsyncMessage: [
-        "OpenTorAdvancedPreferences",
-        "TorRetrieveBootstrapStatus",
-        "TorStopBootstrap",
+        "torconnect:open-tor-preferences",
+        "torconnect:begin-bootstrap",
+        "torconnect:cancel-bootstrap",
+        "torconnect:set-quickstart",
       ],
       RPMSendQuery: [
-        "GetDirection",
-        "GetLocalizedBootstrapStatus",
-        "GetTorStrings",
-        "TorBootstrapErrorOccurred",
-        "TorConnect",
-        "TorCopyLog",
-        "TorIsNetworkDisabled",
-        "TorLogHasWarnOrErr",
-      ],
-      RPMGetBoolPref: [
-        "extensions.torlauncher.quickstart",
-        "extensions.torlauncher.prompt_at_startup",
-      ],
-      RPMSetBoolPref: [
-        "extensions.torlauncher.quickstart",
+        "torconnect:get-init-args",
+        "torconnect:copy-tor-logs",
       ],
     },
   },





More information about the tbb-commits mailing list