};

 */

 /**

  * Get the ID/fingerprint of the bridge used in the most recent Tor circuit.

  *

       });

     removeItem.addEventListener("click", () => {

       const bridgeLine = row.bridgeLine;

       const strings = TorSettings.bridges.bridge_strings;

       const index = strings.indexOf(bridgeLine);

       if (index === -1) {

       }

       strings.splice(index, 1);

       });

     });

   },

       if (!this._haveBridges) {

         return;

       }

       });

     });

           return;

         }

           // This should always have the side effect of disabling bridges as

           // well.

         });

       });

         if (!result.type) {

           return null;

         }

         });

       }

     );

         if (!result.bridges?.length) {

           return null;

         }

         });

       }

     );

         if (!loxId && !result.addresses?.length) {

           return null;

         }

       }

     );

   },

         "torPreferences-quickstart-toggle"

       );

       this._enableQuickstartCheckbox.addEventListener("command", () => {

       });

       this._enableQuickstartCheckbox.checked = TorSettings.quickstart.enabled;

       Services.obs.addObserver(this, TorSettingsTopics.SettingsChanged);

     const port = this._proxyPortTextbox.value;

     const username = this._proxyUsernameTextbox.value;

     const password = this._proxyPasswordTextbox.value;

     switch (type) {

       case TorProxyType.Invalid:

         break;

       case TorProxyType.Socks4:

         break;

       case TorProxyType.Socks5:

         break;

       case TorProxyType.HTTPS:

         break;

     }

       ? this._allowedPortsTextbox.value

       : "";

     if (portListString) {

     } else {

     }

     // FIXME: What if this fails? Should we prevent the dialog to close and show

     // an error?

   },

 };

         set(value) {

             getTorSettings()?.let {

                 it.quickstart = value

             }

         }

             getTorSettings()?.let {

                 if (!value || it.bridgesSource != BridgeSource.Invalid) {

                     it.bridgesEnabled = value

                 }

             }

         }

                     }

                     it.bridgesBuiltinType = bbt

                 }

             }

         }

                 val  userProvidedLines: Array<String> = value?.split("\n")?.filter { it.length > 4 }?.toTypedArray() ?: arrayOf<String>()

                 it.bridgesSource = BridgeSource.UserProvided

                 it.bridgeBridgeStrings = userProvidedLines

             }

         }

   // Events we emit

   private static final String EVENT_SETTINGS_GET = "GeckoView:Tor:SettingsGet";

   private static final String EVENT_SETTINGS_SET = "GeckoView:Tor:SettingsSet";

   private static final String EVENT_BOOTSTRAP_BEGIN = "GeckoView:Tor:BootstrapBegin";

   private static final String EVENT_BOOTSTRAP_BEGIN_AUTO = "GeckoView:Tor:BootstrapBeginAuto";

   private static final String EVENT_BOOTSTRAP_CANCEL = "GeckoView:Tor:BootstrapCancel";

     protected void onPostExecute(TorSettings torSettings) {

       mSettings = torSettings;

       if (TorLegacyAndroidSettings.unmigrated()) {

         TorLegacyAndroidSettings.setMigrated();

       }

     }

     return mSettings;

   }

     mSettings = settings;

         .then(

             new GeckoResult.OnValueListener<Void, Void>() {

               public GeckoResult<Void> onValue(Void v) {

   }

   private @NonNull GeckoResult<Void> emitSetSettings(

     bundle.putBundle("settings", settings.asGeckoBundle());

     return EventDispatcher.getInstance().queryVoid(EVENT_SETTINGS_SET, bundle);

   }

   public @NonNull GeckoResult<Void> beginBootstrap() {

     return EventDispatcher.getInstance().queryVoid(EVENT_BOOTSTRAP_BEGIN);

   }

         // If there are multiple home pages, just load the first one.

         return Promise.resolve(TorConnect.fixupURIs(lazy.HomePage.get())[0]);

       case "torconnect:set-quickstart":

         break;

       case "torconnect:open-tor-preferences":

         this.browsingContext.top.embedderElement.ownerGlobal.openPreferences(

   settingsGet: "GeckoView:Tor:SettingsGet",

   // The data is passed directly to TorSettings.

   settingsSet: "GeckoView:Tor:SettingsSet",

   bootstrapBegin: "GeckoView:Tor:BootstrapBegin",

   // Optionally takes a countryCode, as data.countryCode.

   bootstrapBeginAuto: "GeckoView:Tor:BootstrapBeginAuto",

           callback?.onSuccess(lazy.TorSettings.getSettings());

           return;

         case ListenedEvents.settingsSet:

           break;

         case ListenedEvents.bootstrapBegin:

           lazy.TorConnect.beginBootstrapping();

    * not contradict each other.

    */

   #cleanupSettings() {

     try {

       if (this.bridges.source === TorBridgeSource.Invalid) {

         this.bridges.enabled = false;

         this.firewall.allowed_ports = [];

       }

     } finally {

     }

   }

    * changes you make with a `try` block and call thawNotifications in the

    * `finally` block.

    */

     this.#freezeNotificationsCount++;

   }

   /**

    * Note, if some other method has also frozen the notifications, this will

    * only release them once it has also called this method.

    */

     this.#freezeNotificationsCount--;

     this.#tryNotification();

   }

                 this.#checkIfInitialized();

               }

               const prevVal = this.#settings[groupname][name];

               try {

                 if (transform) {

                   val = transform(val, addError);

               } catch (e) {

                 addError(e.message);

               } finally {

               }

             },

       });

       Services.prefs.getBoolPref(TorSettingsPrefs.enabled, false)

     ) {

       // Do not want notifications for initially loaded prefs.

       try {

         this.#allowUninitialized = true;

         this.#loadFromPrefs();

       } finally {

         this.#allowUninitialized = false;

         this.#notificationQueue.clear();

       }

     }

           // source. But we do pass on the changes to TorProvider.

           // FIXME: This can compete with TorConnect to reach TorProvider.

           // tor-browser#42316

         }

         break;

     }

   /**

    * Save our settings to prefs.

    */

     lazy.logger.debug("saveToPrefs()");

     this.#checkIfInitialized();

     // all tor settings now stored in prefs :)

     Services.prefs.setBoolPref(TorSettingsPrefs.enabled, true);

   }

   /**

    * Even though this introduces a circular depdency, it makes the API nicer for

    * frontend consumers.

    */

     this.#checkIfInitialized();

     const provider = await lazy.TorProviderBuilder.build();

     await provider.writeSettings();

   }

   /**

    *

    *

    */

     this.#checkIfInitialized();

     const backup = this.getSettings();

     this.#settingErrors = [];

     // Hold off on lots of notifications until all settings are changed.

     try {

         this.quickstart.enabled = !!settings.quickstart.enabled;

       }

       if ("bridges" in settings) {

         }

         }

       }

       if ("proxy" in settings) {

         this.proxy.enabled = !!settings.proxy.enabled;

         if (this.proxy.enabled) {

           this.proxy.type = settings.proxy.type;

       }

       if ("firewall" in settings) {

         this.firewall.enabled = !!settings.firewall.enabled;

         if (this.firewall.enabled) {

           this.firewall.allowed_ports = settings.firewall.allowed_ports;

       if (this.#settingErrors.length) {

         throw Error(this.#settingErrors.join("; "));

       }

     } catch (ex) {

       // Restore the old settings without any new notifications generated from

       // the above code.

       this.#settings = backup;

       this.#notificationQueue.clear();

       for (const notification of backupNotifications) {

         this.#notificationQueue.add(notification);

       }

     } finally {

       // Stop collecting errors.

       this.#settingErrors = null;

     }

     lazy.logger.debug("setSettings result", this.#settings);

   }

   /**

     // After checks are complete, we commit them.

     this.#temporaryBridgeSettings = bridgeSettings;

   }

   /**

       lazy.logger.warn("No temporary bridges to save");

       return;

     }

     this.#temporaryBridgeSettings = null;

   }

   /**

       return;

     }

     this.#temporaryBridgeSettings = null;

   }

 }