Bug 1820252 - Misc. TranslationsDocument refactors r=translations-reviewers,gregtatum

        if (!mutation.target) {

          continue;

        }

        const pendingNode = this.#getPendingNodeFromTarget(mutation.target);

        if (pendingNode) {

          const translationId =

            this.#pendingContentTranslations.get(pendingNode);

          if (translationId) {

          if (this.#preventContentTranslation(pendingNode)) {

            // The node was still pending to be translated, cancel it and re-submit.

            this.#preventContentTranslation(pendingNode, translationId);

            this.#markNodeContentMutated(pendingNode);

            if (mutation.type === "childList") {

              // New nodes could have been added, make sure we can follow their shadow roots.

              if (!removedNode) {

                continue;

              }

              const translationId =

                this.#pendingContentTranslations.get(removedNode);

              if (translationId) {

                this.#preventContentTranslation(removedNode, translationId);

              }

              this.#preventContentTranslation(removedNode);

              this.#preventAttributeTranslations(removedNode);

            }

            break;

    const addRootElements = () => {

      this.#addRootElement(document.querySelector("title"));

      this.#addRootElement(document.body);

      this.#addRootElement(document.head);

      this.#addRootElement(document.body);

    };

    if (document.body) {

   * @param {string} attributeName

   */

  #maybeMarkElementAttributeMutated(element, attributeName) {

    if (isAttributeTranslatable(element, attributeName)) {

    if (!isAttributeTranslatable(element, attributeName)) {

      // The given attribute is not translatable for this element.

      return;

    }

    let attributes = this.#elementsWithMutatedAttributes.get(element);

    if (!attributes) {

      attributes = new Set();

    attributes.add(attributeName);

    this.#ensureMutationUpdateCallbackIsRegistered();

  }

  }

  /**

   * Ensures that all nodes that have been picked up by the mutation observer

   * are processed, prioritized and sent to the scheduler to re translated.

   */

  #ensureMutationUpdateCallbackIsRegistered() {

    if (this.#hasPendingMutatedNodesCallback) {

      // A callback has already been registered to update mutated nodes.

      return;

    }

    if (

      !this.#hasPendingMutatedNodesCallback &&

      (this.#nodesWithMutatedContent.size || this.#queuedAttributeElements)

      this.#nodesWithMutatedContent.size === 0 &&

      this.#elementsWithMutatedAttributes.size === 0

    ) {

      // There are no mutated nodes to update.

      return;

    }

    this.#hasPendingMutatedNodesCallback = true;

    const ownerGlobal = ensureExists(this.#sourceDocument.ownerGlobal);

      // Perform a double requestAnimationFrame to:

      //   1. Reduce the number of invalidation cycles of canceling intermediate translations.

      //   2. Do less work on the main thread when there are many mutations.

    // Nodes can be mutated in a tight loop. To guard against the performance of re-translating nodes too frequently,

    // we will batch the processing of mutated nodes into a double requestAnimationFrame.

    ownerGlobal.requestAnimationFrame(() => {

      ownerGlobal.requestAnimationFrame(() => {

        this.#hasPendingMutatedNodesCallback = false;

          this.#enqueueElementForAttributeTranslation(node, attributes);

        }

        this.#dispatchQueuedAttributeTranslations();

        this.#elementsWithMutatedAttributes.clear();

      });

    });

  }

  }

  /**

   * If a pending node contains or is the target node, return that pending node.

   * that content has changed, and the previous translation is no longer valid.

   *

   * @param {Node} node

   * @param {number} translationId

   * @returns {boolean}

   */

  #preventContentTranslation(node, translationId) {

  #preventContentTranslation(node) {

    const translationId = this.#pendingContentTranslations.get(node);

    if (!translationId) {

      // No pending content translation was found for this node.

      return false;

    }

    this.translator.cancelSingleTranslation(translationId);

    if (!isNodeDetached(node)) {

      const element = /** @type {HTMLElement} */ (asHTMLElement(node));

      if (element) {

        }

      }

    }

    this.#pendingContentTranslations.delete(node);

    this.#processedContentNodes.delete(node);

    return true;

  }

  /**

   * that content has changed, and the previous translation is no longer valid.

   *

   * @param {Node} node

   * @returns {boolean}

   *   - True if any pending attribute translations were found for this node.

   */

  #preventAttributeTranslations(node) {

    const element = asElement(node);

    if (!element) {

      return;

      // We only translate attributes on Element type nodes.

      return false;

    }

    const attributes = this.#pendingAttributeTranslations.get(element);

    if (attributes) {

    if (!attributes) {

      // No pending attribute translations were found for this element.

      return false;

    }

    for (const translationId of attributes.values()) {

      this.translator.cancelSingleTranslation(translationId);

    }

    this.#pendingAttributeTranslations.delete(element);

    }

    return true;

  }

  /**

    this.#rootNodes.add(element);

    let viewportNodeTranslations =

      this.#subdivideNodeForContentTranslations(element);

    let viewportAttributeTranslations =

      this.#subdivideNodeForAttributeTranslations(element);

    if (element.nodeName === "TITLE") {

      // The <title> node is special, in that it will never intersect with the viewport,

      // so we must explicitly enqueue it for translation here.

      this.#enqueueNodeForContentTranslation(element);

      this.#maybeEnqueueElementForAttributeTranslation(element);

      return;

    }

    if (!this.#viewportTranslated) {

      this.#viewportTranslated = Promise.allSettled([

        ...(viewportNodeTranslations ?? []),

        ...(viewportAttributeTranslations ?? []),

      ]);

    if (element.nodeName !== "HEAD") {

      // We do not consider the <head> element for content translations, only attributes.

      const contentStartTime = Cu.now();

      this.#subdivideNodeForContentTranslations(element);

      ChromeUtils.addProfilerMarker(

        "TranslationsDocument Add Root",

        { startTime: contentStartTime, innerWindowId: this.#innerWindowId },

        `Subdivided new root "${node.nodeName}" for content translations`

      );

    }

    this.#subdivideNodeForAttributeTranslations(element);

    this.#mutationObserver.observe(element, MUTATION_OBSERVER_OPTIONS);

    this.#addShadowRootsToObserver(element);

  }

      visibility = "in-viewport";

    }

    if (!this.#processedContentNodes.has(node)) {

      this.#queuedContentNodes.set(node, visibility);

    }

  }

  /**

   * Submit the translations giving priority to nodes in the viewport.

   */

  #pauseMutationObserverAndThen(callback) {

    this.#stopMutationObserver();

    try {

      callback();

    } finally {

      this.#startMutationObserver();

    }

  }

  /**

   * Ensures that nodes with completed content translation requests will be updated.

    root = node.ownerDocument.body;

  }

  if (node.parentNode && node.parentNode !== root) {

    path = createNodePath(node.parentNode);

    path = createNodePath(node.parentNode, root);

  }

  path += `/${node.nodeName}`;

  return (

    // This node is out of the DOM and already garbage collected.

    Cu.isDeadWrapper(node) ||

    // The node is detached, but not yet garbage collected,

    // or it has been re-parented to a parent that itself is not connected.

    !node.isConnected ||

    // Normally you could just check `node.parentElement` to see if an element is

    // part of the DOM, but the Chrome-only flattenedTreeParentNode is used to include

    // Shadow DOM elements, which have a null parentElement.