private showNotification(request: RedirectRequest): MaybePromise<void> {
    this.debugLog.log("going to show a redirection notification");
    const browser = this.requestService.getBrowser(request);
    if (browser === null) {
      this.debugLog.log("showNotification: browser n/a");
      return MaybePromise.reject<void>(undefined);
    }

    const window = browser.ownerGlobal;

    const p = tryMultipleTimes(() => {
      const windowModule = this.windowModuleMap.get(window);
      if (!windowModule) {
        this.debugLog.log("showNotification: window module n/a");
        return false;
      }

      // Parameter "replaceIfPossible" is set to true,
      // because the "origin" of
      // redirections going through "nsIChannelEventSink" is just an
      // intermediate URI of a redirection chain, not a real site.
      return windowModule.r21n.showNotification(
          browser,
          {
            origin: request.originURI,
            target: request.destURIWithRef,
          },
          0,
          true,
      );
    });
    return MaybePromise.resolve(p);
  }

 protected startupSelf() {
   this.addRulePopup = this.windowService.$id(
       this.window,
       addRuleMenuName,
   ) as any;
   return MaybePromise.resolve(undefined);
 }

 public startupSelf() {
   const manifestUrl = this.chromeFileService.
       getChromeUrl("bootstrap-data/manifest.json");
   const p = this.chromeFileService.parseJSON(manifestUrl).then((data) => {
     this.data = data;
   });
   return MaybePromise.resolve(p);
 }

  protected startupSelf() {
    if (this.cachedSettings.get("browserSettings.disableNetworkPrediction")) {
      this.networkPrivacyApi.networkPredictionEnabled.set({value: false}).catch(
          this.log.onError("set networkPredictionEnabled false"),
      );
    } else {
      this.networkPrivacyApi.networkPredictionEnabled.clear({}).catch(
          this.log.onError("clear networkPredictionEnabled setting"),
      );
    }

    return MaybePromise.resolve(undefined);
  }

  protected startupSelf() {
    // create a scope variable
    (this.window as any).rpcontinued = {
      classicmenu: this.classicmenu,
      menu: this.menu,
      overlay: this.overlay,
    };

    this.xulTreeLists_ = this.xulService.getXulTreeLists(this.overlay);

    // add all XUL elements
    this.xulService.addTreeElementsToWindow(
        this.window,
        this.xulTreeLists.mainTree,
    );

    return MaybePromise.resolve(undefined);
  }

    it("it's synchronous when all() is called with empty list", function() {
      // setup
      let thenFnCalled = false;
      let catchFnCalled = false;

      // exercise
      const mp = MaybePromise.all([]);
      mp.then(() => {
        thenFnCalled = true;
        return;
      }, () => {
        catchFnCalled = true;
      });

      // verify
      assert.strictEqual(thenFnCalled, true);
      assert.strictEqual(catchFnCalled, false);
    });

function genMaybePromise({isFulfilled, isPromiseWrapper, value = {}, usingAllFn = false}): MaybePromise<any> {
  const mpArg = isPromiseWrapper ? genPromise({isFulfilled, value}) : (value as any);
  const mp = isPromiseWrapper || isFulfilled ?
      MaybePromise.resolve(mpArg) : MaybePromise.reject(mpArg);
  return usingAllFn ? MaybePromise.all([mp]) : mp;
}

 protected startupSelf() {
   return MaybePromise.resolve(this.startupSelfAsync());
 }

 protected startupSelf() {
   this.addToolbarButtonToAustralis();
   return MaybePromise.resolve(undefined);
 }

  protected startupSelf() {
    const promises: IInfoPromises = {};

    const checkPromise = (aPropName: keyof IInfoPromises) => {
      (promises[aPropName] as Promise<any>).catch((e) => {
        this.log.error(`Error initializing "${aPropName}":`, e);
      });
    };

    const infos: IOptionalInfos = {};

    // -------------------------------------------------------------------------
    // RP version info
    // -------------------------------------------------------------------------

    promises.lastRPVersion = Promise.resolve(
        this.cachedSettings.get("lastVersion") as IInfos["lastRPVersion"],
    );
    checkPromise("lastRPVersion");

    promises.isRPUpgrade =
        promises.lastRPVersion.
        then((lastRPVersion) => {
          // Compare with version 1.0.0a8 since that version introduced
          // the "welcome window".
          infos.isRPUpgrade = !!lastRPVersion &&
              this.versionComparator.compare(lastRPVersion, "1.0.0a8") <= 0;
          return infos.isRPUpgrade;
        });
    checkPromise("isRPUpgrade");

    promises.curRPVersion =
        this.managementApi.getSelf().
        then((addon) => {
          infos.curRPVersion = addon.version;
          return infos.curRPVersion;
        });
    checkPromise("curRPVersion");

    // -------------------------------------------------------------------------
    // app version info
    // -------------------------------------------------------------------------

    promises.lastAppVersion = Promise.resolve(
        this.cachedSettings.get("lastAppVersion") as IInfos["lastAppVersion"],
    );
    checkPromise("lastAppVersion");

    promises.curAppVersion =
        this.runtimeApi.getBrowserInfo().
        then(({version}) => {
          infos.curAppVersion = version;
          return version;
        });
    checkPromise("curAppVersion");

    // -------------------------------------------------------------------------
    // store last*Version
    // -------------------------------------------------------------------------

    const p = Promise.all(
        objectValues(promises as IObject<Promise<any>>),
    ).then(() => {
      this.infos = infos as IInfos;
      const {curAppVersion, curRPVersion} = infos;
      return this.cachedSettings.set({
        lastAppVersion: curAppVersion,
        lastVersion: curRPVersion,
      });
    }).catch((e) => {
      this.log.error("Failed to initialize VersionInfoService", e);
    }) as Promise<void>;

    return MaybePromise.resolve(p);
  }