tor-browser

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

GeckoViewModule.sys.mjs (4141B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 import { GeckoViewUtils } from "resource://gre/modules/GeckoViewUtils.sys.mjs";
      6 
      7 const { debug, warn } = GeckoViewUtils.initLogging("Module");
      8 
      9 export class GeckoViewModule {
     10  static initLogging(aModuleName) {
     11    const tag = aModuleName.replace("GeckoView", "");
     12    return GeckoViewUtils.initLogging(tag);
     13  }
     14 
     15  constructor(aModuleInfo) {
     16    this._info = aModuleInfo;
     17 
     18    this._isContentLoaded = false;
     19    this._eventProxy = new EventProxy(this, this.eventDispatcher);
     20 
     21    this.onInitBrowser();
     22  }
     23 
     24  get name() {
     25    return this._info.name;
     26  }
     27 
     28  get enabled() {
     29    return this._info.enabled;
     30  }
     31 
     32  get window() {
     33    return this.moduleManager.window;
     34  }
     35 
     36  getActor(aActorName) {
     37    return this.moduleManager.getActor(aActorName);
     38  }
     39 
     40  get browser() {
     41    return this.moduleManager.browser;
     42  }
     43 
     44  get messageManager() {
     45    return this.moduleManager.messageManager;
     46  }
     47 
     48  get eventDispatcher() {
     49    return this.moduleManager.eventDispatcher;
     50  }
     51 
     52  get settings() {
     53    return this.moduleManager.settings;
     54  }
     55 
     56  get moduleManager() {
     57    return this._info.manager;
     58  }
     59 
     60  // Override to initialize the browser before it is bound to the window.
     61  onInitBrowser() {}
     62 
     63  // Override to cleanup when the browser is destroyed.
     64  onDestroyBrowser() {}
     65 
     66  // Override to initialize module.
     67  onInit() {}
     68 
     69  // Override to cleanup when the window is closed
     70  onDestroy() {}
     71 
     72  // Override to detect settings change. Access settings via this.settings.
     73  onSettingsUpdate() {}
     74 
     75  // Override to enable module after setting a Java delegate.
     76  onEnable() {}
     77 
     78  // Override to disable module after clearing the Java delegate.
     79  onDisable() {}
     80 
     81  // Override to perform actions when content module has started loading;
     82  // by default, pause events so events that depend on content modules can work.
     83  onLoadContentModule() {
     84    this._eventProxy.enableQueuing(true);
     85  }
     86 
     87  // Override to perform actions when content module has finished loading;
     88  // by default, un-pause events and flush queued events.
     89  onContentModuleLoaded() {
     90    this._eventProxy.enableQueuing(false);
     91    this._eventProxy.dispatchQueuedEvents();
     92  }
     93 
     94  registerListener(aEventList) {
     95    this._eventProxy.registerListener(aEventList);
     96  }
     97 
     98  unregisterListener(aEventList) {
     99    this._eventProxy.unregisterListener(aEventList);
    100  }
    101 }
    102 
    103 class EventProxy {
    104  constructor(aListener, aEventDispatcher) {
    105    this.listener = aListener;
    106    this.eventDispatcher = aEventDispatcher;
    107    this._eventQueue = [];
    108    this._registeredEvents = [];
    109    this._enableQueuing = false;
    110  }
    111 
    112  registerListener(aEventList) {
    113    debug`registerListener ${aEventList}`;
    114    this.eventDispatcher.registerListener(this, aEventList);
    115    this._registeredEvents = this._registeredEvents.concat(aEventList);
    116  }
    117 
    118  unregisterListener(aEventList) {
    119    debug`unregisterListener`;
    120    if (this._registeredEvents.length === 0) {
    121      return;
    122    }
    123 
    124    if (!aEventList) {
    125      this.eventDispatcher.unregisterListener(this, this._registeredEvents);
    126      this._registeredEvents = [];
    127    } else {
    128      this.eventDispatcher.unregisterListener(this, aEventList);
    129      this._registeredEvents = this._registeredEvents.filter(
    130        e => !aEventList.includes(e)
    131      );
    132    }
    133  }
    134 
    135  onEvent(aEvent, aData) {
    136    if (this._enableQueuing) {
    137      debug`queue ${aEvent}, data=${aData}`;
    138      this._eventQueue.unshift(arguments);
    139    } else {
    140      this._dispatch(...arguments);
    141    }
    142  }
    143 
    144  enableQueuing(aEnable) {
    145    debug`enableQueuing ${aEnable}`;
    146    this._enableQueuing = aEnable;
    147  }
    148 
    149  _dispatch(aEvent, aData) {
    150    debug`dispatch ${aEvent}, data=${aData}`;
    151    if (this.listener.onEvent) {
    152      this.listener.onEvent(...arguments);
    153    } else {
    154      this.listener(...arguments);
    155    }
    156  }
    157 
    158  dispatchQueuedEvents() {
    159    debug`dispatchQueued`;
    160    while (this._eventQueue.length) {
    161      const args = this._eventQueue.pop();
    162      this._dispatch(...args);
    163    }
    164  }
    165 }