<!DOCTYPE html>
<style>
body {
    margin: 0;
    font-family: Helvetica, sans-serif;
    font-size: 11pt;
}

body > * {
    margin-left: 4px;
    margin-top: 4px;
}

h1 {
    font-size: 14pt;
    margin-top: 1.5em;
}

p {
    margin-bottom: 0.3em;
}

tr:not(.results-row) td {
    white-space: nowrap;
}

tr:not(.results-row) td:first-of-type {
    white-space: normal;
}

td:not(:first-of-type) {
    text-transform: lowercase;
}

td {
    padding: 1px 4px;
}

th:empty, td:empty {
    padding: 0;
}

th {
    -webkit-user-select: none;
    -moz-user-select: none;
}

.content-container {
    min-height: 0;
}

.note {
    color: gray;
    font-size: smaller;
}

.results-row {
    background-color: white;
}

.results-row iframe, .results-row img {
    width: 800px;
    height: 600px;
}

.results-row[data-expanded="false"] {
    display: none;
}

#toolbar {
    position: fixed;
    top: 2px;
    right: 2px;
    text-align: right;
}

.floating-panel {
    padding: 4px;
    background-color: rgba(255, 255, 255, 0.9);
    border: 1px solid silver;
    border-radius: 4px;
}

.expand-button {
    background-color: white;
    width: 11px;
    height: 12px;
    border: 1px solid gray;
    display: inline-block;
    margin: 0 3px 0 0;
    position: relative;
    cursor: default;
}

.current {
    color: red;
}

.current .expand-button {
    border-color: red;
}

.expand-button-text {
    position: absolute;
    top: -0.3em;
    left: 1px;
}

tbody .flag {
    display: none;
}

tbody.flagged .flag {
    display: inline;
}

.stopped-running-early-message {
    border: 3px solid #d00;
    font-weight: bold;
    display: inline-block;
    padding: 3px;
}

.result-container {
    display: inline-block;
    border: 1px solid gray;
    margin: 4px;
}

.result-container iframe, .result-container img {
    border: 0;
    vertical-align: top;
}

#options {
    background-color: white;
}

#options-menu {
    border: 1px solid;
    margin-top: 1px;
    padding: 2px 4px;
    box-shadow: 2px 2px 2px #888;
    -webkit-transition: opacity .2s;
    text-align: left;
    position: absolute;
    right: 4px;
    background-color: white;
}

#options-menu label {
    display: block;
}

.hidden-menu {
    pointer-events: none;
    opacity: 0;
}

.label {
    padding-left: 3px;
    font-weight: bold;
    font-size: small;
    background-color: silver;
}

.pixel-zoom-container {
    position: fixed;
    top: 0;
    left: 0;
    width: 96%;
    margin: 10px;
    padding: 10px;
    display: -webkit-box;
    display: -moz-box;
    pointer-events: none;
    background-color: silver;
    border-radius: 20px;
    border: 1px solid gray;
    box-shadow: 0 0 5px rgba(0, 0, 0, 0.75);
}

.pixel-zoom-container > * {
    -webkit-box-flex: 1;
    -moz-box-flex: 1;
    border: 1px solid black;
    margin: 4px;
    overflow: hidden;
    background-color: white;
}

.pixel-zoom-container .scaled-image-container {
    position: relative;
    overflow: hidden;
    width: 100%;
    height: 400px;
}

.scaled-image-container > img {
    position: absolute;
    top: 0;
    left: 0;
    image-rendering: -webkit-optimize-contrast;
}

#flagged-test-container {
    position: fixed;
    bottom: 4px;
    right: 4px;
    width: 50%;
    min-width: 400px;
    background-color: rgba(255, 255, 255, 0.75);
}

#flagged-test-container > h2 {
    margin: 0 0 4px 0;
}

#flagged-tests {
    padding: 0 5px;
    margin: 0;
    height: 7em;
    overflow-y: scroll;
}
</style>
<style id="unexpected-style"></style>

<script>
if (window.testRunner)
    testRunner.dumpAsText();

var g_state;
function globalState()
{
    if (!g_state) {
        g_state = {
            crashTests: [],
            crashOther: [],
            flakyPassTests: [],
            hasHttpTests: false,
            hasImageFailures: false,
            hasTextFailures: false,
            missingResults: [],
            results: {},
            shouldToggleImages: true,
            failingTests: [],
            testsWithStderr: [],
            timeoutTests: [],
            unexpectedPassTests: []
        }
    }
    return g_state;
}

function ADD_RESULTS(input)
{
    globalState().results = input;
}
</script>

<script src="full_results.json"></script>

<script>
function splitExtension(test)
{
    var index = test.lastIndexOf('.');
    if (index == -1) {
        return [test, ""];
    }
    return [test.substring(0, index), test.substring(index + 1)];
}

function stripExtension(test)
{
    // Temporary fix, also in Tools/Scripts/webkitpy/layout_tests/constrollers/test_result_writer.py, line 95.
    // FIXME: Refactor to avoid confusing reference to both test and process names.
    if (splitExtension(test)[1].length > 5)
        return test;
    return splitExtension(test)[0];
}

function matchesSelector(node, selector)
{
    if (node.matches)
        return node.matches(selector);

    if (node.webkitMatchesSelector)
        return node.webkitMatchesSelector(selector);

    if (node.mozMatchesSelector)
        return node.mozMatchesSelector(selector);
}

function parentOfType(node, selector)
{
    while (node = node.parentNode) {
        if (matchesSelector(node, selector))
            return node;
    }
    return null;
}

function remove(node)
{
    node.parentNode.removeChild(node);
}

function forEach(nodeList, handler)
{
    Array.prototype.forEach.call(nodeList, handler);
}

function resultIframe(src)
{
    // FIXME: use audio tags for AUDIO tests?
    var layoutTestsIndex = src.indexOf('LayoutTests');
    var name;
    if (layoutTestsIndex != -1) {
        var hasTrac = src.indexOf('trac.webkit.org') != -1;
        var prefix = hasTrac ? 'trac.webkit.org/.../' : '';
        name = prefix + src.substring(layoutTestsIndex + 'LayoutTests/'.length);
    } else {
        var lastDashIndex = src.lastIndexOf('-pretty');
        if (lastDashIndex == -1)
            lastDashIndex = src.lastIndexOf('-');
        name = src.substring(lastDashIndex + 1);
    }

    var tagName = (src.lastIndexOf('.png') == -1) ? 'iframe' : 'img';

    if (tagName != 'img')
        src += '?format=txt';
    return '<div class=result-container><div class=label>' + name + '</div><' + tagName + ' src="' + src + '"></' + tagName + '></div>';
}

function togglingImage(prefix)
{
    return '<div class=result-container><div class="label imageText"></div><img class=animatedImage data-prefix="' +
        prefix + '"></img></div>';
}

function toggleExpectations(element)
{
    var expandLink = element;
    if (expandLink.className != 'expand-button-text')
        expandLink = expandLink.querySelector('.expand-button-text');

    if (expandLink.textContent == '+')
        expandExpectations(expandLink);
    else
        collapseExpectations(expandLink);
}

function collapseExpectations(expandLink)
{
    expandLink.textContent = '+';
    var existingResultsRow = parentOfType(expandLink, 'tbody').querySelector('.results-row');
    if (existingResultsRow)
        updateExpandedState(existingResultsRow, false);
}

function updateExpandedState(row, isExpanded)
{
    row.setAttribute('data-expanded', isExpanded);
    updateImageTogglingTimer();
}

function appendHTML(node, html)
{
    if (node.insertAdjacentHTML)
        node.insertAdjacentHTML('beforeEnd', html);
    else
        node.innerHTML += html;
}

function expandExpectations(expandLink)
{
    var row = parentOfType(expandLink, 'tr');
    var parentTbody = row.parentNode;
    var existingResultsRow = parentTbody.querySelector('.results-row');
    
    var enDash = '\u2013';
    expandLink.textContent = enDash;
    if (existingResultsRow) {
        updateExpandedState(existingResultsRow, true);
        return;
    }
    
    var newRow = document.createElement('tr');
    newRow.className = 'results-row';
    var newCell = document.createElement('td');
    newCell.colSpan = row.querySelectorAll('td').length;

    var resultLinks = row.querySelectorAll('.result-link');
    var hasTogglingImages = false;
    for (var i = 0; i < resultLinks.length; i++) {
        var link = resultLinks[i];
        var result;
        if (link.textContent == 'images') {
            hasTogglingImages = true;
            result = togglingImage(link.getAttribute('data-prefix'));
        } else
            result = resultIframe(link.href);

        appendHTML(newCell, result);    
    }

    newRow.appendChild(newCell);
    parentTbody.appendChild(newRow);

    updateExpandedState(newRow, true);

    updateImageTogglingTimer();
}

function updateImageTogglingTimer()
{
    var hasVisibleAnimatedImage = document.querySelector('.results-row[data-expanded="true"] .animatedImage');
    if (!hasVisibleAnimatedImage) {
        clearInterval(globalState().togglingImageInterval);
        globalState().togglingImageInterval = null;
        return;
    }

    if (!globalState().togglingImageInterval) {
        toggleImages();
        globalState().togglingImageInterval = setInterval(toggleImages, 2000);
    }
}

function async(func, args)
{
    setTimeout(function() { func.apply(null, args); }, 100);
}

function visibleTests(opt_container)
{
    var container = opt_container || document;
    if (onlyShowUnexpectedFailures())
        return container.querySelectorAll('tbody:not(.expected)');
    else
        return container.querySelectorAll('tbody');
}

function visibleExpandLinks()
{
    if (onlyShowUnexpectedFailures())
        return document.querySelectorAll('tbody:not(.expected) .expand-button-text');
    else
        return document.querySelectorAll('.expand-button-text');
}

function expandAllExpectations()
{
    var expandLinks = visibleExpandLinks();
    for (var i = 0, len = expandLinks.length; i < len; i++)
        async(expandExpectations, [expandLinks[i]]);
}

function collapseAllExpectations()
{
    var expandLinks = visibleExpandLinks();
    for (var i = 0, len = expandLinks.length; i < len; i++)
        async(collapseExpectations, [expandLinks[i]]);
}

function shouldUseTracLinks()
{
    return !globalState().results.layout_tests_dir || !location.toString().indexOf('file://') == 0;
}

function layoutTestsBasePath()
{
    var basePath;
    if (shouldUseTracLinks()) {
        var revision = globalState().results.revision;
        basePath = 'http://trac.webkit.org';
        basePath += revision ? ('/export/' + revision) : '/browser';
        basePath += '/trunk/LayoutTests/';
    } else
        basePath = globalState().results.layout_tests_dir + '/';
    return basePath;
}

var mappings = {
    "http/tests/ssl/": "https://127.0.0.1:8443/ssl/",
    "http/tests/": "http://127.0.0.1:8000/",
    "http/wpt/": "http://localhost:8800/WebKit/",
    "imported/w3c/web-platform-tests/": "http://localhost:8800/"
}

function testToURL(test, layoutTestsPath)
{
    for (let key in mappings) {
        if (test.startsWith(key))
            return mappings[key] + test.substring(key.length);

    }
    return "file://" + layoutTestsPath + "/" + test
}

function layoutTestURL(test)
{
    if (shouldUseTracLinks())
        return layoutTestsBasePath() + test;
    return testToURL(test, layoutTestsBasePath());
}

function checkServerIsRunning(event)
{
    if (shouldUseTracLinks())
        return;

    var url = event.target.href;
    if (url.startsWith("file://"))
        return;

    event.preventDefault();
    fetch(url, {mode: "no-cors"}).then(() => {
        window.location = url;
    }, () => {
        alert("HTTP server does not seem to be running, please use the run-webkit-httpd script");
    });
}

function testLink(test)
{
    return '<a class=test-link onclick="checkServerIsRunning(event)" href="' + layoutTestURL(test) + '">' + test + '</a><span class=flag onclick="unflag(this)"> \u2691</span>';
}

function unflag(flag)
{
    var shouldFlag = false;
    TestNavigator.flagTest(parentOfType(flag, 'tbody'), shouldFlag);
}

function testLinkWithExpandButton(test)
{
    return '<span class=expand-button onclick="toggleExpectations(this)"><span class=expand-button-text>+</span></span>' + testLink(test);
}

function testWithExpandButton(test)
{
    return '<span class=expand-button onclick="toggleExpectations(this)"><span class=expand-button-text>+</span></span>' + test;
}

function resultLink(testPrefix, suffix, contents)
{
    return '<a class=result-link href="' + testPrefix + suffix + '" data-prefix="' + testPrefix + '">' + contents + '</a> ';
}

function isFailureExpected(expected, actual)
{
    var isExpected = true;
    if (actual != 'SKIP') {
        var expectedArray = expected.split(' ');
        var actualArray = actual.split(' ');
        for (var i = 0; i < actualArray.length; i++) {
            var actualValue = actualArray[i];
            if (expectedArray.indexOf(actualValue) == -1 &&
                (expectedArray.indexOf('FAIL') == -1 ||
                 (actualValue != 'TEXT' && actualValue != 'IMAGE+TEXT' && actualValue != 'AUDIO')))
                isExpected = false;
        }
    }
    return isExpected;
}

function processGlobalStateFor(testObject)
{
    var test = testObject.name;
    if (testObject.has_stderr)
        globalState().testsWithStderr.push(testObject);

    globalState().hasHttpTests = globalState().hasHttpTests || test.indexOf('http/') == 0;

    var actual = testObject.actual;    
    var expected = testObject.expected || 'PASS';
    if (globalState().results.uses_expectations_file)
        testObject.isExpected = isFailureExpected(expected, actual);

    if (actual == 'MISSING') {
        // FIXME: make sure that new-run-webkit-tests spits out an -actual.txt file for
        // tests with MISSING results.
        globalState().missingResults.push(testObject);
        return;
    }

    var actualTokens = actual.split(' ');
    var passedWithImageOnlyFailureInRetry = actualTokens[0] == 'TEXT' && actualTokens[1] == 'IMAGE';
    if (actualTokens[1] && actual.indexOf('PASS') != -1 || (!globalState().results.pixel_tests_enabled && passedWithImageOnlyFailureInRetry)) {
        globalState().flakyPassTests.push(testObject);
        return;
    }

    if (actual == 'PASS' && expected != 'PASS') {
        if (expected != 'IMAGE' || (globalState().results.pixel_tests_enabled || testObject.reftest_type)) {
            globalState().unexpectedPassTests.push(testObject);
        }
        return;
    }

    if (actual == 'CRASH') {
        globalState().crashTests.push(testObject);
        return;
    }

    if (actual == 'TIMEOUT') {
        globalState().timeoutTests.push(testObject);
        return;
    }
    
    globalState().failingTests.push(testObject);
}

function toggleImages()
{
    var images = document.querySelectorAll('.animatedImage');
    var imageTexts = document.querySelectorAll('.imageText');
    for (var i = 0, len = images.length; i < len; i++) {
        var image = images[i];
        var text = imageTexts[i];
        if (text.textContent == 'Expected Image') {
            text.textContent = 'Actual Image';
            image.src = image.getAttribute('data-prefix') + '-actual.png';
        } else {
            text.textContent = 'Expected Image';
            image.src = image.getAttribute('data-prefix') + '-expected.png';
        }
    }
}

function textResultLinks(prefix)
{
    var html = resultLink(prefix, '-expected.txt', 'expected') +
        resultLink(prefix, '-actual.txt', 'actual') +
        resultLink(prefix, '-diff.txt', 'diff');

    if (globalState().results.has_pretty_patch)
        html += resultLink(prefix, '-pretty-diff.html', 'pretty diff');

    if (globalState().results.has_wdiff)
        html += resultLink(prefix, '-wdiff.html', 'wdiff');

    return html;
}

function imageResultsCell(testObject, testPrefix, actual) {
    var row = '';

    if (actual.indexOf('IMAGE') != -1) {
        var testExtension = splitExtension(testObject.name)[1];
        globalState().hasImageFailures = true;

        if (testObject.reftest_type && testObject.reftest_type.indexOf('!=') != -1) {
            row += resultLink(layoutTestsBasePath() + testPrefix, '-expected-mismatch.' + testExtension, 'ref mismatch');
            row += resultLink(testPrefix, '-actual.png', 'actual');
        } else {
            if (testObject.reftest_type && testObject.reftest_type.indexOf('==') != -1) {
                row += resultLink(layoutTestsBasePath() + testPrefix, '-expected.' + testExtension, 'reference');
            }
            if (globalState().shouldToggleImages) {
                row += resultLink(testPrefix, '-diffs.html', 'images');
            } else {
                row += resultLink(testPrefix, '-expected.png', 'expected');
                row += resultLink(testPrefix, '-actual.png', 'actual');
            }

            var diff = testObject.image_diff_percent;
            row += resultLink(testPrefix, '-diff.png', 'diff (' + diff + '%)');
        }
    }

    if (actual.indexOf('MISSING') != -1 && testObject.is_missing_image)
        row += resultLink(testPrefix, '-actual.png', 'png result');

    return row;
}

function flakinessDashboardURLForTests(testObjects)
{
    var testList = "";
    for (var i = 0; i < testObjects.length; ++i) {
        testList += testObjects[i].name;

        if (i != testObjects.length - 1)
            testList += ",";
    }

    return 'http://webkit-test-results.webkit.org/dashboards/flakiness_dashboard.html#showAllRuns=true&tests=' + encodeURIComponent(testList);
}

function tableRow(testObject)
{    
    var row = '<tbody'
    if (globalState().results.uses_expectations_file)
        row += ' class="' + (testObject.isExpected ? 'expected' : '') + '"';
    if (testObject.reftest_type && testObject.reftest_type.indexOf('!=') != -1)
        row += ' mismatchreftest=true';
    row += '><tr>';

    row += '<td>' + testLinkWithExpandButton(testObject.name) + '</td>';

    var testPrefix = stripExtension(testObject.name);
    row += '<td>';
    
    var actual = testObject.actual;
    if (actual.indexOf('TEXT') != -1) {
        globalState().hasTextFailures = true;
        row += textResultLinks(testPrefix);
    }
    
    if (actual.indexOf('AUDIO') != -1) {
        row += resultLink(testPrefix, '-expected.wav', 'expected audio');
        row += resultLink(testPrefix, '-actual.wav', 'actual audio');
        row += resultLink(testPrefix, '-diff.txt', 'textual diff');
    }

    if (actual.indexOf('MISSING') != -1) {
        if (testObject.is_missing_audio)
            row += resultLink(testPrefix, '-actual.wav', 'audio result');
        if (testObject.is_missing_text)
            row += resultLink(testPrefix, '-actual.txt', 'result');
    }

    var actualTokens = actual.split(/\s+/);
    var cell = imageResultsCell(testObject, testPrefix, actualTokens[0]);
    if (!cell && actualTokens.length > 1)
        cell = imageResultsCell(testObject, 'retries/' + testPrefix, actualTokens[1]);

    row += '</td><td>' + cell + '</td>';

    if (globalState().results.uses_expectations_file || actual.indexOf(' ') != -1)
        row += '<td>' + actual + '</td>';

    if (globalState().results.uses_expectations_file)
        row += '<td>' + (actual.indexOf('MISSING') == -1 ? testObject.expected : '') + '</td>';

    row += '<td><a href="' + flakinessDashboardURLForTests([testObject]) + '">history</a></td>';

    row += '</tr></tbody>';
    return row;
}

function forEachTest(handler, opt_tree, opt_prefix)
{
    var tree = opt_tree || globalState().results.tests;
    var prefix = opt_prefix || '';

    for (var key in tree) {
        var newPrefix = prefix ? (prefix + '/' + key) : key;
        if ('actual' in tree[key]) {
            var testObject = tree[key];
            testObject.name = newPrefix;
            handler(testObject);
        } else
            forEachTest(handler, tree[key], newPrefix);
    }
}

function forOtherCrashes()
{
    var tree = globalState().results.other_crashes;
    for (var key in tree) {
            var testObject = tree[key];
            testObject.name = key;
            globalState().crashOther.push(testObject);
    }
}

function hasUnexpected(tests)
{
    return tests.some(function (test) { return !test.isExpected; });
}

function updateTestlistCounts()
{
    forEach(document.querySelectorAll('.test-list-count'), function(count) {
        var container = parentOfType(count, 'div');
        var testContainers;
        if (onlyShowUnexpectedFailures())
            testContainers = container.querySelectorAll('tbody:not(.expected)');
        else
            testContainers = container.querySelectorAll('tbody');

        count.textContent = testContainers.length;
    })
}

function flagAll(headerLink)
{
    var tests = visibleTests(parentOfType(headerLink, 'div'));
    forEach(tests, function(tests) {
        var shouldFlag = true;
        TestNavigator.flagTest(tests, shouldFlag);
    })
}

function testListHeaderHtml(header)
{
    return '<h1>' + header + ' (<span class=test-list-count></span>): <a href="#" class=flag-all onclick="flagAll(this)">flag all</a></h1>';
}

function testList(tests, header, tableId)
{
    tests.sort(function (a, b) { return a.name.localeCompare(b.name) });

    var html = '<div' + ((!hasUnexpected(tests) && tableId != 'stderr-table') ? ' class=expected' : '') + ' id=' + tableId + '>' +
        testListHeaderHtml(header) + '<table>';

    // FIXME: add the expected failure column for all the test lists if globalState().results.uses_expectations_file
    if (tableId == 'passes-table')
        html += '<thead><th>test</th><th>expected failure</th></thead>';

    for (var i = 0; i < tests.length; i++) {
        var testObject = tests[i];
        var test = testObject.name;
        html += '<tbody';
        if (globalState().results.uses_expectations_file)
            html += ' class="' + ((testObject.isExpected && tableId != 'stderr-table') ? 'expected' : '') + '"';
        html += '><tr><td>';
        if (tableId == 'passes-table')
            html += testLink(test);
        else if (tableId == 'other-crash-tests-table')
            html += testWithExpandButton(test);
        else
            html += testLinkWithExpandButton(test);

        html += '</td><td>';

        if (tableId == 'stderr-table')
            html += resultLink(stripExtension(test), '-stderr.txt', 'stderr');
        else if (tableId == 'passes-table')
            html += testObject.expected;
        else if (tableId == 'other-crash-tests-table') 
            html += resultLink(stripExtension(test), '-crash-log.txt', 'crash log');
        else if (tableId == 'crash-tests-table') {
            html += resultLink(stripExtension(test), '-crash-log.txt', 'crash log');
            html += resultLink(stripExtension(test), '-sample.txt', 'sample');
        } else if (tableId == 'timeout-tests-table') {
            // FIXME: only include timeout actual/diff results here if we actually spit out results for timeout tests.
            html += textResultLinks(stripExtension(test));
        }

        if (tableId != 'other-crash-tests-table')
            html += '</td><td><a href="' + flakinessDashboardURLForTests([testObject]) + '">history</a></td>';

        html += '</tr></tbody>';
    }
    html += '</table></div>';
    return html;
}

function toArray(nodeList)
{
    return Array.prototype.slice.call(nodeList);
}

function trim(string)
{
    return string.replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
}

// Just a namespace for code management.
var TableSorter = {};

TableSorter._forwardArrow = '<svg style="width:10px;height:10px"><polygon points="0,0 10,0 5,10" style="fill:#ccc"></svg>';

TableSorter._backwardArrow = '<svg style="width:10px;height:10px"><polygon points="0,10 10,10 5,0" style="fill:#ccc"></svg>';

TableSorter._sortedContents = function(header, arrow)
{
    return arrow + ' ' + trim(header.textContent) + ' ' + arrow;
}

TableSorter._updateHeaderClassNames = function(newHeader)
{
    var sortHeader = document.querySelector('.sortHeader');
    if (sortHeader) {
        if (sortHeader == newHeader) {
            var isAlreadyReversed = sortHeader.classList.contains('reversed');
            if (isAlreadyReversed)
                sortHeader.classList.remove('reversed');
            else
                sortHeader.classList.add('reversed');
        } else {
            sortHeader.textContent = sortHeader.textContent;
            sortHeader.classList.remove('sortHeader');
            sortHeader.classList.remove('reversed');
        }
    }

    newHeader.classList.add('sortHeader');
}

TableSorter._textContent = function(tbodyRow, column)
{
    return tbodyRow.querySelectorAll('td')[column].textContent;
}

TableSorter._sortRows = function(newHeader, reversed)
{
    var testsTable = document.getElementById('results-table');
    var headers = toArray(testsTable.querySelectorAll('th'));
    var sortColumn = headers.indexOf(newHeader);

    var rows = toArray(testsTable.querySelectorAll('tbody'));

    rows.sort(function(a, b) {
        // Only need to support lexicographic sort for now.
        var aText = TableSorter._textContent(a, sortColumn);
        var bText = TableSorter._textContent(b, sortColumn);
        
        // Forward sort equal values by test name.
        if (sortColumn && aText == bText) {
            var aTestName = TableSorter._textContent(a, 0);
            var bTestName = TableSorter._textContent(b, 0);
            if (aTestName == bTestName)
                return 0;
            return aTestName < bTestName ? -1 : 1;
        }

        if (reversed)
            return aText < bText ? 1 : -1;
        else
            return aText < bText ? -1 : 1;
    });

    for (var i = 0; i < rows.length; i++)
        testsTable.appendChild(rows[i]);
}

TableSorter.sortColumn = function(columnNumber)
{
    var newHeader = document.getElementById('results-table').querySelectorAll('th')[columnNumber];
    TableSorter._sort(newHeader);
}

TableSorter.handleClick = function(e)
{
    var newHeader = e.target;
    if (newHeader.localName != 'th')
        return;
    TableSorter._sort(newHeader);
}

TableSorter._sort = function(newHeader)
{
    TableSorter._updateHeaderClassNames(newHeader);
    
    var reversed = newHeader.classList.contains('reversed');
    var sortArrow = reversed ? TableSorter._backwardArrow : TableSorter._forwardArrow;
    newHeader.innerHTML = TableSorter._sortedContents(newHeader, sortArrow);
    
    TableSorter._sortRows(newHeader, reversed);
}

var PixelZoomer = {};

PixelZoomer.showOnDelay = true;
PixelZoomer._zoomFactor = 6;

var kResultWidth = 800;
var kResultHeight = 600;

var kZoomedResultWidth = kResultWidth * PixelZoomer._zoomFactor;
var kZoomedResultHeight = kResultHeight * PixelZoomer._zoomFactor;

PixelZoomer._zoomImageContainer = function(url)
{
    var container = document.createElement('div');
    container.className = 'zoom-image-container';

    var title = url.match(/\-([^\-]*)\.png/)[1];
    
    var label = document.createElement('div');
    label.className = 'label';
    label.appendChild(document.createTextNode(title));
    container.appendChild(label);
    
    var imageContainer = document.createElement('div');
    imageContainer.className = 'scaled-image-container';
    
    var image = new Image();
    image.src = url;
    image.style.width = kZoomedResultWidth + 'px';
    image.style.height = kZoomedResultHeight + 'px';
    image.style.border = '1px solid black';
    imageContainer.appendChild(image);
    container.appendChild(imageContainer);
    
    return container;
}

PixelZoomer._createContainer = function(e)
{
    var tbody = parentOfType(e.target, 'tbody');
    var row = tbody.querySelector('tr');
    var imageDiffLinks = row.querySelectorAll('a[href$=".png"]');
    
    var container = document.createElement('div');
    container.className = 'pixel-zoom-container';
    
    var html = '';
    
    var togglingImageLink = row.querySelector('a[href$="-diffs.html"]');
    if (togglingImageLink) {
        var prefix = togglingImageLink.getAttribute('data-prefix');
        container.appendChild(PixelZoomer._zoomImageContainer(prefix + '-expected.png'));
        container.appendChild(PixelZoomer._zoomImageContainer(prefix + '-actual.png'));
    }
    
    for (var i = 0; i < imageDiffLinks.length; i++)
        container.appendChild(PixelZoomer._zoomImageContainer(imageDiffLinks[i].href));

    document.body.appendChild(container);
    PixelZoomer._drawAll();
}

PixelZoomer._draw = function(imageContainer)
{
    var image = imageContainer.querySelector('img');
    var containerBounds = imageContainer.getBoundingClientRect();
    image.style.left = (containerBounds.width / 2 - PixelZoomer._percentX * kZoomedResultWidth) + 'px';
    image.style.top = (containerBounds.height / 2 - PixelZoomer._percentY * kZoomedResultHeight) + 'px';
}

PixelZoomer._drawAll = function()
{
    forEach(document.querySelectorAll('.pixel-zoom-container .scaled-image-container'), PixelZoomer._draw);
}

PixelZoomer.handleMouseOut = function(e)
{
    if (e.relatedTarget && e.relatedTarget.tagName != 'IFRAME')
        return;

    // If e.relatedTarget is null, we've moused out of the document.
    var container = document.querySelector('.pixel-zoom-container');
    if (container)
        remove(container);
}

PixelZoomer.handleMouseMove = function(e) {
    if (PixelZoomer._mouseMoveTimeout)
        clearTimeout(PixelZoomer._mouseMoveTimeout);

    if (parentOfType(e.target, '.pixel-zoom-container'))
        return;

    var container = document.querySelector('.pixel-zoom-container');
    
    var resultContainer = (e.target.className == 'result-container') ?
        e.target : parentOfType(e.target, '.result-container');
    if (!resultContainer || !resultContainer.querySelector('img')) {
        if (container)
            remove(container);
        return;
    }

    var targetLocation = e.target.getBoundingClientRect();
    PixelZoomer._percentX = (e.clientX - targetLocation.left) / targetLocation.width;
    PixelZoomer._percentY = (e.clientY - targetLocation.top) / targetLocation.height;

    if (!container) {
        if (PixelZoomer.showOnDelay) {
            PixelZoomer._mouseMoveTimeout = setTimeout(function() {
                PixelZoomer._createContainer(e);
            }, 400);
            return;
        }

        PixelZoomer._createContainer(e);
        return;
    }
    
    PixelZoomer._drawAll();
}

document.addEventListener('mousemove', PixelZoomer.handleMouseMove, false);
document.addEventListener('mouseout', PixelZoomer.handleMouseOut, false);

var TestNavigator = {};

TestNavigator.reset = function() {
    TestNavigator.currentTestIndex = -1;
    TestNavigator.flaggedTests = {};
}

TestNavigator.handleKeyEvent = function(event)
{
    if (event.metaKey || event.shiftKey || event.ctrlKey)
        return;

    switch (String.fromCharCode(event.charCode)) {
        case 'i':
            TestNavigator._scrollToFirstTest();
            break;
        case 'j':
            TestNavigator._scrollToNextTest();
            break;
        case 'k':
            TestNavigator._scrollToPreviousTest();
            break;
        case 'l':
            TestNavigator._scrollToLastTest();
            break;
        case 'e':
            TestNavigator._expandCurrentTest();
            break;
        case 'c':
            TestNavigator._collapseCurrentTest();
            break;
        case 't':
            TestNavigator._toggleCurrentTest();
            break;
        case 'f':
            TestNavigator._toggleCurrentTestFlagged();
            break;
    }
}

TestNavigator._scrollToFirstTest = function()
{
    if (TestNavigator._setCurrentTest(0))
        TestNavigator._scrollToCurrentTest();
}

TestNavigator._scrollToLastTest = function()
{
    var links = visibleTests();
    if (TestNavigator._setCurrentTest(links.length - 1))
        TestNavigator._scrollToCurrentTest();
}

TestNavigator._scrollToNextTest = function()
{
    if (TestNavigator.currentTestIndex == -1)
        TestNavigator._scrollToFirstTest();
    else if (TestNavigator._setCurrentTest(TestNavigator.currentTestIndex + 1))
        TestNavigator._scrollToCurrentTest();
}

TestNavigator._scrollToPreviousTest = function()
{
    if (TestNavigator.currentTestIndex == -1)
        TestNavigator._scrollToLastTest();
    else if (TestNavigator._setCurrentTest(TestNavigator.currentTestIndex - 1))
        TestNavigator._scrollToCurrentTest();
}

TestNavigator._currentTestLink = function()
{
    var links = visibleTests();
    return links[TestNavigator.currentTestIndex];
}

TestNavigator._currentTestExpandLink = function()
{
    return TestNavigator._currentTestLink().querySelector('.expand-button-text');
}

TestNavigator._expandCurrentTest = function()
{
    expandExpectations(TestNavigator._currentTestExpandLink());
}

TestNavigator._collapseCurrentTest = function()
{
    collapseExpectations(TestNavigator._currentTestExpandLink());
}

TestNavigator._toggleCurrentTest = function()
{
    toggleExpectations(TestNavigator._currentTestExpandLink());
}

TestNavigator._toggleCurrentTestFlagged = function()
{
    var testLink = TestNavigator._currentTestLink();
    TestNavigator.flagTest(testLink, !testLink.classList.contains('flagged'));
}

// FIXME: Test navigator shouldn't know anything about flagging. It should probably call out to TestFlagger or something.
TestNavigator.flagTest = function(testTbody, shouldFlag)
{
    var testName = testTbody.querySelector('.test-link').innerText;
    
    if (shouldFlag) {
        testTbody.classList.add('flagged');
        TestNavigator.flaggedTests[testName] = 1;
    } else {
        testTbody.classList.remove('flagged');
        delete TestNavigator.flaggedTests[testName];
    }

    TestNavigator.updateFlaggedTests();
}

TestNavigator.updateFlaggedTests = function()
{
    var flaggedTestTextbox = document.getElementById('flagged-tests');
    if (!flaggedTestTextbox) {
        var flaggedTestContainer = document.createElement('div');
        flaggedTestContainer.id = 'flagged-test-container';
        flaggedTestContainer.className = 'floating-panel';
        flaggedTestContainer.innerHTML = '<h2>Flagged Tests</h2><pre id="flagged-tests" contentEditable></pre>';
        document.body.appendChild(flaggedTestContainer);

        flaggedTestTextbox = document.getElementById('flagged-tests');
    }

    var flaggedTests = Object.keys(this.flaggedTests);
    flaggedTests.sort();
    var separator = document.getElementById('use-newlines').checked ? '\n' : ' ';
    flaggedTestTextbox.innerHTML = flaggedTests.join(separator);
    document.getElementById('flagged-test-container').style.display = flaggedTests.length ? '' : 'none';
}

TestNavigator._setCurrentTest = function(testIndex)
{
    var links = visibleTests();
    if (testIndex < 0 || testIndex >= links.length)
        return false;

    var currentTest = links[TestNavigator.currentTestIndex];
    if (currentTest)
        currentTest.classList.remove('current');

    TestNavigator.currentTestIndex = testIndex;

    currentTest = links[TestNavigator.currentTestIndex];
    currentTest.classList.add('current');

    return true;
}

TestNavigator._scrollToCurrentTest = function()
{
    var targetLink = TestNavigator._currentTestLink();
    if (!targetLink)
        return;

    var rowRect = targetLink.getBoundingClientRect();
    // rowRect is in client coords (i.e. relative to viewport), so we just want to add its top to the current scroll position.
    document.body.scrollTop += rowRect.top;
}

TestNavigator.onlyShowUnexpectedFailuresChanged = function()
{
    var currentTest = document.querySelector('.current');
    if (!currentTest)
        return;

    // If our currentTest became hidden, reset the currentTestIndex.
    if (onlyShowUnexpectedFailures() && currentTest.classList.contains('expected'))
        TestNavigator._scrollToFirstTest();
    else {
        // Recompute TestNavigator.currentTestIndex
        var links = visibleTests();
        TestNavigator.currentTestIndex = links.indexOf(currentTest);
    }
}

document.addEventListener('keypress', TestNavigator.handleKeyEvent, false);


function onlyShowUnexpectedFailures()
{
    return document.getElementById('unexpected-results').checked;
}

function handleUnexpectedResultsChange()
{
    OptionWriter.save();
    updateExpectedFailures();
}

function updateExpectedFailures()
{
    document.getElementById('unexpected-style').textContent = onlyShowUnexpectedFailures() ?
        '.expected { display: none; }' : '';

    updateTestlistCounts();
    TestNavigator.onlyShowUnexpectedFailuresChanged();
}

var OptionWriter = {};

OptionWriter._key = 'run-webkit-tests-options';

OptionWriter.save = function()
{
    var options = document.querySelectorAll('label input');
    var data = {};
    for (var i = 0, len = options.length; i < len; i++) {
        var option = options[i];
        data[option.id] = option.checked;
    }
    try {
        localStorage.setItem(OptionWriter._key, JSON.stringify(data));
    } catch (err) {
        if (err.name != "SecurityError")
            throw err;
    }
}

OptionWriter.apply = function()
{
    var json;
    try {
        json = localStorage.getItem(OptionWriter._key);
    } catch (err) {
       if (err.name != "SecurityError")
          throw err;
    }

    if (!json) {
        updateAllOptions();
        return;
    }

    var data = JSON.parse(json);
    for (var id in data) {
        var input = document.getElementById(id);
        if (input)
            input.checked = data[id];
    }
    updateAllOptions();
}

function updateAllOptions()
{
    forEach(document.querySelectorAll('#options-menu input'), function(input) { input.onchange(); });
}

function handleToggleUseNewlines()
{
    OptionWriter.save();
    TestNavigator.updateFlaggedTests();
}

function handleToggleImagesChange()
{
    OptionWriter.save();
    updateTogglingImages();
}

function updateTogglingImages()
{
    var shouldToggle = document.getElementById('toggle-images').checked;
    globalState().shouldToggleImages = shouldToggle;
    
    if (shouldToggle) {
        forEach(document.querySelectorAll('table:not(#missing-table) tbody:not([mismatchreftest]) a[href$=".png"]'), convertToTogglingHandler(function(prefix) {
            return resultLink(prefix, '-diffs.html', 'images');
        }));
        forEach(document.querySelectorAll('table:not(#missing-table) tbody:not([mismatchreftest]) img[src$=".png"]'), convertToTogglingHandler(togglingImage));
    } else {
        forEach(document.querySelectorAll('a[href$="-diffs.html"]'), convertToNonTogglingHandler(resultLink));
        forEach(document.querySelectorAll('.animatedImage'), convertToNonTogglingHandler(function (absolutePrefix, suffix) {
            return resultIframe(absolutePrefix + suffix);
        }));
    }

    updateImageTogglingTimer();
}

function getResultContainer(node)
{
    return (node.tagName == 'IMG') ? parentOfType(node, '.result-container') : node;
}

function convertToTogglingHandler(togglingImageFunction)
{
    return function(node) {
        var url = (node.tagName == 'IMG') ? node.src : node.href;
        if (url.match('-expected.png$'))
            remove(getResultContainer(node));
        else if (url.match('-actual.png$')) {
            var name = parentOfType(node, 'tbody').querySelector('.test-link').textContent;
            getResultContainer(node).outerHTML = togglingImageFunction(stripExtension(name));
        }
    }
}

function convertToNonTogglingHandler(resultFunction)
{
    return function(node) {
        var prefix = node.getAttribute('data-prefix');
        getResultContainer(node).outerHTML = resultFunction(prefix, '-expected.png', 'expected') + resultFunction(prefix, '-actual.png', 'actual');
    }
}

function toggleOptionsMenu()
{
    var menu = document.getElementById('options-menu');
    menu.className = (menu.className == 'hidden-menu') ? '' : 'hidden-menu';
}

function handleMouseDown(e)
{
    if (!parentOfType(e.target, '#options-menu') && e.target.id != 'options-link')
        document.getElementById('options-menu').className = 'hidden-menu';
}

document.addEventListener('mousedown', handleMouseDown, false);

function failingTestsTable(tests, title, id)
{
    if (!tests.length)
        return '';

    var numberofUnexpectedFailures = 0;
    var tableRowHtml = '';
    for (var i = 0; i < tests.length; i++){
        tableRowHtml += tableRow(tests[i]);
        if (!tests[i].isExpected)
            numberofUnexpectedFailures++;
    }

    var header = '<div';
    if (!hasUnexpected(tests))
        header += ' class=expected';

    header += '>' + testListHeaderHtml(title) +
        '<table id="' + id + '"><thead><tr>' +
        '<th>test</th>' +
        '<th id="text-results-header">results</th>' +
        '<th id="image-results-header">image results</th>';

    if (globalState().results.uses_expectations_file)
        header += '<th>actual failure</th><th>expected failure</th>';

    header += '<th><a href="' + flakinessDashboardURLForTests(tests) + '">history</a></th>';

    if (id == 'flaky-tests-table')
        header += '<th>failures</th>';

    header += '</tr></thead>';

    return header + tableRowHtml + '</table></div>';
}

function updateTitle()
{
    var dateString = globalState().results.date;
    
    var title = document.createElement('title');
    title.textContent = 'Layout Test Results from ' + dateString;
    document.head.appendChild(title);
}

function generatePage()
{
    updateTitle();
    forEachTest(processGlobalStateFor);
    forOtherCrashes();

    var html = "";

    if (globalState().results.interrupted)
        html += "<p class='stopped-running-early-message'>Testing exited early.</p>"

    if (globalState().crashTests.length)
        html += testList(globalState().crashTests, 'Tests that crashed', 'crash-tests-table');

    if (globalState().crashOther.length)
        html += testList(globalState().crashOther, 'Other Crashes', 'other-crash-tests-table');

    html += failingTestsTable(globalState().failingTests,
        'Tests that failed text/pixel/audio diff', 'results-table');

    html += failingTestsTable(globalState().missingResults,
        'Tests that had no expected results (probably new)', 'missing-table');

    if (globalState().timeoutTests.length)
        html += testList(globalState().timeoutTests, 'Tests that timed out', 'timeout-tests-table');

    if (globalState().testsWithStderr.length)
        html += testList(globalState().testsWithStderr, 'Tests that had stderr output', 'stderr-table');

    html += failingTestsTable(globalState().flakyPassTests,
        'Flaky tests (failed the first run and passed on retry)', 'flaky-tests-table');

    if (globalState().results.uses_expectations_file && globalState().unexpectedPassTests.length)
        html += testList(globalState().unexpectedPassTests, 'Tests expected to fail but passed', 'passes-table');

    if (globalState().hasHttpTests) {
        html += '<p>httpd access log: <a href="access_log.txt">access_log.txt</a></p>' +
            '<p>httpd error log: <a href="error_log.txt">error_log.txt</a></p>';
    }

    document.getElementById('main-content').innerHTML = html + '</div>';

    if (document.getElementById('results-table')) {
        document.getElementById('results-table').addEventListener('click', TableSorter.handleClick, false);
        TableSorter.sortColumn(0);
        if (!globalState().results.uses_expectations_file)
            parentOfType(document.getElementById('unexpected-results'), 'label').style.display = 'none';
        if (!globalState().hasTextFailures)
            document.getElementById('text-results-header').textContent = '';
        if (!globalState().hasImageFailures) {
            document.getElementById('image-results-header').textContent = '';
            parentOfType(document.getElementById('toggle-images'), 'label').style.display = 'none';
        }
    }

    updateTestlistCounts();

    TestNavigator.reset();
    OptionWriter.apply();
}
</script>
<body onload="generatePage()">
    
    <div class="content-container">
        <div id="toolbar" class="floating-panel">
        <div class="note">Use the i, j, k and l keys to navigate, e, c to expand and collapse, and f to flag</div>
        <a href="javascript:void()" onclick="expandAllExpectations()">expand all</a>
        <a href="javascript:void()" onclick="collapseAllExpectations()">collapse all</a>
        <a href="javascript:void()" id=options-link onclick="toggleOptionsMenu()">options</a>
        <div id="options-menu" class="hidden-menu">
            <label><input id="unexpected-results" type="checkbox" checked onchange="handleUnexpectedResultsChange()">Only unexpected results</label>
            <label><input id="toggle-images" type="checkbox" checked onchange="handleToggleImagesChange()">Toggle images</label>
            <label title="Use newlines instead of spaces to separate flagged tests"><input id="use-newlines" type="checkbox" checked onchange="handleToggleUseNewlines()">Use newlines in flagged list</input>
        </div>
    </div>

<div id="main-content"></div>

</body>