macro(GENERATE_ATOMS _inputs)

    foreach (_file IN ITEMS ${_inputs})

        get_filename_component(_name ${_file} NAME)

        add_custom_command(

            OUTPUT ${_file}

            MAIN_DEPENDENCY ${WEBKIT_DIR}/Scripts/generate-automation-atom.py

            DEPENDS

                ${WEBKIT_DIR}/UIProcess/Automation/atoms/${_name}

                ${WEBKIT_DIR}/UIProcess/Automation/atoms/utils.js

            COMMAND ${PYTHON_EXECUTABLE} ${WEBKIT_DIR}/Scripts/generate-automation-atom.py ${WEBKIT_DIR}/UIProcess/Automation/atoms/${_name} ${_file}

            VERBATIM

        )

    endforeach ()

endmacro()

GENERATE_ATOMS("${WebDriver_SCRIPTS}")

2022-02-04  Carlos Garcia Campos  <cgarcia@igalia.com>

        WebDriver: add a javascript atom to get the visible text

        https://bugs.webkit.org/show_bug.cgi?id=174617

        <rdar://problem/32307461>

        Reviewed by NOBODY (OOPS!).

        Generate the JavaScript atoms using the new command and use the new atom to get element text.

        * CMakeLists.txt:

        * Session.cpp:

        (WebDriver::Session::getElementText):

2022-02-04  Carlos Garcia Campos  <cgarcia@igalia.com>

        WebDriver: add a javascript atom to get the visible text

        https://bugs.webkit.org/show_bug.cgi?id=174617

        <rdar://problem/32307461>

        Reviewed by NOBODY (OOPS!).

        Add a new JavaScript atom to get the visible text according to the spec. The new atom uses code from other atoms

        like ElementDisplayed and it's also used now by FindNodes one. The atoms are now autogenerated using a script to

        include the duplicated code from a common source utils.js.

        * Scripts/generate-automation-atom.py: Added.

        (collect_utils):

        (parse_utils):

        (append_functions):

        (main):

        * UIProcess/Automation/atoms/ElementDisplayed.js:

        (isShown.nodeIsElement): Deleted.

        (isShown.parentElementForElement): Deleted.

        (isShown.enclosingNodeOrSelfMatchingPredicate): Deleted.

        (isShown.enclosingElementOrSelfMatchingPredicate): Deleted.

        (isShown.cascadedStylePropertyForElement): Deleted.

        (isShown.elementSubtreeHasNonZeroDimensions): Deleted.

        (isShown): Deleted.

        (isShown.isElementSubtreeHiddenByOverflow): Deleted.

        * UIProcess/Automation/atoms/ElementText.js: Added.

        * UIProcess/Automation/atoms/FindNodes.js:

        (tryToFindNode):

        * UIProcess/Automation/atoms/utils.js: Added.

        (utils.nodeIsElement):

        (utils.enclosingNodeOrSelfMatchingPredicate):

        (utils.parentElementForElement):

        (utils.cascadedStylePropertyForElement):

        (elementSubtreeHasNonZeroDimensions):

        (isElementSubtreeHiddenByOverflow):

        (utils.isShown):

        (appendLines.currentLine):

        (appendLines):

        (utils.getText):

#!/usr/bin/env python3

#

# Copyright (C) 2022 Igalia S.L.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

# 1.  Redistributions of source code must retain the above copyright

#     notice, this list of conditions and the following disclaimer.

# 2.  Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR

# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import os

import re

import sys

def collect_utils(data):

    match = re.findall(r'(?P<destination>utils\.[A-Za-z_0-9]+)', data)

    return set(match)

def parse_utils(utils):

    functions = {}

    current_function = None

    with open(utils, "r") as fd:

        for line in fd.readlines():

            if line.startswith("utils."):

                current_function = line.split(" ", 1)[0]

                functions.setdefault(current_function, "")

            elif line.startswith("}"):

                functions[current_function] += line

                current_function = None

            if current_function is not None:

                functions[current_function] += line

    return functions

def append_functions(utils_data, util_functions, util_functions_impl, functions_written):

    for function in util_functions:

        if function in functions_written:

            continue

        function_impl = util_functions_impl[function]

        dependencies = collect_utils(function_impl)

        if function in dependencies:

            dependencies.remove(function)

        append_functions(utils_data, dependencies, util_functions_impl, functions_written)

        for line in function_impl.split("\n"):

            if not line.strip():

                utils_data.append(line)

            else:

                utils_data.append("    " + line)

        functions_written.append(function)

def main(args):

    input = args[0]

    output = args[1]

    utils = os.path.join(os.path.dirname(input), "utils.js")

    with open(input, "r") as fd:

        input_data = fd.read()

    util_functions = collect_utils(input_data)

    if util_functions:

        utils_data = ["    var utils = { };", ""]

        util_functions_impl = parse_utils(utils)

        functions_written = []

        append_functions(utils_data, util_functions, util_functions_impl, functions_written)

        input_data = input_data.replace('"use strict";\n', '"use strict";\n\n' + "\n".join(utils_data))

    with open(output, "w") as fd:

        fd.write(input_data)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv[1:]))

/*

 * Copyright (C) 2022 Igalia S.L.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

function(element) {

    "use strict";

    return utils.getText(element);

}

    "use strict";

/*

 * Copyright (C) 2022 Igalia S.L.

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

var utils = { };

utils.nodeIsElement = function(node) {

    return !!node && node.nodeType === Node.ELEMENT_NODE;

}

utils.enclosingNodeOrSelfMatchingPredicate = function(targetNode, predicate) {

    for (let node = targetNode; node && node !== targetNode.getRootNode(); node = node.parentNode)

        if (predicate(node))

            return node;

    return null;

}

utils.parentElementForElement = function(element) {

    if (!element)

        return null;

    return utils.enclosingNodeOrSelfMatchingPredicate(element.parentNode, utils.nodeIsElement);

}

utils.cascadedStylePropertyForElement = function(element, property) {

    if (!element || !property)

        return null;

    let computedStyle = window.getComputedStyle(element);

    let computedStyleProperty = computedStyle.getPropertyValue(property);

    if (computedStyleProperty && computedStyleProperty !== "inherit")

        return computedStyleProperty;

    // Ideally getPropertyValue would return the 'used' or 'actual' value, but

    // it doesn't for legacy reasons. So we need to do our own poor man's cascade.

    // Fall back to the first non-'inherit' value found in an ancestor.

    // In any case, getPropertyValue will not return 'initial'.

    // FIXME: will this incorrectly inherit non-inheritable CSS properties?

    // I think all important non-inheritable properties (width, height, etc.)

    // for our purposes here are specially resolved, so this may not be an issue.

    // Specification is here: https://drafts.csswg.org/cssom/#resolved-values

    let parentElement = utils.parentElementForElement(element);

    return utils.cascadedStylePropertyForElement(parentElement, property);

}

utils.isShown = function(element) {

    function enclosingElementOrSelfMatchingPredicate(targetElement, predicate) {

        for (let element = targetElement; element && element !== targetElement.getRootNode(); element = utils.parentElementForElement(element))

            if (predicate(element))

                return element;

        return null;

    }

    function elementSubtreeHasNonZeroDimensions(element) {

        let boundingBox = element.getBoundingClientRect();

        if (boundingBox.width > 0 && boundingBox.height > 0)

            return true;

        // Paths can have a zero width or height. Treat them as shown if the stroke width is positive.

        if (element.tagName.toUpperCase() === "PATH" && boundingBox.width + boundingBox.height > 0) {

            let strokeWidth = utils.cascadedStylePropertyForElement(element, "stroke-width");

            return !!strokeWidth && (parseInt(strokeWidth, 10) > 0);

        }

        let cascadedOverflow = utils.cascadedStylePropertyForElement(element, "overflow");

        if (cascadedOverflow === "hidden")

            return false;

        // If the container's overflow is not hidden and it has zero size, consider the

        // container to have non-zero dimensions if a child node has non-zero dimensions.

        return Array.from(element.childNodes).some((childNode) => {

            if (childNode.nodeType === Node.TEXT_NODE)

                return true;

            if (utils.nodeIsElement(childNode))

                return elementSubtreeHasNonZeroDimensions(childNode);

            return false;

        });

    }

    function elementOverflowsContainer(element) {

        let cascadedOverflow = utils.cascadedStylePropertyForElement(element, "overflow");

        if (cascadedOverflow !== "hidden")

            return false;

        // FIXME: this needs to take into account the scroll position of the element,

        // the display modes of it and its ancestors, and the container it overflows.

        // See Selenium's bot.dom.getOverflowState atom for an exhaustive list of edge cases.

        return true;

    }

    function isElementSubtreeHiddenByOverflow(element) {

        if (!element)

            return false;

        if (!elementOverflowsContainer(element))

            return false;

        if (!element.childNodes.length)

            return false;

        // This element's subtree is hidden by overflow if all child subtrees are as well.

        return Array.from(element.childNodes).every((childNode) => {

            // Returns true if the child node is overflowed or otherwise hidden.

            // Base case: not an element, has zero size, scrolled out, or doesn't overflow container.

            if (!utils.nodeIsElement(childNode))

                return true;

            if (!elementSubtreeHasNonZeroDimensions(childNode))

                return true;

            // Recurse.

            return isElementSubtreeHiddenByOverflow(childNode);

        });

    }

    // This is a partial reimplementation of Selenium's "element is displayed" algorithm.

    // When the W3C specification's algorithm stabilizes, we should implement that.

    if (!(element instanceof Element))

        throw new Error("Cannot check the displayedness of a non-Element argument.");

    // If this command is misdirected to the wrong document, treat it as not shown.

    if (!document.contains(element))

        return false;

    // Special cases for specific tag names.

    switch (element.tagName.toUpperCase()) {

    case "BODY":

        return true;

    case "SCRIPT":

    case "NOSCRIPT":

        return false;

    case "OPTGROUP":

    case "OPTION":

        // Option/optgroup are considered shown if the containing <select> is shown.

        let enclosingSelectElement = utils.enclosingNodeOrSelfMatchingPredicate(element, (e) => e.tagName.toUpperCase() === "SELECT");

        return utils.isShown(enclosingSelectElement);

    case "INPUT":

        // <input type="hidden"> is considered not shown.

        if (element.type === "hidden")

            return false;

        break;

    case "MAP":

        // FIXME: Selenium has special handling for <map> elements. We don't do anything now.

    default:

        break;

    }

    if (utils.cascadedStylePropertyForElement(element, "visibility") !== "visible")

        return false;

    let hasAncestorWithZeroOpacity = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {

        return Number(utils.cascadedStylePropertyForElement(e, "opacity")) === 0;

    });

    let hasAncestorWithDisplayNone = !!enclosingElementOrSelfMatchingPredicate(element, (e) => {

        return utils.cascadedStylePropertyForElement(e, "display") === "none";

    });

    if (hasAncestorWithZeroOpacity || hasAncestorWithDisplayNone)

        return false;

    if (!elementSubtreeHasNonZeroDimensions(element))

        return false;

    if (isElementSubtreeHiddenByOverflow(element))

        return false;

    return true;

}

utils.getText = function(element) {

    var lines = [];

    function appendLinesFromTextNode(textNode, whitespace, textTransform) {

        // Remove zero-width characters.

        let text = textNode.nodeValue.replace(/[\u200b\u200e\u200f]/g, '');

        // Canonicalize the new lines.

        text = text.replace(/(\r\n|\r|\n)/g, '\n');

        let collapseAll = true;

        switch (whitespace) {

        case "normal":

        case "nowrap":

            // Collapse new lines.

            text = text.replace(/\n/g, ' ');

            break;

        case "pre":

        case "pre-wrap":

            // Convert all breaking spaces to be non-breaking.

            text = text.replace(/[ \f\t\v\u2028\u2029]/g, '\xa0');

            collapseAll = false;

            break;

        }

        if (collapseAll) {

            // Collapse all breaking spaces.

            text = text.replace(/[\ \f\t\v\u2028\u2029]+/g, ' ');

        }

        switch (textTransform) {

        case "capitalize":

            text = text.replace(/(^|[^\d\p{L}\p{S}])([\p{Ll}|\p{S}])/gu, function() {

                return arguments[1] + arguments[2].toUpperCase();

            });

            break;

        case "uppercase":

            text = text.toUpperCase();

            break;

        case "lowercase":

            text = text.toLowerCase();

            break;

        }

        let currentLine = lines.pop() || '';

        if (currentLine.endsWith(' ') && text.startsWith(' '))

            text = text.substr(1);

        lines.push(currentLine + text);

    }

    function appendLines(element) {

        function currentLine() {

            return lines[lines.length - 1] || '';

        }

        let isTableCell = false, display = null, isBlock = false;

        if (element.tagName.toUpperCase() === "BR")

            lines.push('');

        else {

            isTableCell = element.tagName.toUpperCase() === "TD";

            display = utils.cascadedStylePropertyForElement(element, "display");

            isBlock = !isTableCell

                && !(display === "inline"

                     || display === "inline-block"

                     || display === "inline-table"

                     || display === "none"

                     || display === "table-cell"

                     || display === "table-column"

                     || display === "table-column-group");

            let previousElementSibling = element.previousElementSibling;

            let previousDisplay = previousElementSibling ? utils.cascadedStylePropertyForElement(previousElementSibling, "display") : '';

            let elementFloat = utils.cascadedStylePropertyForElement(element, "float") || utils.cascadedStylePropertyForElement(element, "cssFloat");

            let runIntoThis = previousDisplay == "run-in" && elementFloat == "none";

            if (isBlock && !runIntoThis && /^[\s\xa0]*$/.test(currentLine()))

                lines.push('');

        }

        let shown = utils.isShown(element);

        let whitespace = null, textTransform = null;

        if (shown) {

            whitespace = utils.cascadedStylePropertyForElement(element, "white-space");

            textTransform = utils.cascadedStylePropertyForElement(element, "text-transform");

        }

        Array.from(element.childNodes).forEach((childNode) => {

            switch (childNode.nodeType) {

            case Node.TEXT_NODE:

                if (shown)

                    appendLinesFromTextNode(childNode, whitespace, textTransform);

                break;

            case Node.ELEMENT_NODE:

                appendLines(childNode);

                break;

            }

        });

        let line = currentLine();

        if ((isTableCell || display == "table-cell") && line && line.endsWith(' '))

            lines[lines.length - 1] += ' ';

        if (isBlock && display != "run-in" && /^[\s\xa0]*$/.test(line))

            lines.push('');

    }

    appendLines(element);

    lines = lines.map((str) => str.replace(/^[^\S\xa0]+|[^\S\xa0]+$/g, ''));

    let trimmed = lines.join('\n').replace(/^[^\S\xa0]+|[^\S\xa0]+$/g, '');

    // Replace non-breakable spaces with regular ones.

    return trimmed.replace(/\xa0/g, ' ');

}

2022-02-04  Carlos Garcia Campos  <cgarcia@igalia.com>

        WebDriver: add a javascript atom to get the visible text

        https://bugs.webkit.org/show_bug.cgi?id=174617

        <rdar://problem/32307461>

        Reviewed by NOBODY (OOPS!).

        Remove expectations of tests that are now passing.

        * TestExpectations.json: