firefox/browser/extensions/newtab/lib/ActivityStreamMessageChannel.sys.mjs

/* 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, {
  AboutHomeStartupCache: "resource:///modules/AboutHomeStartupCache.sys.mjs",
  AboutNewTabParent: "resource:///actors/AboutNewTabParent.sys.mjs",
});

import {
  actionCreators as ac,
  actionTypes as at,
  actionUtils as au,
} from "resource://newtab/common/Actions.mjs";

const ABOUT_NEW_TAB_URL = "about:newtab";

export const DEFAULT_OPTIONS = {
  dispatch(action) {
    throw new Error(
      `\nMessageChannel: Received action ${action.type}, but no dispatcher was defined.\n`
    );
  },
  pageURL: ABOUT_NEW_TAB_URL,
  outgoingMessageName: "ActivityStream:MainToContent",
  incomingMessageName: "ActivityStream:ContentToMain",
};

export class ActivityStreamMessageChannel {
  /**
   * ActivityStreamMessageChannel - This module connects a Redux store to the new tab page actor.
   *                  You should use the BroadcastToContent, AlsoToOneContent, and AlsoToMain action creators
   *                  in common/Actions.sys.mjs to help you create actions that will be automatically routed
   *                  to the correct location.
   *
   * @param  {object} options
   * @param  {function} options.dispatch The dispatch method from a Redux store
   * @param  {string} options.pageURL The URL to which the channel is attached, such as about:newtab.
   * @param  {string} options.outgoingMessageName The name of the message sent to child processes
   * @param  {string} options.incomingMessageName The name of the message received from child processes
   * @return {ActivityStreamMessageChannel}
   */
  constructor(options = {}) {
    Object.assign(this, DEFAULT_OPTIONS, options);

    this.middleware = this.middleware.bind(this);
    this.onMessage = this.onMessage.bind(this);
    this.onNewTabLoad = this.onNewTabLoad.bind(this);
    this.onNewTabUnload = this.onNewTabUnload.bind(this);
    this.onNewTabInit = this.onNewTabInit.bind(this);
  }

  /**
   * Get an iterator over the loaded tab objects.
   */
  get loadedTabs() {
    // In the test, AboutNewTabParent is not defined.
    return lazy.AboutNewTabParent?.loadedTabs || new Map();
  }

  /**
   * middleware - Redux middleware that looks for AlsoToOneContent and BroadcastToContent type
   *              actions, and sends them out.
   *
   * @param  {object} store A redux store
   * @return {function} Redux middleware
   */
  middleware() {
    return next => action => {
      const skipMain = action.meta && action.meta.skipMain;
      if (au.isSendToOneContent(action)) {
        this.send(action);
      } else if (au.isBroadcastToContent(action)) {
        this.broadcast(action);
      } else if (au.isSendToPreloaded(action)) {
        this.sendToPreloaded(action);
      }

      if (!skipMain) {
        next(action);
      }
    };
  }

  /**
   * onActionFromContent - Handler for actions from a content processes
   *
   * @param  {object} action  A Redux action
   * @param  {string} targetId The portID of the port that sent the message
   */
  onActionFromContent(action, targetId) {
    this.dispatch(ac.AlsoToMain(action, this.validatePortID(targetId)));
  }

  /**
   * broadcast - Sends an action to all ports
   *
   * @param  {object} action A Redux action
   */
  broadcast(action) {
    // We're trying to update all tabs, so signal the AboutHomeStartupCache
    // that its likely time to refresh the cache.
    lazy.AboutHomeStartupCache.onPreloadedNewTabMessage();

    for (let { actor } of this.loadedTabs.values()) {
      try {
        actor.sendAsyncMessage(this.outgoingMessageName, action);
      } catch (e) {
        // The target page is closed/closing by the user or test, so just ignore.
      }
    }
  }

  /**
   * send - Sends an action to a specific port
   *
   * @param  {obj} action A redux action; it should contain a portID in the meta.toTarget property
   */
  send(action) {
    const targetId = action.meta && action.meta.toTarget;
    const target = this.getTargetById(targetId);
    try {
      target.sendAsyncMessage(this.outgoingMessageName, action);
    } catch (e) {
      // The target page is closed/closing by the user or test, so just ignore.
    }
  }

  /**
   * A valid portID is a combination of process id and a port number.
   * It is generated in AboutNewTabChild.sys.mjs.
   */
  validatePortID(id) {
    if (typeof id !== "string" || !id.includes(":")) {
      console.error("Invalid portID");
    }

    return id;
  }

  /**
   * getTargetById - Retrieve the message target by portID, if it exists
   *
   * @param  {string} id A portID
   * @return {obj|null} The message target, if it exists.
   */
  getTargetById(id) {
    this.validatePortID(id);

    for (let { portID, actor } of this.loadedTabs.values()) {
      if (portID === id) {
        return actor;
      }
    }
    return null;
  }

  /**
   * sendToPreloaded - Sends an action to each preloaded browser, if any
   *
   * @param  {obj} action A redux action
   */
  sendToPreloaded(action) {
    // We're trying to update the preloaded about:newtab, so signal
    // the AboutHomeStartupCache that its likely time to refresh
    // the cache.
    lazy.AboutHomeStartupCache.onPreloadedNewTabMessage();

    const preloadedActors = this.getPreloadedActors();
    if (preloadedActors && action.data) {
      for (let preloadedActor of preloadedActors) {
        try {
          preloadedActor.sendAsyncMessage(this.outgoingMessageName, action);
        } catch (e) {
          // The preloaded page is no longer available, so just ignore.
        }
      }
    }
  }

  /**
   * getPreloadedActors - Retrieve the preloaded actors
   *
   * @return {Array|null} An array of actors belonging to the preloaded browsers, or null
   *                      if there aren't any preloaded browsers
   */
  getPreloadedActors() {
    let preloadedActors = [];
    for (let { actor, browser } of this.loadedTabs.values()) {
      if (this.isPreloadedBrowser(browser)) {
        preloadedActors.push(actor);
      }
    }
    return preloadedActors.length ? preloadedActors : null;
  }

  /**
   * isPreloadedBrowser - Returns true if the passed browser has been preloaded
   *                      for faster rendering of new tabs.
   *
   * @param {<browser>} A <browser> to check.
   * @return {bool} True if the browser is preloaded.
   *                      if there aren't any preloaded browsers
   */
  isPreloadedBrowser(browser) {
    return browser.getAttribute("preloadedState") === "preloaded";
  }

  simulateMessagesForExistingTabs() {
    // Some pages might have already loaded, so we won't get the usual message
    for (const loadedTab of this.loadedTabs.values()) {
      let simulatedDetails = {
        actor: loadedTab.actor,
        browser: loadedTab.browser,
        browsingContext: loadedTab.browsingContext,
        portID: loadedTab.portID,
        url: loadedTab.url,
        simulated: true,
      };

      this.onActionFromContent(
        {
          type: at.NEW_TAB_INIT,
          data: simulatedDetails,
        },
        loadedTab.portID
      );

      if (loadedTab.loaded) {
        this.tabLoaded(simulatedDetails);
      }
    }

    // It's possible that those existing tabs had sent some messages up
    // to us before the feeds / ActivityStreamMessageChannel was ready.
    //
    // AboutNewTabParent takes care of queueing those for us, so
    // now that we're ready, we can flush these queued messages.
    lazy.AboutNewTabParent.flushQueuedMessagesFromContent();
  }

  /**
   * onNewTabInit - Handler for special RemotePage:Init message fired
   * on initialization.
   *
   * @param  {obj} msg The messsage from a page that was just initialized
   * @param  {obj} tabDetails details about a loaded tab
   *
   * tabDetails contains:
   *   actor, browser, browsingContext, portID, url
   */
  onNewTabInit(msg, tabDetails) {
    this.onActionFromContent(
      {
        type: at.NEW_TAB_INIT,
        data: tabDetails,
      },
      msg.data.portID
    );
  }

  /**
   * onNewTabLoad - Handler for special RemotePage:Load message fired on page load.
   *
   * @param  {obj} msg The messsage from a page that was just loaded
   * @param  {obj} tabDetails details about a loaded tab, similar to onNewTabInit
   */
  onNewTabLoad(msg, tabDetails) {
    this.tabLoaded(tabDetails);
  }

  tabLoaded(tabDetails) {
    tabDetails.loaded = true;

    let { browser } = tabDetails;
    if (
      this.isPreloadedBrowser(browser) &&
      browser.ownerGlobal.windowState !== browser.ownerGlobal.STATE_MINIMIZED &&
      !browser.ownerGlobal.isFullyOccluded
    ) {
      // As a perceived performance optimization, if this loaded Activity Stream
      // happens to be a preloaded browser in a window that is not minimized or
      // occluded, have it render its layers to the compositor now to increase
      // the odds that by the time we switch to the tab, the layers are already
      // ready to present to the user.
      browser.renderLayers = true;
    }

    this.onActionFromContent({ type: at.NEW_TAB_LOAD }, tabDetails.portID);
  }

  /**
   * onNewTabUnloadLoad - Handler for special RemotePage:Unload message fired
   * on page unload.
   *
   * @param  {obj} msg The messsage from a page that was just unloaded
   * @param  {obj} tabDetails details about a loaded tab, similar to onNewTabInit
   */
  onNewTabUnload(msg, tabDetails) {
    this.onActionFromContent({ type: at.NEW_TAB_UNLOAD }, tabDetails.portID);
  }

  /**
   * onMessage - Handles custom messages from content. It expects all messages to
   *             be formatted as Redux actions, and dispatches them to this.store
   *
   * @param  {obj} msg A custom message from content
   * @param  {obj} msg.action A Redux action (e.g. {type: "HELLO_WORLD"})
   * @param  {obj} msg.target A message target
   * @param  {obj} tabDetails details about a loaded tab, similar to onNewTabInit
   */
  onMessage(msg, tabDetails) {
    if (!msg.data || !msg.data.type) {
      console.error(
        new Error(
          `Received an improperly formatted message from ${tabDetails.portID}`
        )
      );
      return;
    }
    let action = {};
    Object.assign(action, msg.data);
    // target is used to access a browser reference that came from the content
    // and should only be used in feeds (not reducers)
    action._target = {
      browser: tabDetails.browser,
    };

    this.onActionFromContent(action, tabDetails.portID);
  }
}