tor-browser

markup.js (10392B)

---

/* import-globals-from ../attributes.js */
/* import-globals-from ../common.js */
/* import-globals-from ../events.js */
/* import-globals-from ../name.js */

// //////////////////////////////////////////////////////////////////////////////
// Name tests described by "markuprules.xml" file.

var gNameRulesFileURL = "markuprules.xml";

var gRuleDoc = null;

// Debuggin stuff.
var gDumpToConsole = false;

/**
* Start name tests. Run through markup elements and test names for test
* element (see namerules.xml for details).
*/
function testNames() {
 // enableLogging("tree,stack"); // debugging

 var request = new XMLHttpRequest();
 request.open("get", gNameRulesFileURL, false);
 request.send();

 gRuleDoc = request.responseXML;

 var markupElms = evaluateXPath(gRuleDoc, "//rules/rulesample/markup");
 gTestIterator.iterateMarkups(markupElms);
}

// //////////////////////////////////////////////////////////////////////////////
// Private section.

/**
* Helper class to interate through name tests.
*/
var gTestIterator = {
 iterateMarkups: function gTestIterator_iterateMarkups(aMarkupElms) {
   this.markupElms = aMarkupElms;

   this.iterateNext();
 },

 iterateRules: function gTestIterator_iterateRules(
   aElm,
   aContainer,
   aRuleSetElm,
   aRuleElms,
   aTestID
 ) {
   this.ruleSetElm = aRuleSetElm;
   this.ruleElms = aRuleElms;
   this.elm = aElm;
   this.container = aContainer;
   this.testID = aTestID;

   this.iterateNext();
 },

 iterateNext: function gTestIterator_iterateNext() {
   if (this.markupIdx == -1) {
     this.markupIdx++;
     testNamesForMarkup(this.markupElms[this.markupIdx]);
     return;
   }

   this.ruleIdx++;
   if (this.ruleIdx == this.ruleElms.length) {
     // When test is finished then name is empty and no explicit-name.
     var defaultName = this.ruleSetElm.hasAttribute("defaultName")
       ? this.ruleSetElm.getAttribute("defaultName")
       : null;
     testName(
       this.elm,
       defaultName,
       "Default name test (" + gTestIterator.testID + "). "
     );
     testAbsentAttrs(this.elm, { "explicit-name": "true" });

     this.markupIdx++;
     if (this.markupIdx == this.markupElms.length) {
       // disableLogging("tree"); // debugging
       SimpleTest.finish();
       return;
     }

     this.ruleIdx = -1;

     if (gDumpToConsole) {
       dump(
         "\nPend next markup processing. Wait for reorder event on " +
           prettyName(document) +
           "'\n"
       );
     }
     waitForEvent(
       EVENT_REORDER,
       document,
       testNamesForMarkup,
       null,
       this.markupElms[this.markupIdx]
     );

     document.body.removeChild(this.container);
     return;
   }

   testNameForRule(this.elm, this.ruleElms[this.ruleIdx]);
 },

 markupElms: null,
 markupIdx: -1,
 rulesetElm: null,
 ruleElms: null,
 ruleIdx: -1,
 elm: null,
 container: null,
 testID: "",
};

/**
* Process every 'markup' element and test names for it. Used by testNames
* function.
*/
function testNamesForMarkup(aMarkupElm) {
 if (gDumpToConsole) {
   dump("\nProcessing markup '" + aMarkupElm.getAttribute("id") + "'\n");
 }

 var div = document.createElement("div");
 div.setAttribute("id", "test");

 var child = aMarkupElm.firstChild;
 while (child) {
   var newChild = document.importNode(child, true);
   div.appendChild(newChild);
   child = child.nextSibling;
 }

 if (gDumpToConsole) {
   dump(
     "\nProcessing markup. Wait for reorder event on " +
       prettyName(document) +
       "'\n"
   );
 }
 waitForEvent(
   EVENT_REORDER,
   document,
   testNamesForMarkupRules,
   null,
   aMarkupElm,
   div
 );

 document.body.appendChild(div);
}

function testNamesForMarkupRules(aMarkupElm, aContainer) {
 var testID = aMarkupElm.getAttribute("id");
 if (gDumpToConsole) {
   dump("\nProcessing markup rules '" + testID + "'\n");
 }

 var expr = "//html/body/div[@id='test']/" + aMarkupElm.getAttribute("ref");
 var elm = evaluateXPath(document, expr, htmlDocResolver)[0];

 var ruleId = aMarkupElm.getAttribute("ruleset");
 var ruleElm = gRuleDoc.querySelector("[id='" + ruleId + "']");
 var ruleElms = getRuleElmsByRulesetId(ruleId);

 var processMarkupRules = gTestIterator.iterateRules.bind(
   gTestIterator,
   elm,
   aContainer,
   ruleElm,
   ruleElms,
   testID
 );

 // Images may be recreated after we append them into subtree. We need to wait
 // in this case. If we are on profiling enabled build then stack tracing
 // works and thus let's log instead. Note, that works if you enabled logging
 // (refer to testNames() function).
 if (isAccessible(elm) || isLogged("stack")) {
   processMarkupRules();
 } else {
   waitForEvent(EVENT_SHOW, elm, processMarkupRules);
 }
}

/**
* Test name for current rule and current 'markup' element. Used by
* testNamesForMarkup function.
*/
function testNameForRule(aElm, aRuleElm) {
 if (aRuleElm.hasAttribute("attr")) {
   if (gDumpToConsole) {
     dump(
       "\nProcessing rule { attr: " + aRuleElm.getAttribute("attr") + " }\n"
     );
   }

   testNameForAttrRule(aElm, aRuleElm);
 } else if (aRuleElm.hasAttribute("elm")) {
   if (gDumpToConsole) {
     dump(
       "\nProcessing rule { elm: " +
         aRuleElm.getAttribute("elm") +
         ", elmattr: " +
         aRuleElm.getAttribute("elmattr") +
         " }\n"
     );
   }

   testNameForElmRule(aElm, aRuleElm);
 } else if (aRuleElm.getAttribute("fromsubtree") == "true") {
   if (gDumpToConsole) {
     dump(
       "\nProcessing rule { fromsubtree: " +
         aRuleElm.getAttribute("fromsubtree") +
         " }\n"
     );
   }

   testNameForSubtreeRule(aElm, aRuleElm);
 }
}

function testNameForAttrRule(aElm, aRule) {
 var name = "";

 var attr = aRule.getAttribute("attr");
 var attrValue = aElm.getAttribute(attr);

 var type = aRule.getAttribute("type");
 if (type == "string") {
   name = attrValue;
 } else if (type == "ref" && attrValue) {
   var ids = attrValue.split(/\s+/);
   for (var idx = 0; idx < ids.length; idx++) {
     var labelElm = getNode(ids[idx]);
     if (name != "") {
       name += " ";
     }

     name += labelElm.getAttribute("textequiv");
   }
 }

 var msg = "Attribute '" + attr + "' test (" + gTestIterator.testID + "). ";
 testName(aElm, name, msg);

 if (aRule.getAttribute("explicit-name") != "false") {
   testAttrs(aElm, { "explicit-name": "true" }, true);
 } else {
   testAbsentAttrs(aElm, { "explicit-name": "true" });
 }

 waitForEvent(
   EVENT_NAME_CHANGE,
   aElm,
   gTestIterator.iterateNext,
   gTestIterator
 );

 aElm.removeAttribute(attr);
}

function testNameForElmRule(aElm, aRule) {
 var labelElm;

 var tagname = aRule.getAttribute("elm");
 var attrname = aRule.getAttribute("elmattr");
 if (attrname) {
   var filter = {
     acceptNode: function filter_acceptNode(aNode) {
       if (
         aNode.localName == this.mLocalName &&
         aNode.getAttribute(this.mAttrName) == this.mAttrValue
       ) {
         return NodeFilter.FILTER_ACCEPT;
       }

       return NodeFilter.FILTER_SKIP;
     },

     mLocalName: tagname,
     mAttrName: attrname,
     mAttrValue: aElm.getAttribute("id"),
   };

   var treeWalker = document.createTreeWalker(
     document.body,
     NodeFilter.SHOW_ELEMENT,
     filter
   );
   labelElm = treeWalker.nextNode();
 } else {
   // if attrname is empty then look for the element in subtree.
   labelElm = aElm.getElementsByTagName(tagname)[0];
   if (!labelElm) {
     labelElm = aElm.getElementsByTagName("html:" + tagname)[0];
   }
 }

 if (!labelElm) {
   ok(false, msg + " Failed to find '" + tagname + "' element.");
   gTestIterator.iterateNext();
   return;
 }

 var msg = "Element '" + tagname + "' test (" + gTestIterator.testID + ").";
 testName(aElm, labelElm.getAttribute("textequiv"), msg);
 testAttrs(aElm, { "explicit-name": "true" }, true);

 var parentNode = labelElm.parentNode;

 if (gDumpToConsole) {
   dump(
     "\nProcessed elm rule. Wait for name change event on " +
       prettyName(aElm) +
       "\n"
   );
 }
 waitForEvent(
   EVENT_NAME_CHANGE,
   aElm,
   gTestIterator.iterateNext,
   gTestIterator
 );

 parentNode.removeChild(labelElm);
}

function testNameForSubtreeRule(aElm) {
 var msg = "From subtree test (" + gTestIterator.testID + ").";
 testName(aElm, aElm.getAttribute("textequiv"), msg);
 testAbsentAttrs(aElm, { "explicit-name": "true" });

 if (gDumpToConsole) {
   dump(
     "\nProcessed from subtree rule. Wait for name change event on " +
       prettyName(aElm) +
       "\n"
   );
 }
 waitForEvent(
   EVENT_NAME_CHANGE,
   aElm,
   gTestIterator.iterateNext,
   gTestIterator
 );

 while (aElm.firstChild) {
   aElm.firstChild.remove();
 }
}

/**
* Return array of 'rule' elements. Used in conjunction with
* getRuleElmsFromRulesetElm() function.
*/
function getRuleElmsByRulesetId(aRulesetId) {
 var expr = "//rules/ruledfn/ruleset[@id='" + aRulesetId + "']";
 var rulesetElm = evaluateXPath(gRuleDoc, expr);
 return getRuleElmsFromRulesetElm(rulesetElm[0]);
}

function getRuleElmsFromRulesetElm(aRulesetElm) {
 var rulesetId = aRulesetElm.getAttribute("ref");
 if (rulesetId) {
   return getRuleElmsByRulesetId(rulesetId);
 }

 var ruleElms = [];

 var child = aRulesetElm.firstChild;
 while (child) {
   if (child.localName == "ruleset") {
     ruleElms = ruleElms.concat(getRuleElmsFromRulesetElm(child));
   }
   if (child.localName == "rule") {
     ruleElms.push(child);
   }

   child = child.nextSibling;
 }

 return ruleElms;
}

/**
* Helper method to evaluate xpath expression.
*/
function evaluateXPath(aNode, aExpr, aResolver) {
 var xpe = new XPathEvaluator();

 var resolver = aResolver;
 if (!resolver) {
   var node =
     aNode.ownerDocument == null
       ? aNode.documentElement
       : aNode.ownerDocument.documentElement;
   resolver = xpe.createNSResolver(node);
 }

 var result = xpe.evaluate(aExpr, aNode, resolver, 0, null);
 var found = [];
 var res;
 while ((res = result.iterateNext())) {
   found.push(res);
 }

 return found;
}

function htmlDocResolver(aPrefix) {
 var ns = {
   html: "http://www.w3.org/1999/xhtml",
 };
 return ns[aPrefix] || null;
}