Quelle  AboutNewTabParent.sys.mjs  Sprache: unbekannt

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
  AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
  ASRouter: "resource:///modules/asrouter/ASRouter.sys.mjs",
});

// A mapping of loaded new tab pages, where the mapping is:
//   browser -> { actor, browser, browsingContext, portID, url, loaded }
let gLoadedTabs = new Map();

export class AboutNewTabParent extends JSWindowActorParent {
  static get loadedTabs() {
    return gLoadedTabs;
  }

  getTabDetails() {
    let browser = this.browsingContext.top.embedderElement;
    return browser ? gLoadedTabs.get(browser) : null;
  }

  handleEvent(event) {
    if (event.type == "SwapDocShells") {
      let oldBrowser = this.browsingContext.top.embedderElement;
      let newBrowser = event.detail;

      let tabDetails = gLoadedTabs.get(oldBrowser);
      if (tabDetails) {
        tabDetails.browser = newBrowser;
        gLoadedTabs.delete(oldBrowser);
        gLoadedTabs.set(newBrowser, tabDetails);

        oldBrowser.removeEventListener("SwapDocShells", this);
        newBrowser.addEventListener("SwapDocShells", this);
      }
    }
  }

  /**
   * When newtab is disabled, we show an empty page. For consistency with
   * about:blank and historical behavior, avoid a persistent SH entry for
   * it if it's the initial document.
   */
  makeTransientIfDisabledAndInitial() {
    if (Services.prefs.getBoolPref("browser.newtabpage.enabled", true)) {
      return;
    }

    const sh = this.browsingContext.sessionHistory;
    if (!sh || sh.count > 1) {
      return;
    }

    const entry = sh.getEntryAtIndex(0);
    if (entry.URI.spec === "about:newtab") {
      entry.setTransient();
    }
  }

  async receiveMessage(message) {
    switch (message.name) {
      case "AboutNewTabVisible":
        {
          const browsingContext = this.browsingContext;
          // for all of the await's within this switch
          // check if the Parent actor is still active
          // helps avoid test failures
          await lazy.ASRouter.waitForInitialized;
          if (!browsingContext.isDiscarded) {
            await lazy.ASRouter.sendTriggerMessage({
              browser: browsingContext.top.embedderElement,
              // triggerId and triggerContext
              id: "defaultBrowserCheck",
              context: { source: "newtab" },
            });
          }
          if (!browsingContext.isDiscarded) {
            await lazy.ASRouter.sendTriggerMessage({
              browser: browsingContext.top.embedderElement,
              id: "newtabMessageCheck",
            });
          }
        }
        break;
      case "Init": {
        let browsingContext = this.browsingContext;
        let browser = browsingContext.top.embedderElement;
        if (!browser) {
          return null;
        }

        let tabDetails = {
          actor: this,
          browser,
          browsingContext,
          portID: message.data.portID,
          url: message.data.url,
        };
        gLoadedTabs.set(browser, tabDetails);

        browser.addEventListener("SwapDocShells", this);
        browser.addEventListener("EndSwapDocShells", this);

        this.notifyActivityStreamChannel("onNewTabInit", message, tabDetails);
        break;
      }

      case "Load": {
        this.notifyActivityStreamChannel("onNewTabLoad", message);
        this.makeTransientIfDisabledAndInitial();
        break;
      }

      case "Unload": {
        let tabDetails = this.getTabDetails();
        if (!tabDetails) {
          // When closing a tab, the embedderElement can already be disconnected, so
          // as a backup, look up the tab details by browsing context.
          tabDetails = this.getByBrowsingContext(this.browsingContext);
        }

        if (!tabDetails) {
          return null;
        }

        tabDetails.browser.removeEventListener("EndSwapDocShells", this);

        gLoadedTabs.delete(tabDetails.browser);

        this.notifyActivityStreamChannel("onNewTabUnload", message, tabDetails);
        break;
      }

      case "ActivityStream:ContentToMain": {
        this.notifyActivityStreamChannel("onMessage", message);
        break;
      }

      case "AssignRenderer": {
        // This could have been called by the remote renderer host document
        // early during startup, before we've had a chance to have
        // ActivityStream initialize and (most importantly here) register the
        // MozNewTabRemoteRendererProtocol parent actor. So if that's the case,
        // we wait for that startup to complete before continuing.
        if (!lazy.AboutNewTab.activityStream) {
          await lazy.AboutNewTab.activityStreamPromise;
        }
        const rendererActor = this.browsingContext.currentWindowGlobal.getActor(
          "MozNewTabRemoteRendererProtocol"
        );
        return rendererActor.assignRenderer();
      }
    }
    return null;
  }

  notifyActivityStreamChannel(name, message, tabDetails) {
    if (!tabDetails) {
      tabDetails = this.getTabDetails();
      if (!tabDetails) {
        return;
      }
    }

    let channel = this.getChannel();
    if (!channel) {
      // We're not yet ready to deal with these messages. We'll queue
      // them for now, and then dispatch them once the channel has finished
      // being set up.
      AboutNewTabParent.#queuedMessages.push({
        actor: this,
        name,
        message,
        tabDetails,
      });
      return;
    }

    let messageToSend = {
      target: this,
      data: message.data || {},
    };

    channel[name](messageToSend, tabDetails);
  }

  getByBrowsingContext(expectedBrowsingContext) {
    for (let tabDetails of AboutNewTabParent.loadedTabs.values()) {
      if (tabDetails.browsingContext === expectedBrowsingContext) {
        return tabDetails;
      }
    }

    return null;
  }

  getChannel() {
    return lazy.AboutNewTab.activityStream?.store?.getMessageChannel();
  }

  // Queued messages sent from the content process. These are only queued
  // if an AboutNewTabParent receives them before the
  // ActivityStreamMessageChannel exists.
  static #queuedMessages = [];

  /**
   * If there were any messages sent from content before the
   * ActivityStreamMessageChannel was set up, dispatch them now.
   */
  static flushQueuedMessagesFromContent() {
    for (let messageData of AboutNewTabParent.#queuedMessages) {
      let { actor, name, message, tabDetails } = messageData;
      actor.notifyActivityStreamChannel(name, message, tabDetails);
    }
    AboutNewTabParent.#queuedMessages = [];
  }
}