var notify = [];
var experimentIdCounter = 0;
/**
* The questions above are answered by running a bunch of experiments
* exhaustively for all combinations of HTML element names.
*
* @param makeHtmlString takes one or more element names.
* Its {@code length} property specifies its arity, and runExperiment
* calls it iteratively with every permutation of length element names.
* @param checkDom receives the element names passed to makeHtmlString,
* an HTML document body created by parsing the HTML from makeHtmlString
* and initialResult/return value from last call to checkDom.
* @param initialResult the first result value to pass to checkDom.
* @param opt_elementNames an array of element names which defaults to
* window.elementNames.
*/
function runExperiment(makeHtmlString, checkDom, initialResult, onResult,
opt_elementNames) {
var experimentIndex = ++experimentIdCounter;
var iframes = document.getElementById('experiment-iframes');
var iframe = document.createElement('iframe');
iframes.appendChild(iframe);
var elementNames = opt_elementNames || window.elementNames;
var nElements = elementNames.length;
var arity = makeHtmlString.length;
var nRuns = Math.pow(nElements, arity);
var runIndex = 0;
var paramIndices = new Array(arity);
var paramValues = new Array(arity);
for (var i = 0; i < arity; ++i) {
paramIndices[i] = 0;
paramValues[i] = elementNames[0];
}
var exhausted = nRuns === 0;
var progressCounterContainer =
document.getElementById('experiment-progress-counter');
var startTime = Date.now();
var lastProgressUpdateTime = startTime;
var result = initialResult;
var progressCounter;
if (progressCounterContainer) {
progressCounter = document.createElement('li');
progressCounter.style.width = '0';
progressCounterContainer.appendChild(progressCounter);
}
function advance() {
// Advance to next permutation.
var i;
for (i = arity; --i >= 0;) {
if (++paramIndices[i] < nElements) {
paramValues[i] = elementNames[paramIndices[i]];
break;
}
paramIndices[i] = 0;
paramValues [i] = elementNames[0];
}
++runIndex;
if (progressCounter) {
var now = Date.now();
if (now - lastProgressUpdateTime > 250 ) {
var ratio = runIndex / nRuns;
progressCounter.style.width = (100 * ratio).toFixed(2) + '%';
lastProgressUpdateTime = now;
var timeSoFar = now - startTime;
if (timeSoFar > 5000) {
// Assuming time per run is constant:
// total_time / nRuns = time_so_far / runIndex
// total_time = time_so_far * nRuns / runIndex
// = time_so_far / ratio
// eta = total_time - time_so_far
// = time_so_far / ratio - time_so_far
// = time_so_far * (1/ratio - 1)
var eta = timeSoFar * (1 / ratio - 1);
progressCounter.innerHTML = eta > 250
? 'ETA:' + (eta / 1000).toFixed(1) + 's' : '';
}
}
}
exhausted = i < 0;
}
function step() {
var htmlString = null;
// Try to generate an HTML string.
// The maker can return a nullish value to abort or punt on an experiment,
// so we loop until we find work to do.
while (!exhausted) {
paramValues.length = arity;
htmlString = makeHtmlString.apply(null, paramValues);
if (htmlString != null) {
break;
}
advance();
}
if (htmlString == null) {
var endTime = Date.now();
console.log('experiment took %d millis for %d runs',
(endTime - startTime), nRuns);
if (progressCounter) {
setTimeout(function () {
iframes.removeChild(iframe);
progressCounterContainer.removeChild(progressCounter);
}, 250);
}
onResult(result);
} else {
var notifyIndex = notify.indexOf(void 0);
if (notifyIndex < 0) { notifyIndex = notify.length; }
notify[notifyIndex] = function () {
notify[notifyIndex] = void 0;
// Process result
paramValues[arity] = iframe.contentDocument.body;
paramValues[arity + 1] = result;
result = checkDom.apply(null, paramValues);
paramValues.length = arity;
// Requeue the next step on the parent frames event queue.
setTimeout(function () { advance(); step(); }, 0);
};
// Start the iframe parsing its body.
iframe.srcdoc = (
'<!doctype html><html><head></head>'
+ '<body onload="parent.notify[' + notifyIndex + ']()">'
+ htmlString
);
}
}
step();
}
function formatDataToJsonHTML(data) {
var out = [];
var htmlForNullValue = '<span class="json-kw">null</span>';
var htmlForErrorValue = '<span class="json-kw json-err">null</span>';
var depth = 0;
var spaces = ' ';
format(data);
return out.join('');
function format(v) {
if (v == null) {
out.push(htmlForNullValue);
return;
}
var t = typeof v;
if (t === 'boolean') {
out.push('<span class="json-kw">', v, '</span>');
} else if (t === 'number') {
if (isFinite(v)) {
out.push('<span class="json-val">', v, '</span>');
} else {
out.push(htmlForErrorValue);
}
} else if (t === 'string' || v instanceof String) {
var token = JSON.stringify(String(v));
token = token.replace(/&/g, '&').replace(/</g, '<');
out.push('<span class="json-str">', token, '</span>');
} else {
var length = v.length;
var isSeries = ('number' === typeof length
&& length === (length & 0x7fffffff));
// Don't put properties on their own line if there are only a few.
var inlinePropLimit = isSeries ? 8 : 4;
var inline = true;
var numProps = 0;
for (var k in v) {
if (!Object.hasOwnProperty.call(v, k)) { continue; }
var propValue = v[k];
if ((propValue != null && typeof propValue == 'object')
|| ++numProps > inlinePropLimit) {
inline = false;
break;
}
}
// Put the appropriate white-space inside brackets and after commas.
function maybeIndent(afterComma) {
if (inline) {
if (afterComma) { out.push(' '); }
} else {
out.push('\n');
var nSpaces = depth * 2;
while (nSpaces > 0) {
var nToPush = Math.min(nSpaces, spaces.length);
out.push(spaces.substring(0, nToPush));
nSpaces -= nToPush;
}
}
}
var onclick = depth
? ' onclick="return toggleJsonBlock(this, event)"'
: '';
// Mark blocks so that we can do expandos on collections.
out.push('<span class="json-ext json-block-', depth,
depth === 0 || inline ? ' json-nocollapse' : '',
'"', onclick, '>',
isSeries ? '[' : '{',
// Emit link-like ellipses that can serve as a button for
// expando-ness.
'<span class="json-ell">…</span>',
'<span class="json-int">');
++depth;
if (isSeries) {
for (var i = 0; i < length; ++i) {
if (i) { out.push(','); }
maybeIndent(i !== 0);
format(v[i]);
}
} else {
var needsComma = false;
for (var k in v) {
if (!Object.hasOwnProperty.call(v, k)) { continue; }
if (needsComma) {
out.push(',');
}
maybeIndent(needsComma);
out.push('<span class="json-prop">');
format(String(k));
out.push(': ');
format(v[k]);
out.push('</span>');
needsComma = true;
}
}
--depth;
maybeIndent(false);
out.push('</span>', isSeries ? ']' : '}', '</span>');
}
}
}
function displayJson(data, container) {
container.innerHTML = formatDataToJsonHTML(data);
}
function toggleJsonBlock(el, event) {
event && event.stopPropagation && event.stopPropagation();
var className = el.className;
var classNameCollapsed = className.replace(/\bjson-expanded\b/g, '');
className = className === classNameCollapsed
? className + ' json-expanded' : classNameCollapsed;
className = className.replace(/^ +| +$| +( [^ ])/g, "$1");
el.className = className;
return false;
}
function Promise() {
if (!(this instanceof Promise)) { return new Promise(); }
this.paused = [];
this.satisfy = function () {
var paused = this.paused;
console.log('satisfying ' + paused.length);
for (var i = 0, n = paused.length; i < n; ++i) {
setTimeout(paused[i], 0);
}
this.paused.length = 0;
};
}
Promise.prototype.toString = function () { return "Promise"; };
function when(f, var_args) {
var unsatisfied = [];
for (var i = 1, n = arguments.length; i < n; ++i) {
var argument = arguments[i];
if (argument instanceof Promise) {
unsatisfied.push(argument);
}
}
var nToWaitFor = unsatisfied.length;
if (nToWaitFor) {
var pauser = function pauser() {
if (!--nToWaitFor) {
setTimeout(f, 0);
}
};
for (var j = 0; j < nToWaitFor; ++j) {
unsatisfied[j].paused.push(pauser);
}
unsatisfied = null;
} else {
setTimeout(f, 0);
}
}
function newBlankObject() {
return (Object.create || Object)(null);
}
function getOwn(o, k, opt_default) {
return Object.hasOwnProperty.call(o, k) ? o[k] : opt_default;
}
function breadthFirstSearch(start, isEnd, eq, adjacent) {
var stack = [{ node: start, next: null }];
while (stack.length) {
var candidate = stack.shift();
if (isEnd(candidate.node)) {
var path = [candidate.node];
while (candidate.next) {
candidate = candidate.next;
path.push(candidate.node);
}
return path;
}
var adjacentNodes = adjacent(candidate.node);
adj:
for (var i = 0, n = adjacentNodes.length; i < n; ++i) {
var adjacentNode = adjacentNodes[i];
for (var dupe = candidate; dupe; dupe = dupe.next) {
if (eq(dupe.node, adjacentNode)) { continue adj; }
}
stack.push({ node: adjacentNode, next: candidate });
}
}
return null;
}
function reverseMultiMap(multimap) {
var reverse = newBlankObject();
for (var k in multimap) {
if (Object.hasOwnProperty.call(multimap, k)) {
var values = multimap[k];
for (var i = 0, n = values.length; i < n; ++i) {
var value = values[i];
var reverseKeys = getOwn(reverse, value) || [];
reverse[value] = reverseKeys;
reverseKeys.push(k);
}
}
}
return reverse;
}
function innerTextOf(element) {
function appendTextOf(node, out) {
switch (node.nodeType) {
case 1: // Element
for (var c = node.firstChild; c; c = c.nextSibling) {
appendTextOf(c, out);
}
break;
case 3: case 4: case 6: // Text / CDATA / Entity
out.push(node.nodeValue);
break;
}
}
var buf = [];
if (element) { appendTextOf(element, buf); }
return buf.join('');
}
function sortedMultiMap(mm) {
var props = [];
for (var k in mm) {
if (!Object.hasOwnProperty.call(mm, k)) { continue; }
var v = mm[k];
if (v instanceof Array) {
v = v.slice();
v.sort();
}
props.push([k, v]);
}
props.sort(
function (a, b) {
a = a[0];
b = b[0];
if (a < b) { return -1; }
if (b < a) { return 1; }
return 0;
});
var sorted = newBlankObject();
for (var i = 0, n = props.length; i < n; ++i) {
var prop = props[i];
sorted[prop[0]] = prop[1];
}
return sorted;
}
function makeSet(strs) {
var s = newBlankObject();
for (var i = 0, n = strs.length; i < n; ++i) {
s[strs[i]] = s;
}
return s;
}
function inSet(s, str) {
return s[str] === s;
}
function elementContainsComment(el) {
return elementContainsNodeOfType(el, 8);
}
function elementContainsText(el) {
return elementContainsNodeOfType(el, 3);
}
function elementContainsNodeOfType(el, nodeType) {
if (el) {
for (var c = el.firstChild; c; c = c.nextSibling) {
if (c.nodeType === nodeType) { return true; }
}
return false;
}
}