--- a/accessible/jsat/AccessFu.jsm
+++ b/accessible/jsat/AccessFu.jsm
@@ -883,17 +883,17 @@ var Input = {
   },
 
   sendContextMenuMessage: function sendContextMenuMessage() {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
     mm.sendAsyncMessage("AccessFu:ContextMenu", {});
   },
 
   setEditState: function setEditState(aEditState) {
-    Logger.debug(() => { return ["setEditState", JSON.stringify(aEditState)] });
+    Logger.debug(() => { return ["setEditState", JSON.stringify(aEditState)]; });
     this.editState = aEditState;
   },
 
   // XXX: This is here for backwards compatability with screen reader simulator
   // it should be removed when the extension is updated on amo.
   scroll: function scroll(aPage, aHorizontal) {
     this.sendScrollMessage(aPage, aHorizontal);
   },

--- a/accessible/jsat/EventManager.jsm
+++ b/accessible/jsat/EventManager.jsm
@@ -475,17 +475,17 @@ this.EventManager.prototype = {
         return liveAttrs;
       }
       let parent = aEvent.targetParent;
       while (parent) {
         liveAttrs = parseLiveAttrs(parent);
         if (liveAttrs) {
           return liveAttrs;
         }
-        parent = parent.parent
+        parent = parent.parent;
       }
       return {};
     };
     let {live, relevant, /* busy, atomic, memberOf */ } = getLiveAttributes(aEvent);
     // If container-live is not present or is set to |off| ignore the event.
     if (!live || live === "off") {
       return {};
     }
@@ -507,17 +507,17 @@ this.EventManager.prototype = {
     let domNode = aLiveRegion.DOMNode;
     if (this._liveEventQueue && this._liveEventQueue.has(domNode)) {
       let queue = this._liveEventQueue.get(domNode);
       let nextEvent = queue[0];
       if (nextEvent.eventType === aEventType) {
         Utils.win.clearTimeout(nextEvent.timeoutID);
         queue.shift();
         if (queue.length === 0) {
-          this._liveEventQueue.delete(domNode)
+          this._liveEventQueue.delete(domNode);
         }
       }
     }
   },
 
   _queueLiveEvent: function _queueLiveEvent(aEventType, aLiveRegion, aIsPolite, aModifiedText) {
     if (!this._liveEventQueue) {
       this._liveEventQueue = new WeakMap();

--- a/accessible/tests/mochitest/actions.js
+++ b/accessible/tests/mochitest/actions.js
@@ -128,41 +128,41 @@ function actionInvoker(aAccOrElmOrId, aA
        "Wrong action name of the accessible for " + prettyName(aAccOrElmOrId));
 
     try {
       acc.doAction(aActionIndex);
     } catch (e) {
       ok(false, "doAction(" + aActionIndex + ") failed with: " + e.name);
       return INVOKER_ACTION_FAILED;
     }
-  }
+  };
 
   this.eventSeq = aEventSeq;
 
   this.getID = function actionInvoker_getID() {
     return "invoke an action " + aActionName + " at index " + aActionIndex +
       " on " + prettyName(aAccOrElmOrId);
-  }
+  };
 }
 
 function checkerOfActionInvoker(aType, aTarget, aActionObj) {
   this.type = aType;
 
   this.target = aTarget;
 
   this.phase = false;
 
   this.getID = function getID() {
     return aType + " event handling";
-  }
+  };
 
   this.check = function check(aEvent) {
     if (aActionObj && "checkOnClickEvent" in aActionObj)
       aActionObj.checkOnClickEvent(aEvent);
-  }
+  };
 }
 
 var gActionDescrMap =
 {
   jump: "Jump",
   press: "Press",
   check: "Check",
   uncheck: "Uncheck",

--- a/accessible/tests/mochitest/actions/test_anchors.html
+++ b/accessible/tests/mochitest/actions/test_anchors.html
@@ -21,17 +21,17 @@
     // //////////////////////////////////////////////////////////////////////////
     // Event checkers
 
     function scrollingChecker(aAcc) {
       this.type = EVENT_SCROLLING_START;
       this.target = aAcc;
       this.getID = function scrollingChecker_getID() {
         return "scrolling start handling for " + prettyName(aAcc);
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Test
 
     // gA11yEventDumpID = "debug"; // debug stuff
     // gA11yEventDumpToConsole = true; // debug stuff
 

--- a/accessible/tests/mochitest/actions/test_link.html
+++ b/accessible/tests/mochitest/actions/test_link.html
@@ -38,21 +38,21 @@
       this.type = EVENT_DOCUMENT_LOAD_COMPLETE;
       this.__defineGetter__("target", getAnchorTargetDocumentAcc);
 
       this.check = function linkChecker_check() {
         var anchorTargetWindow =
           getAccessible(getAnchorTargetDocumentAcc(), [nsIAccessibleDocument]).
           window;
         anchorTargetWindow.close();
-      }
+      };
 
       this.getID = function linkChecker_getID() {
         return "link '" + aID + "' states check ";
-      }
+      };
     }
 
     // gA11yEventDumpToConsole = true;
     // enableLogging("tree,eventTree,verbose");
 
     function doTest() {
       var actionsArray = [
         {

--- a/accessible/tests/mochitest/actions/test_media.html
+++ b/accessible/tests/mochitest/actions/test_media.html
@@ -26,32 +26,32 @@ https://bugzilla.mozilla.org/show_bug.cg
     // gA11yEventDumpID = "eventDump";
     // gA11yEventDumpToConsole = true; // debug stuff
 
     function focusChecker(aAcc) {
       this.type = EVENT_FOCUS;
       this.target = aAcc;
       this.getID = function focusChecker_getID() {
         return "focus handling";
-      }
+      };
       this.check = function focusChecker_check(aEvent) {
         testStates(this.target, STATE_FOCUSED);
-      }
+      };
     }
 
     function nameChecker(aAcc, aName) {
       this.type = EVENT_NAME_CHANGE;
       this.target = aAcc;
       this.getID = function nameChecker_getID() {
         return "name change handling";
       },
       this.check = function nameChecker_check(aEvent) {
         is(aEvent.accessible.name, aName,
            "Wrong name of " + prettyName(aEvent.accessible) + " on focus");
-      }
+      };
     }
 
     function doTest() {
       // ////////////////////////////////////////////////////////////////////////
       // test actions of audio controls
 
       todo(false, "Focus test are disabled until bug 494175 is fixed.");
 

--- a/accessible/tests/mochitest/attributes.js
+++ b/accessible/tests/mochitest/attributes.js
@@ -203,36 +203,36 @@ function testTextAttrsWrongOffset(aID, a
     res = true;
   }
 
   ok(res,
      "text attributes are calculated successfully at wrong offset " + aOffset + " for " + prettyName(aID));
 }
 
 const kNormalFontWeight =
-  function equalsToNormal(aWeight) { return aWeight <= 400 ; }
+  function equalsToNormal(aWeight) { return aWeight <= 400 ; };
 
 const kBoldFontWeight =
-  function equalsToBold(aWeight) { return aWeight > 400; }
+  function equalsToBold(aWeight) { return aWeight > 400; };
 
 // The pt font size of the input element can vary by Linux distro.
 const kInputFontSize = WIN ?
   "10pt" : (MAC ? "8pt" : function() { return true; });
 
 const kAbsentFontFamily =
-  function(aFontFamily) { return aFontFamily != "sans-serif"; }
+  function(aFontFamily) { return aFontFamily != "sans-serif"; };
 const kInputFontFamily =
-  function(aFontFamily) { return aFontFamily != "sans-serif"; }
+  function(aFontFamily) { return aFontFamily != "sans-serif"; };
 
 const kMonospaceFontFamily =
-  function(aFontFamily) { return aFontFamily != "monospace"; }
+  function(aFontFamily) { return aFontFamily != "monospace"; };
 const kSansSerifFontFamily =
-  function(aFontFamily) { return aFontFamily != "sans-serif"; }
+  function(aFontFamily) { return aFontFamily != "sans-serif"; };
 const kSerifFontFamily =
-  function(aFontFamily) { return aFontFamily != "serif"; }
+  function(aFontFamily) { return aFontFamily != "serif"; };
 
 const kCursiveFontFamily = LINUX ? "DejaVu Serif" : "Comic Sans MS";
 
 /**
  * Return used font from the given computed style.
  */
 function fontFamily(aComputedStyle) {
   var name = aComputedStyle.fontFamily;

--- a/accessible/tests/mochitest/attributes/test_obj.html
+++ b/accessible/tests/mochitest/attributes/test_obj.html
@@ -132,17 +132,17 @@ https://bugzilla.mozilla.org/show_bug.cg
       testAbsentAttrs("th3", { "abbr": "" }, true);
 
       // application accessible
       if (WIN) {
         var gfxInfo = Components.classes["@mozilla.org/gfx/info;1"].
           getService(Components.interfaces.nsIGfxInfo);
         var attrs = {
           "D2D": (gfxInfo.D2DEnabled ? "true" : "false")
-        }
+        };
         testAttrs(getApplicationAccessible(), attrs, false);
       }
 
       // no object attributes
       testAbsentAttrs(getAccessible("listitem").firstChild, { "tag": "" });
 
       // experimental aria
       testAttrs("experimental", {"blah": "true"}, true);

--- a/accessible/tests/mochitest/attributes/test_obj_css.html
+++ b/accessible/tests/mochitest/attributes/test_obj_css.html
@@ -22,25 +22,25 @@
       this.accessible = getAccessible(aID);
 
       this.eventSeq = [
         new invokerChecker(EVENT_HIDE, this.accessible)
       ];
 
       this.invoke = function removeElm_invoke() {
         this.node.remove();
-      }
+      };
 
       this.check = function removeElm_check() {
         testAbsentCSSAttrs(this.accessible);
-      }
+      };
 
       this.getID = function removeElm_getID() {
         return "test CSS-based attributes on removed accessible";
-      }
+      };
     }
 
     function doTest() {
       // CSS display
       testCSSAttrs("display_block");
       testCSSAttrs("display_inline");
       testCSSAttrs("display_inline-block");
       testCSSAttrs("display_list-item");

--- a/accessible/tests/mochitest/autocomplete.js
+++ b/accessible/tests/mochitest/autocomplete.js
@@ -81,17 +81,17 @@ ResultsHeap.prototype =
     for (var idx = 0; idx < this.values.length; idx++) {
       if (this.values[idx].indexOf(aSearchString) != -1) {
         values.push(this.values[idx]);
         comments.push(this.comments[idx]);
       }
     }
     return new AutoCompleteResult(values, comments);
   }
-}
+};
 
 
 /**
  * nsIAutoCompleteSearch implementation.
  *
  * @param aName       [in] the name of autocomplete search
  * @param aAllResults [in] ResultsHeap object
  */
@@ -128,17 +128,17 @@ AutoCompleteSearch.prototype =
     return this.QueryInterface(iid);
   },
 
   // Search name. Used by AutoCompleteController.
   name: null,
 
   // Results heap.
   allResults: null
-}
+};
 
 
 /**
  * nsIAutoCompleteResult implementation.
  */
 function AutoCompleteResult(aValues, aComments) {
   this.values = aValues;
   this.comments = aComments;
@@ -195,9 +195,9 @@ AutoCompleteResult.prototype =
       return this;
 
     throw Components.results.NS_ERROR_NO_INTERFACE;
   },
 
   // Data
   values: null,
   comments: null
-}
+};

--- a/accessible/tests/mochitest/bounds/test_select.html
+++ b/accessible/tests/mochitest/bounds/test_select.html
@@ -27,25 +27,25 @@
 
       this.eventSeq = [
         new invokerChecker(EVENT_FOCUS, this.comboboxOption)
       ];
 
       this.invoke = function openComboboxNCheckBounds_invoke() {
         getNode(aID).focus();
         synthesizeKey("VK_DOWN", { altKey: true });
-      }
+      };
 
       this.finalCheck = function openComboboxNCheckBounds_invoke() {
         testBounds(this.comboboxOption);
-      }
+      };
 
       this.getID = function openComboboxNCheckBounds_getID() {
         return "open combobox and test boundaries";
-      }
+      };
     }
 
     // gA11yEventDumpToConsole = true;
 
     var gQueue = null;
 
     function doTest() {
       // Combobox

--- a/accessible/tests/mochitest/common.js
+++ b/accessible/tests/mochitest/common.js
@@ -598,44 +598,44 @@ function testDefunctAccessible(aAcc, aNo
   var msg = " doesn't fail for shut down accessible " +
              prettyName(aNodeOrId) + "!";
 
   // firstChild
   var success = false;
   try {
     aAcc.firstChild;
   } catch (e) {
-    success = (e.result == Components.results.NS_ERROR_FAILURE)
+    success = (e.result == Components.results.NS_ERROR_FAILURE);
   }
   ok(success, "firstChild" + msg);
 
   // lastChild
   success = false;
   try {
     aAcc.lastChild;
   } catch (e) {
-    success = (e.result == Components.results.NS_ERROR_FAILURE)
+    success = (e.result == Components.results.NS_ERROR_FAILURE);
   }
   ok(success, "lastChild" + msg);
 
   // childCount
   success = false;
   try {
     aAcc.childCount;
   } catch (e) {
-    success = (e.result == Components.results.NS_ERROR_FAILURE)
+    success = (e.result == Components.results.NS_ERROR_FAILURE);
   }
   ok(success, "childCount" + msg);
 
   // children
   success = false;
   try {
     aAcc.children;
   } catch (e) {
-    success = (e.result == Components.results.NS_ERROR_FAILURE)
+    success = (e.result == Components.results.NS_ERROR_FAILURE);
   }
   ok(success, "children" + msg);
 
   // nextSibling
   success = false;
   try {
     aAcc.nextSibling;
   } catch (e) {
@@ -675,17 +675,17 @@ function roleToString(aRole) {
 function statesToString(aStates, aExtraStates) {
   var list = gAccService.getStringStates(aStates, aExtraStates);
 
   var str = "";
   for (var index = 0; index < list.length - 1; index++)
     str += list.item(index) + ", ";
 
   if (list.length != 0)
-    str += list.item(index)
+    str += list.item(index);
 
   return str;
 }
 
 /**
  * Convert event type to human readable string.
  */
 function eventTypeToString(aEventType) {

--- a/accessible/tests/mochitest/editabletext/editabletext.js
+++ b/accessible/tests/mochitest/editabletext/editabletext.js
@@ -1,32 +1,32 @@
 /**
  * Perform all editable text tests.
  */
 function editableTextTestRun() {
   this.add = function add(aTest) {
     this.seq.push(aTest);
-  }
+  };
 
   this.run = function run() {
     this.iterate();
-  }
+  };
 
   this.index = 0;
   this.seq = [];
 
   this.iterate = function iterate() {
     if (this.index < this.seq.length) {
       this.seq[this.index++].startTest(this);
       return;
     }
 
     this.seq = null;
     SimpleTest.finish();
-  }
+  };
 }
 
 /**
  * Used to test nsIEditableTextAccessible methods.
  */
 function editableTextTest(aID) {
   /**
    * Schedule a test, the given function with its arguments will be executed
@@ -40,17 +40,17 @@ function editableTextTest(aID) {
       funcArgs: Array.slice(arguments, 1)
     };
     this.mEventQueue.push(dataContainer);
 
     if (!this.mEventQueueReady) {
       this.unwrapNextTest();
       this.mEventQueueReady = true;
     }
-  }
+  };
 
   /**
    * setTextContents test.
    */
   this.setTextContents = function setTextContents(aValue, aSkipStartOffset) {
     var testID = "setTextContents '" + aValue + "' for " + prettyName(aID);
 
     function setTextContentsInvoke() {
@@ -63,17 +63,17 @@ function editableTextTest(aID) {
     var insertTripple = aValue ?
       [ aSkipStartOffset, aSkipStartOffset + aValue.length, aValue ] : null;
     var oldValue = getValue(aID);
     var removeTripple = oldValue ?
       [ aSkipStartOffset, aSkipStartOffset + oldValue.length, oldValue ] : null;
 
     this.generateTest(aID, removeTripple, insertTripple, setTextContentsInvoke,
                       getValueChecker(aID, aValue), testID);
-  }
+  };
 
   /**
    * insertText test.
    */
   this.insertText = function insertText(aStr, aPos, aResStr, aResPos) {
     var testID = "insertText '" + aStr + "' at " + aPos + " for " +
       prettyName(aID);
 
@@ -81,33 +81,33 @@ function editableTextTest(aID) {
       dump(`\ninsertText '${aStr}' at ${aPos} pos\n`);
       var acc = getAccessible(aID, nsIAccessibleEditableText);
       acc.insertText(aStr, aPos);
     }
 
     var resPos = (aResPos != undefined) ? aResPos : aPos;
     this.generateTest(aID, null, [resPos, resPos + aStr.length, aStr],
                       insertTextInvoke, getValueChecker(aID, aResStr), testID);
-  }
+  };
 
   /**
    * copyText test.
    */
   this.copyText = function copyText(aStartPos, aEndPos, aClipboardStr) {
     var testID = "copyText from " + aStartPos + " to " + aEndPos + " for " +
       prettyName(aID);
 
     function copyTextInvoke() {
       var acc = getAccessible(aID, nsIAccessibleEditableText);
       acc.copyText(aStartPos, aEndPos);
     }
 
     this.generateTest(aID, null, null, copyTextInvoke,
                       getClipboardChecker(aID, aClipboardStr), testID);
-  }
+  };
 
   /**
    * copyText and pasteText test.
    */
   this.copyNPasteText = function copyNPasteText(aStartPos, aEndPos,
                                                 aPos, aResStr) {
     var testID = "copyText from " + aStartPos + " to " + aEndPos +
       "and pasteText at " + aPos + " for " + prettyName(aID);
@@ -115,17 +115,17 @@ function editableTextTest(aID) {
     function copyNPasteTextInvoke() {
       var acc = getAccessible(aID, nsIAccessibleEditableText);
       acc.copyText(aStartPos, aEndPos);
       acc.pasteText(aPos);
     }
 
     this.generateTest(aID, null, [aStartPos, aEndPos, getTextFromClipboard],
                       copyNPasteTextInvoke, getValueChecker(aID, aResStr), testID);
-  }
+  };
 
   /**
    * cutText test.
    */
   this.cutText = function cutText(aStartPos, aEndPos, aResStr,
                                   aResStartPos, aResEndPos) {
     var testID = "cutText from " + aStartPos + " to " + aEndPos + " for " +
       prettyName(aID);
@@ -134,17 +134,17 @@ function editableTextTest(aID) {
       var acc = getAccessible(aID, nsIAccessibleEditableText);
       acc.cutText(aStartPos, aEndPos);
     }
 
     var resStartPos = (aResStartPos != undefined) ? aResStartPos : aStartPos;
     var resEndPos = (aResEndPos != undefined) ? aResEndPos : aEndPos;
     this.generateTest(aID, [resStartPos, resEndPos, getTextFromClipboard], null,
                       cutTextInvoke, getValueChecker(aID, aResStr), testID);
-  }
+  };
 
   /**
    * cutText and pasteText test.
    */
   this.cutNPasteText = function copyNPasteText(aStartPos, aEndPos,
                                                aPos, aResStr) {
     var testID = "cutText from " + aStartPos + " to " + aEndPos +
       " and pasteText at " + aPos + " for " + prettyName(aID);
@@ -154,32 +154,32 @@ function editableTextTest(aID) {
       acc.cutText(aStartPos, aEndPos);
       acc.pasteText(aPos);
     }
 
     this.generateTest(aID, [aStartPos, aEndPos, getTextFromClipboard],
                       [aPos, -1, getTextFromClipboard],
                       cutNPasteTextInvoke, getValueChecker(aID, aResStr),
                       testID);
-  }
+  };
 
   /**
    * pasteText test.
    */
   this.pasteText = function pasteText(aPos, aResStr) {
     var testID = "pasteText at " + aPos + " for " + prettyName(aID);
 
     function pasteTextInvoke() {
       var acc = getAccessible(aID, nsIAccessibleEditableText);
       acc.pasteText(aPos);
     }
 
     this.generateTest(aID, null, [aPos, -1, getTextFromClipboard],
                       pasteTextInvoke, getValueChecker(aID, aResStr), testID);
-  }
+  };
 
   /**
    * deleteText test.
    */
   this.deleteText = function deleteText(aStartPos, aEndPos, aResStr) {
     var testID = "deleteText from " + aStartPos + " to " + aEndPos +
       " for " + prettyName(aID);
 
@@ -188,17 +188,17 @@ function editableTextTest(aID) {
 
     function deleteTextInvoke() {
       var acc = getAccessible(aID, [nsIAccessibleEditableText]);
       acc.deleteText(aStartPos, aEndPos);
     }
 
     this.generateTest(aID, removeTripple, null, deleteTextInvoke,
                       getValueChecker(aID, aResStr), testID);
-  }
+  };
 
   // ////////////////////////////////////////////////////////////////////////////
   // Implementation details.
 
   function getValue(aID) {
     var elm = getNode(aID);
     if (elm instanceof Components.interfaces.nsIDOMNSEditableElement)
       return elm.value;
@@ -232,17 +232,17 @@ function editableTextTest(aID) {
 
   /**
    * Process next scheduled test.
    */
   this.unwrapNextTest = function unwrapNextTest() {
     var data = this.mEventQueue.mInvokers[this.mEventQueue.mIndex + 1];
     if (data)
       data.func.apply(this, data.funcArgs);
-  }
+  };
 
   /**
    * Used to generate an invoker object for the sheduled test.
    */
   this.generateTest = function generateTest(aID, aRemoveTriple, aInsertTriple,
                                             aInvokeFunc, aChecker, aInvokerID) {
     var et = this;
     var invoker = {
@@ -272,33 +272,33 @@ function editableTextTest(aID) {
       invoker.eventSeq.push(checker);
     }
 
     // Claim that we don't want to fail when no events are expected.
     if (!aRemoveTriple && !aInsertTriple)
       invoker.noEventsOnAction = true;
 
     this.mEventQueue.mInvokers[this.mEventQueue.mIndex + 1] = invoker;
-  }
+  };
 
   /**
    * Run the tests.
    */
   this.startTest = function startTest(aTestRun) {
     var testRunObj = aTestRun;
     var thisObj = this;
     this.mEventQueue.onFinish = function finishCallback() {
       // Notify textRun object that all tests were finished.
       testRunObj.iterate();
 
       // Help GC to avoid leaks (refer to aTestRun from local variable, drop
       // onFinish function).
       thisObj.mEventQueue.onFinish = null;
 
       return DO_NOT_FINISH_TEST;
-    }
+    };
 
     this.mEventQueue.invoke();
-  }
+  };
 
   this.mEventQueue = new eventQueue();
   this.mEventQueueReady = false;
 }

--- a/accessible/tests/mochitest/elm/test_HTMLSpec.html
+++ b/accessible/tests/mochitest/elm/test_HTMLSpec.html
@@ -137,48 +137,48 @@
         textAttrs: {
           0: { },
           6: { "font-weight": kBoldFontWeight }
         },
         children: [
           { role: ROLE_TEXT_LEAF }, // plain text
           { role: ROLE_TEXT_LEAF } // HTML:b text
         ]
-      }
+      };
       testElm("b_container", obj);
 
       // ////////////////////////////////////////////////////////////////////////
       obj = { // HTML:bdi contained by paragraph
         role: ROLE_PARAGRAPH,
         todo_textAttrs: {
           0: { },
           5: { "writing-mode": "rl" },
           8: { }
         },
         children: [
           { role: ROLE_TEXT_LEAF }, // plain text
           { role: ROLE_TEXT_LEAF }, // HTML:bdi text
           { role: ROLE_TEXT_LEAF } // plain text
         ]
-      }
+      };
       testElm("bdi_container", obj);
 
       // ////////////////////////////////////////////////////////////////////////
       // HTML:bdo contained by paragraph
 
       obj = {
         role: ROLE_PARAGRAPH,
         todo_textAttrs: {
           0: { },
           6: { "writing-mode": "rl" }
         },
         children: [
           { role: ROLE_TEXT_LEAF }, // plain text
         ]
-      }
+      };
       testElm("bdo_container", obj);
 
       // ////////////////////////////////////////////////////////////////////////
       // HTML:blockquote
 
       obj = {
         role: ROLE_SECTION,
         interfaces: [ nsIAccessibleText, nsIAccessibleHyperText ],
@@ -646,17 +646,17 @@
         textAttrs: {
           0: { },
           6: { "font-style": "italic" }
         },
         children: [
           { role: ROLE_TEXT_LEAF }, // plain text
           { role: ROLE_TEXT_LEAF } // HTML:i text
         ]
-      }
+      };
       testElm("i_container", obj);
 
       // ////////////////////////////////////////////////////////////////////////
       // HTML:img
 
       obj = {
         role: ROLE_GRAPHIC,
         interfaces: [ nsIAccessibleImage ]

--- a/accessible/tests/mochitest/events.js
+++ b/accessible/tests/mochitest/events.js
@@ -251,35 +251,35 @@ const DO_NOT_FINISH_TEST = 1;
 function eventQueue(aEventType) {
   // public
 
   /**
    * Add invoker object into queue.
    */
   this.push = function eventQueue_push(aEventInvoker) {
     this.mInvokers.push(aEventInvoker);
-  }
+  };
 
   /**
    * Start the queue processing.
    */
   this.invoke = function eventQueue_invoke() {
     listenA11yEvents(true);
 
     // XXX: Intermittent test_events_caretmove.html fails withouth timeout,
     // see bug 474952.
     this.processNextInvokerInTimeout(true);
-  }
+  };
 
   /**
    * This function is called when all events in the queue were handled.
    * Override it if you need to be notified of this.
    */
   this.onFinish = function eventQueue_finish() {
-  }
+  };
 
   // private
 
   /**
    * Process next invoker.
    */
   this.processNextInvoker = function eventQueue_processNextInvoker() {
     // Some scenario was matched, we wait on next invoker processing.
@@ -422,17 +422,17 @@ function eventQueue(aEventType) {
     if (invoker.invoke() == INVOKER_ACTION_FAILED) {
       // Invoker failed to prepare action, fail and finish tests.
       this.processNextInvoker();
       return;
     }
 
     if (this.hasUnexpectedEventsScenario())
       this.processNextInvokerInTimeout(true);
-  }
+  };
 
   this.processNextInvokerInTimeout =
     function eventQueue_processNextInvokerInTimeout(aUncondProcess) {
     this.setInvokerStatus(kInvokerPending, "Process next invoker in timeout");
 
     // No need to wait extra timeout when a) we know we don't need to do that
     // and b) there's no any single unexpected event.
     if (!aUncondProcess && this.areAllEventsExpected()) {
@@ -440,17 +440,17 @@ function eventQueue(aEventType) {
       var queue = this;
       SimpleTest.executeSoon(function() { queue.processNextInvoker(); });
       return;
     }
 
     // Check in timeout invoker didn't fire registered events.
     window.setTimeout(function(aQueue) { aQueue.processNextInvoker(); }, 300,
                       this);
-  }
+  };
 
   /**
    * Handle events for the current invoker.
    */
   this.handleEvent = function eventQueue_handleEvent(aEvent) {
     var invoker = this.getInvoker();
     if (!invoker) // skip events before test was started
       return;
@@ -568,47 +568,47 @@ function eventQueue(aEventType) {
       return;
     }
 
     // If we have scheduled a next invoker then cancel in case of match.
     if ((this.mNextInvokerStatus == kInvokerPending) && hasMatchedCheckers) {
       this.setInvokerStatus(kInvokerCanceled,
                             "Cancel the scheduled invoker in case of match");
     }
-  }
+  };
 
   // Helpers
   this.processMatchedChecker =
     function eventQueue_function(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx) {
     aMatchedChecker.wasCaught++;
 
     if ("check" in aMatchedChecker)
       aMatchedChecker.check(aEvent);
 
     eventQueue.logEvent(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx,
                         this.areExpectedEventsLeft(),
                         this.mNextInvokerStatus);
-  }
+  };
 
   this.getNextExpectedEvent =
     function eventQueue_getNextExpectedEvent(aEventSeq) {
     if (!("idx" in aEventSeq))
       aEventSeq.idx = 0;
 
     while (aEventSeq.idx < aEventSeq.length &&
            (aEventSeq[aEventSeq.idx].unexpected ||
             aEventSeq[aEventSeq.idx].todo ||
             aEventSeq[aEventSeq.idx].async ||
             aEventSeq[aEventSeq.idx] instanceof orderChecker ||
             aEventSeq[aEventSeq.idx].wasCaught > 0)) {
       aEventSeq.idx++;
     }
 
     return aEventSeq.idx != aEventSeq.length ? aEventSeq[aEventSeq.idx] : null;
-  }
+  };
 
   this.areExpectedEventsLeft =
     function eventQueue_areExpectedEventsLeft(aScenario) {
       function scenarioHasUnhandledExpectedEvent(aEventSeq) {
         // Check if we have unhandled async (can be anywhere in the sequance) or
         // sync expcected events yet.
         for (var idx = 0; idx < aEventSeq.length; idx++) {
           if (!aEventSeq[idx].unexpected && !aEventSeq[idx].todo &&
@@ -623,71 +623,71 @@ function eventQueue(aEventType) {
         return scenarioHasUnhandledExpectedEvent(aScenario);
 
       for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
         var eventSeq = this.mScenarios[scnIdx];
         if (scenarioHasUnhandledExpectedEvent(eventSeq))
           return true;
       }
       return false;
-    }
+    };
 
   this.areAllEventsExpected =
     function eventQueue_areAllEventsExpected() {
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
         if (eventSeq[idx].unexpected || eventSeq[idx].todo)
           return false;
       }
     }
 
     return true;
-  }
+  };
 
   this.isUnexpectedEventScenario =
     function eventQueue_isUnexpectedEventsScenario(aScenario) {
     for (var idx = 0; idx < aScenario.length; idx++) {
       if (!aScenario[idx].unexpected && !aScenario[idx].todo)
         break;
     }
 
     return idx == aScenario.length;
-  }
+  };
 
   this.hasUnexpectedEventsScenario =
     function eventQueue_hasUnexpectedEventsScenario() {
     if (this.getInvoker().noEventsOnAction)
       return true;
 
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       if (this.isUnexpectedEventScenario(this.mScenarios[scnIdx]))
         return true;
     }
 
     return false;
-  }
+  };
 
   this.hasMatchedScenario =
     function eventQueue_hasMatchedScenario() {
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var scn = this.mScenarios[scnIdx];
       if (!this.isUnexpectedEventScenario(scn) && !this.areExpectedEventsLeft(scn))
         return true;
     }
     return false;
-  }
+  };
 
   this.getInvoker = function eventQueue_getInvoker() {
     return this.mInvokers[this.mIndex];
-  }
+  };
 
   this.getNextInvoker = function eventQueue_getNextInvoker() {
     return this.mInvokers[++this.mIndex];
-  }
+  };
 
   this.setEventHandler = function eventQueue_setEventHandler(aInvoker) {
     if (!("scenarios" in aInvoker) || aInvoker.scenarios.length == 0) {
       var eventSeq = aInvoker.eventSeq;
       var unexpectedEventSeq = aInvoker.unexpectedEventSeq;
       if (!eventSeq && !unexpectedEventSeq && this.mDefEventType)
         eventSeq = [ new invokerChecker(this.mDefEventType, aInvoker.DOMNode) ];
 
@@ -757,17 +757,17 @@ function eventQueue(aEventType) {
         } else {
           // A11y event
           addA11yEventListener(eventType, this);
         }
       }
     }
 
     return true;
-  }
+  };
 
   this.clearEventHandler = function eventQueue_clearEventHandler() {
     if (!this.mScenarios)
       return;
 
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
@@ -780,32 +780,32 @@ function eventQueue(aEventType) {
 
         } else {
           // A11y event
           removeA11yEventListener(eventType, this);
         }
       }
     }
     this.mScenarios = null;
-  }
+  };
 
   this.getEventID = function eventQueue_getEventID(aChecker) {
     if ("getID" in aChecker)
       return aChecker.getID();
 
     var invoker = this.getInvoker();
     return invoker.getID();
-  }
+  };
 
   this.setInvokerStatus = function eventQueue_setInvokerStatus(aStatus, aLogMsg) {
     this.mNextInvokerStatus = aStatus;
 
     // Uncomment it to debug invoker processing logic.
     // gLogger.log(eventQueue.invokerStatusToMsg(aStatus, aLogMsg));
-  }
+  };
 
   this.mDefEventType = aEventType;
 
   this.mInvokers = [];
   this.mIndex = -1;
   this.mScenarios = null;
 
   this.mNextInvokerStatus = kInvokerNotScheduled;
@@ -823,17 +823,17 @@ eventQueue.getEventTypeAsString =
   if (aEventOrChecker instanceof nsIDOMEvent)
     return aEventOrChecker.type;
 
   if (aEventOrChecker instanceof nsIAccessibleEvent)
     return eventTypeToString(aEventOrChecker.eventType);
 
   return (typeof aEventOrChecker.type == "string") ?
     aEventOrChecker.type : eventTypeToString(aEventOrChecker.type);
-}
+};
 
 eventQueue.getEventTargetDescr =
   function eventQueue_getEventTargetDescr(aEventOrChecker, aDontForceTarget) {
   if (aEventOrChecker instanceof nsIDOMEvent)
     return prettyName(aEventOrChecker.originalTarget);
 
   if (aEventOrChecker instanceof nsIDOMEvent)
     return prettyName(aEventOrChecker.accessible);
@@ -842,28 +842,28 @@ eventQueue.getEventTargetDescr =
   if (descr)
     return descr;
 
   if (aDontForceTarget)
     return "no target description";
 
   var target = ("target" in aEventOrChecker) ? aEventOrChecker.target : null;
   return prettyName(target);
-}
+};
 
 eventQueue.getEventPhase = function eventQueue_getEventPhase(aChecker) {
   return ("phase" in aChecker) ? aChecker.phase : true;
-}
+};
 
 eventQueue.compareEventTypes =
   function eventQueue_compareEventTypes(aChecker, aEvent) {
   var eventType = (aEvent instanceof nsIDOMEvent) ?
     aEvent.type : aEvent.eventType;
   return aChecker.type == eventType;
-}
+};
 
 eventQueue.compareEvents = function eventQueue_compareEvents(aChecker, aEvent) {
   if (!eventQueue.compareEventTypes(aChecker, aEvent))
     return false;
 
   // If checker provides "match" function then allow the checker to decide
   // whether event is matched.
   if ("match" in aChecker)
@@ -877,26 +877,26 @@ eventQueue.compareEvents = function even
     return target1 == target2;
   }
 
   // If original target isn't suitable then extend interface to support target
   // (original target is used in test_elm_media.html).
   var target2 = (aEvent instanceof nsIDOMEvent) ?
     aEvent.originalTarget : aEvent.DOMNode;
   return target1 == target2;
-}
+};
 
 eventQueue.isSameEvent = function eventQueue_isSameEvent(aChecker, aEvent) {
   // We don't have stored info about handled event other than its type and
   // target, thus we should filter text change and state change events since
   // they may occur on the same element because of complex changes.
   return this.compareEvents(aChecker, aEvent) &&
     !(aEvent instanceof nsIAccessibleTextChangeEvent) &&
     !(aEvent instanceof nsIAccessibleStateChangeEvent);
-}
+};
 
 eventQueue.invokerStatusToMsg =
   function eventQueue_invokerStatusToMsg(aInvokerStatus, aMsg) {
   var msg = "invoker status: ";
   switch (aInvokerStatus) {
     case kInvokerNotScheduled:
       msg += "not scheduled";
       break;
@@ -907,17 +907,17 @@ eventQueue.invokerStatusToMsg =
       msg += "canceled";
       break;
   }
 
   if (aMsg)
     msg += " (" + aMsg + ")";
 
   return msg;
-}
+};
 
 eventQueue.logEvent = function eventQueue_logEvent(aOrigEvent, aMatchedChecker,
                                                    aScenarioIdx, aEventIdx,
                                                    aAreExpectedEventsLeft,
                                                    aInvokerStatus) {
   // Dump DOM event information. Skip a11y event since it is dumped by
   // gA11yEventObserver.
   if (aOrigEvent instanceof nsIDOMEvent) {
@@ -934,17 +934,17 @@ eventQueue.logEvent = function eventQueu
   var consoleMsg = "*****\nScenario " + aScenarioIdx +
     ", event " + aEventIdx + " matched: " + currType + "\n" + infoMsg + "\n*****";
   gLogger.logToConsole(consoleMsg);
 
   var emphText = "matched ";
   var msg = "EQ event, type: " + currType + ", target: " + currTargetDescr +
     ", " + infoMsg;
   gLogger.logToDOM(msg, true, emphText);
-}
+};
 
 
 // //////////////////////////////////////////////////////////////////////////////
 // Action sequence
 
 /**
  * Deal with action sequence. Used when you need to execute couple of actions
  * each after other one.
@@ -963,31 +963,31 @@ function sequence() {
    * @param  aEventType  [in] event type of expected event on item action
    * @param  aTarget     [in] event target of expected event on item action
    * @param  aItemID     [in] identifier of item
    */
   this.append = function sequence_append(aProcessor, aEventType, aTarget,
                                          aItemID) {
     var item = new sequenceItem(aProcessor, aEventType, aTarget, aItemID);
     this.items.push(item);
-  }
+  };
 
   /**
    * Process next sequence item.
    */
   this.processNext = function sequence_processNext() {
     this.idx++;
     if (this.idx >= this.items.length) {
       ok(false, "End of sequence: nothing to process!");
       SimpleTest.finish();
       return;
     }
 
     this.items[this.idx].startProcess();
-  }
+  };
 
   this.items = [];
   this.idx = -1;
 }
 
 
 // //////////////////////////////////////////////////////////////////////////////
 // Event queue invokers
@@ -1055,53 +1055,53 @@ function synthClick(aNodeOrID, aCheckerO
     var x = 1, y = 1;
     if (aArgs && ("where" in aArgs) && aArgs.where == "right") {
       if (targetNode instanceof nsIDOMHTMLElement)
         x = targetNode.offsetWidth - 1;
       else if (targetNode instanceof nsIDOMXULElement)
         x = targetNode.boxObject.width - 1;
     }
     synthesizeMouse(targetNode, x, y, aArgs ? aArgs : {});
-  }
+  };
 
   this.finalCheck = function synthClick_finalCheck() {
     // Scroll top window back.
     window.top.scrollTo(0, 0);
-  }
+  };
 
   this.getID = function synthClick_getID() {
     return prettyName(aNodeOrID) + " click";
-  }
+  };
 }
 
 /**
  * Mouse move invoker.
  */
 function synthMouseMove(aID, aCheckerOrEventSeq) {
   this.__proto__ = new synthAction(aID, aCheckerOrEventSeq);
 
   this.invoke = function synthMouseMove_invoke() {
     synthesizeMouse(this.DOMNode, 1, 1, { type: "mousemove" });
     synthesizeMouse(this.DOMNode, 2, 2, { type: "mousemove" });
-  }
+  };
 
   this.getID = function synthMouseMove_getID() {
     return prettyName(aID) + " mouse move";
-  }
+  };
 }
 
 /**
  * General key press invoker.
  */
 function synthKey(aNodeOrID, aKey, aArgs, aCheckerOrEventSeq) {
   this.__proto__ = new synthAction(aNodeOrID, aCheckerOrEventSeq);
 
   this.invoke = function synthKey_invoke() {
     synthesizeKey(this.mKey, this.mArgs, this.mWindow);
-  }
+  };
 
   this.getID = function synthKey_getID() {
     var key = this.mKey;
     switch (this.mKey) {
       case "VK_TAB":
         key = "tab";
         break;
       case "VK_DOWN":
@@ -1133,17 +1133,17 @@ function synthKey(aNodeOrID, aKey, aArgs
       if (aArgs.shiftKey)
         key += " shift";
       if (aArgs.ctrlKey)
         key += " ctrl";
       if (aArgs.altKey)
         key += " alt";
     }
     return prettyName(aNodeOrID) + " '" + key + " ' key";
-  }
+  };
 
   this.mKey = aKey;
   this.mArgs = aArgs ? aArgs : {};
   this.mWindow = aArgs ? aArgs.window : null;
 }
 
 /**
  * Tab key invoker.
@@ -1224,17 +1224,17 @@ function synthEnterKey(aID, aCheckerOrEv
 /**
  * Synth alt + down arrow to open combobox.
  */
 function synthOpenComboboxKey(aID, aCheckerOrEventSeq) {
   this.__proto__ = new synthDownKey(aID, aCheckerOrEventSeq, { altKey: true });
 
   this.getID = function synthOpenComboboxKey_getID() {
     return "open combobox (atl + down arrow) " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Focus invoker.
  */
 function synthFocus(aNodeOrID, aCheckerOrEventSeq) {
   var checkerOfEventSeq =
     aCheckerOrEventSeq ? aCheckerOrEventSeq : new focusChecker(aNodeOrID);
@@ -1242,39 +1242,39 @@ function synthFocus(aNodeOrID, aCheckerO
 
   this.invoke = function synthFocus_invoke() {
     if (this.DOMNode instanceof Components.interfaces.nsIDOMNSEditableElement &&
         this.DOMNode.editor ||
         this.DOMNode instanceof Components.interfaces.nsIDOMXULTextBoxElement) {
       this.DOMNode.selectionStart = this.DOMNode.selectionEnd = this.DOMNode.value.length;
     }
     this.DOMNode.focus();
-  }
+  };
 
   this.getID = function synthFocus_getID() {
     return prettyName(aNodeOrID) + " focus";
-  }
+  };
 }
 
 /**
  * Focus invoker. Focus the HTML body of content document of iframe.
  */
 function synthFocusOnFrame(aNodeOrID, aCheckerOrEventSeq) {
   var frameDoc = getNode(aNodeOrID).contentDocument;
   var checkerOrEventSeq =
     aCheckerOrEventSeq ? aCheckerOrEventSeq : new focusChecker(frameDoc);
   this.__proto__ = new synthAction(frameDoc, checkerOrEventSeq);
 
   this.invoke = function synthFocus_invoke() {
     this.DOMNode.body.focus();
-  }
+  };
 
   this.getID = function synthFocus_getID() {
     return prettyName(aNodeOrID) + " frame document focus";
-  }
+  };
 }
 
 /**
  * Change the current item when the widget doesn't have a focus.
  */
 function changeCurrentItem(aID, aItemID) {
   this.eventSeq = [ new nofocusChecker() ];
 
@@ -1315,85 +1315,85 @@ function changeCurrentItem(aID, aItemID)
       controlNode.selectedItem = itemNode;
       return;
     }
 
     if (controlNode.currentItem == itemNode)
       ok(false, "Error in test: proposed current item is already current" + prettyName(aID));
 
     controlNode.currentItem = itemNode;
-  }
+  };
 
   this.getID = function changeCurrentItem_getID() {
     return "current item change for " + prettyName(aID);
-  }
+  };
 
   this.reportError = function changeCurrentItem_reportError() {
     ok(false,
        "Error in test: proposed current item '" + aItemID + "' is already current");
-  }
+  };
 }
 
 /**
  * Toggle top menu invoker.
  */
 function toggleTopMenu(aID, aCheckerOrEventSeq) {
   this.__proto__ = new synthKey(aID, "VK_ALT", null,
                                 aCheckerOrEventSeq);
 
   this.getID = function toggleTopMenu_getID() {
     return "toggle top menu on " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Context menu invoker.
  */
 function synthContextMenu(aID, aCheckerOrEventSeq) {
   this.__proto__ = new synthClick(aID, aCheckerOrEventSeq,
                                   { button: 0, type: "contextmenu" });
 
   this.getID = function synthContextMenu_getID() {
     return "context menu on " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Open combobox, autocomplete and etc popup, check expandable states.
  */
 function openCombobox(aComboboxID) {
   this.eventSeq = [
     new stateChangeChecker(STATE_EXPANDED, false, true, aComboboxID)
   ];
 
   this.invoke = function openCombobox_invoke() {
     getNode(aComboboxID).focus();
     synthesizeKey("VK_DOWN", { altKey: true });
-  }
+  };
 
   this.getID = function openCombobox_getID() {
     return "open combobox " + prettyName(aComboboxID);
-  }
+  };
 }
 
 /**
  * Close combobox, autocomplete and etc popup, check expandable states.
  */
 function closeCombobox(aComboboxID) {
   this.eventSeq = [
     new stateChangeChecker(STATE_EXPANDED, false, false, aComboboxID)
   ];
 
   this.invoke = function closeCombobox_invoke() {
     synthesizeKey("VK_ESCAPE", { });
-  }
+  };
 
   this.getID = function closeCombobox_getID() {
     return "close combobox " + prettyName(aComboboxID);
-  }
+  };
 }
 
 
 /**
  * Select all invoker.
  */
 function synthSelectAll(aNodeOrID, aCheckerOrEventSeq) {
   this.__proto__ = new synthAction(aNodeOrID, aCheckerOrEventSeq);
@@ -1401,92 +1401,92 @@ function synthSelectAll(aNodeOrID, aChec
   this.invoke = function synthSelectAll_invoke() {
     if (this.DOMNode instanceof Components.interfaces.nsIDOMHTMLInputElement ||
         this.DOMNode instanceof Components.interfaces.nsIDOMXULTextBoxElement) {
       this.DOMNode.select();
 
     } else {
       window.getSelection().selectAllChildren(this.DOMNode);
     }
-  }
+  };
 
   this.getID = function synthSelectAll_getID() {
     return aNodeOrID + " selectall";
-  }
+  };
 }
 
 /**
  * Move the caret to the end of line.
  */
 function moveToLineEnd(aID, aCaretOffset) {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_RIGHT", { metaKey: true },
                                   new caretMoveChecker(aCaretOffset, aID));
   } else {
     this.__proto__ = new synthEndKey(aID,
                                      new caretMoveChecker(aCaretOffset, aID));
   }
 
   this.getID = function moveToLineEnd_getID() {
     return "move to line end in " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Move the caret to the end of previous line if any.
  */
 function moveToPrevLineEnd(aID, aCaretOffset) {
   this.__proto__ = new synthAction(aID, new caretMoveChecker(aCaretOffset, aID));
 
   this.invoke = function moveToPrevLineEnd_invoke() {
     synthesizeKey("VK_UP", { });
 
     if (MAC)
       synthesizeKey("VK_RIGHT", { metaKey: true });
     else
       synthesizeKey("VK_END", { });
-  }
+  };
 
   this.getID = function moveToPrevLineEnd_getID() {
     return "move to previous line end in " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Move the caret to begining of the line.
  */
 function moveToLineStart(aID, aCaretOffset) {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_LEFT", { metaKey: true },
                                   new caretMoveChecker(aCaretOffset, aID));
   } else {
     this.__proto__ = new synthHomeKey(aID,
                                       new caretMoveChecker(aCaretOffset, aID));
   }
 
   this.getID = function moveToLineEnd_getID() {
     return "move to line start in " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Move the caret to begining of the text.
  */
 function moveToTextStart(aID) {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_UP", { metaKey: true },
                                   new caretMoveChecker(0, aID));
   } else {
     this.__proto__ = new synthKey(aID, "VK_HOME", { ctrlKey: true },
                                   new caretMoveChecker(0, aID));
   }
 
   this.getID = function moveToTextStart_getID() {
     return "move to text start in " + prettyName(aID);
-  }
+  };
 }
 
 /**
  * Move the caret in text accessible.
  */
 function moveCaretToDOMPoint(aID, aDOMPointNodeID, aDOMPointOffset,
                              aExpectedOffset, aFocusTargetID,
                              aCheckFunc) {
@@ -1501,27 +1501,27 @@ function moveCaretToDOMPoint(aID, aDOMPo
 
     var selection = this.DOMPointNode.ownerGlobal.getSelection();
     var selRange = selection.getRangeAt(0);
     selRange.setStart(this.DOMPointNode, aDOMPointOffset);
     selRange.collapse(true);
 
     selection.removeRange(selRange);
     selection.addRange(selRange);
-  }
+  };
 
   this.getID = function moveCaretToDOMPoint_getID() {
    return "Set caret on " + prettyName(aID) + " at point: " +
      prettyName(aDOMPointNodeID) + " node with offset " + aDOMPointOffset;
-  }
+  };
 
   this.finalCheck = function moveCaretToDOMPoint_finalCheck() {
     if (aCheckFunc)
       aCheckFunc.call();
-  }
+  };
 
   this.eventSeq = [
     new caretMoveChecker(aExpectedOffset, this.target)
   ];
 
   if (this.focus)
     this.eventSeq.push(new asyncInvokerChecker(EVENT_FOCUS, this.focus));
 }
@@ -1531,21 +1531,21 @@ function moveCaretToDOMPoint(aID, aDOMPo
  */
 function setCaretOffset(aID, aOffset, aFocusTargetID) {
   this.target = getAccessible(aID, [nsIAccessibleText]);
   this.offset = aOffset == -1 ? this.target.characterCount : aOffset;
   this.focus = aFocusTargetID ? getAccessible(aFocusTargetID) : null;
 
   this.invoke = function setCaretOffset_invoke() {
     this.target.caretOffset = this.offset;
-  }
+  };
 
   this.getID = function setCaretOffset_getID() {
    return "Set caretOffset on " + prettyName(aID) + " at " + this.offset;
-  }
+  };
 
   this.eventSeq = [
     new caretMoveChecker(this.offset, this.target)
   ];
 
   if (this.focus)
     this.eventSeq.push(new asyncInvokerChecker(EVENT_FOCUS, this.focus));
 }
@@ -1632,17 +1632,17 @@ function asyncInvokerChecker(aEventType,
 function focusChecker(aTargetOrFunc, aTargetFuncArg) {
   this.__proto__ = new invokerChecker(EVENT_FOCUS, aTargetOrFunc,
                                       aTargetFuncArg, false);
 
   this.unique = true; // focus event must be unique for invoker action
 
   this.check = function focusChecker_check(aEvent) {
     testStates(aEvent.accessible, STATE_FOCUSED);
-  }
+  };
 }
 
 function nofocusChecker(aID) {
   this.__proto__ = new focusChecker(aID);
   this.unexpected = true;
 }
 
 /**
@@ -1683,32 +1683,32 @@ function textChangeChecker(aID, aStart, 
     var changeInfo = (aIsInserted ? "inserted" : "removed");
     is(aEvent.isInserted, aIsInserted,
        "Text was " + changeInfo + " for " + prettyName(aID));
     is(aEvent.modifiedText, modifiedText,
        "Wrong " + changeInfo + " text for " + prettyName(aID));
     if (typeof aFromUser != "undefined")
       is(aEvent.isFromUserInput, aFromUser,
          "wrong value of isFromUserInput() for " + prettyName(aID));
-  }
+  };
 }
 
 /**
  * Caret move events checker.
  */
 function caretMoveChecker(aCaretOffset, aTargetOrFunc, aTargetFuncArg,
                           aIsAsync) {
   this.__proto__ = new invokerChecker(EVENT_TEXT_CARET_MOVED,
                                       aTargetOrFunc, aTargetFuncArg, aIsAsync);
 
   this.check = function caretMoveChecker_check(aEvent) {
     is(aEvent.QueryInterface(nsIAccessibleCaretMoveEvent).caretOffset,
        aCaretOffset,
        "Wrong caret offset for " + prettyName(aEvent.accessible));
-  }
+  };
 }
 
 function asyncCaretMoveChecker(aCaretOffset, aTargetOrFunc, aTargetFuncArg) {
   this.__proto__ = new caretMoveChecker(aCaretOffset, aTargetOrFunc,
                                         aTargetFuncArg, true);
 }
 
 /**
@@ -1718,17 +1718,17 @@ function textSelectionChecker(aID, aStar
   this.__proto__ = new invokerChecker(EVENT_TEXT_SELECTION_CHANGED, aID);
 
   this.check = function textSelectionChecker_check(aEvent) {
     if (aStartOffset == aEndOffset) {
       ok(true, "Collapsed selection triggered text selection change event.");
     } else {
       testTextGetSelection(aID, aStartOffset, aEndOffset, 0);
     }
-  }
+  };
 }
 
 /**
  * Object attribute changed checker
  */
 function objAttrChangedChecker(aID, aAttr) {
   this.__proto__ = new invokerChecker(EVENT_OBJECT_ATTRIBUTE_CHANGED, aID);
 
@@ -1792,26 +1792,26 @@ function stateChangeChecker(aState, aIsE
       return;
     }
 
     var state = aIsEnabled ? (aIsExtraState ? 0 : aState) : 0;
     var extraState = aIsEnabled ? (aIsExtraState ? aState : 0) : 0;
     var unxpdState = aIsEnabled ? 0 : (aIsExtraState ? 0 : aState);
     var unxpdExtraState = aIsEnabled ? 0 : (aIsExtraState ? aState : 0);
     testStates(event.accessible, state, extraState, unxpdState, unxpdExtraState);
-  }
+  };
 
   this.match = function stateChangeChecker_match(aEvent) {
     if (aEvent instanceof nsIAccessibleStateChangeEvent) {
       var scEvent = aEvent.QueryInterface(nsIAccessibleStateChangeEvent);
       return (aEvent.accessible == getAccessible(this.target)) &&
         (scEvent.state == aState);
     }
     return false;
-  }
+  };
 }
 
 function asyncStateChangeChecker(aState, aIsExtraState, aIsEnabled,
                                  aTargetOrFunc, aTargetFuncArg) {
   this.__proto__ = new stateChangeChecker(aState, aIsExtraState, aIsEnabled,
                                           aTargetOrFunc, aTargetFuncArg, true);
 }
 
@@ -1836,17 +1836,17 @@ function expandedStateChecker(aIsEnabled
     is(event.state, STATE_EXPANDED, "Wrong state of the statechange event.");
     is(event.isExtraState, false,
        "Wrong extra state bit of the statechange event.");
     is(event.isEnabled, aIsEnabled,
       "Wrong state of statechange event state");
 
     testStates(event.accessible,
                (aIsEnabled ? STATE_EXPANDED : STATE_COLLAPSED));
-  }
+  };
 }
 
 // //////////////////////////////////////////////////////////////////////////////
 // Event sequances (array of predefined checkers)
 
 /**
  * Event seq for single selection change.
  */
@@ -2123,23 +2123,23 @@ var gLogger =
 /**
  * Base class of sequence item.
  */
 function sequenceItem(aProcessor, aEventType, aTarget, aItemID) {
   // private
 
   this.startProcess = function sequenceItem_startProcess() {
     this.queue.invoke();
-  }
+  };
 
   this.queue = new eventQueue();
   this.queue.onFinish = function() {
     aProcessor.onProcessed();
     return DO_NOT_FINISH_TEST;
-  }
+  };
 
   var invoker = {
     invoke: function invoker_invoke() {
       return aProcessor.process();
     },
     getID: function invoker_getID() {
       return aItemID;
     },
@@ -2168,10 +2168,10 @@ function synthAction(aNodeOrID, aEventsO
     } else {
       scenarios = [ [ aEventsObj ] ]; // a single checker object
     }
 
     for (var i = 0; i < scenarios.length; i++)
       defineScenario(this, scenarios[i]);
   }
 
-  this.getID = function synthAction_getID() { return prettyName(aNodeOrID) + " action"; }
+  this.getID = function synthAction_getID() { return prettyName(aNodeOrID) + " action"; };
 }

--- a/accessible/tests/mochitest/events/test_aria_alert.html
+++ b/accessible/tests/mochitest/events/test_aria_alert.html
@@ -31,25 +31,25 @@
       };
 
       this.getID = function showAlert_getID() {
         return "Show ARIA alert " + aID;
       };
     }
 
     function changeAlert(aID) {
-      this.__defineGetter__("DOMNode", function() { return getNode(aID) });
+      this.__defineGetter__("DOMNode", function() { return getNode(aID); });
 
       this.invoke = function changeAlert_invoke() {
         this.DOMNode.textContent = "new alert";
-      }
+      };
 
       this.getID = function showAlert_getID() {
         return "Change ARIA alert " + aID;
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     // gA11yEventDumpToConsole = true; // debuging
     // enableLogging("tree,events,verbose");
 

--- a/accessible/tests/mochitest/events/test_aria_menu.html
+++ b/accessible/tests/mochitest/events/test_aria_menu.html
@@ -32,21 +32,21 @@
                                               getNode(aActiveMenuBarID)));
       }
 
       this.eventSeq.push(new invokerChecker(EVENT_MENU_START, getNode(aMenuBarID)));
       this.eventSeq.push(new invokerChecker(EVENT_FOCUS, getNode(aMenuID)));
 
       this.invoke = function focusMenu_invoke() {
         getNode(aMenuID).focus();
-      }
+      };
 
       this.getID = function focusMenu_getID() {
         return "focus menu '" + aMenuID + "'";
-      }
+      };
     }
 
     function showMenu(aMenuID, aParentMenuID, aHow) {
       this.menuNode = getNode(aMenuID);
 
       // Because of aria-owns processing we may have menupopup start fired before
       // related show event.
       this.eventSeq = [
@@ -83,23 +83,23 @@
         // Store menu accessible reference while menu is still open.
         this.menu = getAccessible(this.menuNode);
 
         // Hide menu.
         if (aHow == kViaDisplayStyle)
           this.menuNode.style.display = "none";
         else
           this.menuNode.style.visibility = "hidden";
-      }
+      };
 
       this.getID = function closeMenu_getID() {
         return "Close ARIA menu " + aMenuID + " by " +
           (aHow == kViaDisplayStyle ? "display" : "visibility") +
           " style tricks";
-      }
+      };
 
       function getMenu(aThisObj) {
         return aThisObj.menu;
       }
     }
 
     function focusInsideMenu(aMenuID, aMenuBarID) {
       this.eventSeq = [
@@ -107,34 +107,34 @@
       ];
 
       this.unexpectedEventSeq = [
         new invokerChecker(EVENT_MENU_END, getNode(aMenuBarID))
       ];
 
       this.invoke = function focusInsideMenu_invoke() {
         getNode(aMenuID).focus();
-      }
+      };
 
       this.getID = function focusInsideMenu_getID() {
         return "focus menu '" + aMenuID + "'";
-      }
+      };
     }
 
     function blurMenu(aMenuBarID) {
       var eventSeq = [
         new invokerChecker(EVENT_MENU_END, getNode(aMenuBarID)),
         new invokerChecker(EVENT_FOCUS, getNode("outsidemenu"))
       ];
 
       this.__proto__ = new synthClick("outsidemenu", eventSeq);
 
       this.getID = function blurMenu_getID() {
         return "blur menu";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     // gA11yEventDumpToConsole = true; // debuging
     // enableLogging("tree,events,verbose");
 

--- a/accessible/tests/mochitest/events/test_aria_objattr.html
+++ b/accessible/tests/mochitest/events/test_aria_objattr.html
@@ -46,17 +46,17 @@
       this.finalCheck = function updateARIAHidden() {
         if (aIsDefined) {
           testAttrs(aID, {"hidden": "true"}, true);
           testAttrs(aChildId, {"hidden": "true"}, true);
         } else {
           testAbsentAttrs(aID, { "hidden": "true"});
           testAbsentAttrs(aChildId, { "hidden": "true"});
         }
-      }
+      };
     }
 
     // Debug stuff.
     // gA11yEventDumpID = "eventdump";
     // gA11yEventDumpToConsole = true;
 
     function doTests() {
       gQueue = new eventQueue();

--- a/accessible/tests/mochitest/events/test_attrs.html
+++ b/accessible/tests/mochitest/events/test_attrs.html
@@ -29,17 +29,17 @@
 
       this.noTarget = getNode(aNoTargetID);
 
       this.check = function checker_check(aEvent) {
         testAttrs(aEvent.accessible, { "event-from-input": aValue }, true);
 
         var accessible = getAccessible(this.noTarget);
         testAbsentAttrs(accessible, { "event-from-input": "" });
-      }
+      };
     }
 
     /**
      * Do tests.
      */
     var gQueue = null;
 
     // gA11yEventDumpID = "eventdump"; // debug stuff

--- a/accessible/tests/mochitest/events/test_bug1322593-2.html
+++ b/accessible/tests/mochitest/events/test_bug1322593-2.html
@@ -27,21 +27,21 @@
         new orderChecker(),
         new textChangeChecker("container", 0, 1, "a", true, undefined, true),
         new textChangeChecker("container", 7, 8, "b", true, undefined, true)
       ];
 
       this.invoke = function changeMultipleElements_invoke() {
         this.node1.textContent = "a";
         this.node2.textContent = "b";
-      }
+      };
 
       this.getID = function changeMultipleElements_invoke_getID() {
         return "Change the text content of multiple sibling divs";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 //    gA11yEventDumpToConsole = true; // debugging
 
     var gQueue = null;
     function doTests() {

--- a/accessible/tests/mochitest/events/test_bug1322593.html
+++ b/accessible/tests/mochitest/events/test_bug1322593.html
@@ -27,21 +27,21 @@
         new orderChecker(),
         new textChangeChecker("div1", 0, 1, "a", true, undefined, true),
         new textChangeChecker("div2", 0, 1, "b", true, undefined, true)
       ];
 
       this.invoke = function changeMultipleElements_invoke() {
         this.node1.textContent = "a";
         this.node2.textContent = "b";
-      }
+      };
 
       this.getID = function changeMultipleElements_invoke_getID() {
         return "Change the text content of multiple sibling divs";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 //    gA11yEventDumpToConsole = true; // debugging
 
     var gQueue = null;
     function doTests() {

--- a/accessible/tests/mochitest/events/test_caretmove.html
+++ b/accessible/tests/mochitest/events/test_caretmove.html
@@ -28,17 +28,17 @@
       this.check = function clickChecker_check(aEvent) {
         this.__proto__.check(aEvent);
 
         if (this.extraNode) {
           var acc = getAccessible(this.extraNode, [nsIAccessibleText]);
           is(acc.caretOffset, aExtraCaretOffset,
              "Wrong caret offset for " + aExtraNodeOrID);
         }
-      }
+      };
     }
 
     /**
      * Do tests.
      */
     var gQueue = null;
 
     // gA11yEventDumpID = "eventdump"; // debug stuff

--- a/accessible/tests/mochitest/events/test_coalescence.html
+++ b/accessible/tests/mochitest/events/test_coalescence.html
@@ -38,36 +38,36 @@
       this.invoke = function coalescenceBase_invoke() {
         if (aPerformActionOnChildInTheFirstPlace) {
           this.invokeAction(this.childNode, aChildAction);
           this.invokeAction(this.parentNode, aParentAction);
         } else {
           this.invokeAction(this.parentNode, aParentAction);
           this.invokeAction(this.childNode, aChildAction);
         }
-      }
+      };
 
       this.getID = function coalescenceBase_getID() {
         var childAction = this.getActionName(aChildAction) + " child";
         var parentAction = this.getActionName(aParentAction) + " parent";
 
         if (aPerformActionOnChildInTheFirstPlace)
           return childAction + " and then " + parentAction;
 
         return parentAction + " and then " + childAction;
-      }
+      };
 
       this.finalCheck = function coalescenceBase_check() {
         if (this.getEventType(aChildAction) == EVENT_HIDE) {
           testIsDefunct(this.child);
         }
         if (this.getEventType(aParentAction) == EVENT_HIDE) {
           testIsDefunct(this.parent);
         }
-      }
+      };
 
       // Implementation details
 
       this.invokeAction = function coalescenceBase_invokeAction(aNode, aAction) {
         switch (aAction) {
           case kRemoveElm:
             aNode.remove();
             break;
@@ -85,56 +85,56 @@
 
           case kShowElm:
             aNode.style.display = "block";
             break;
 
           default:
             return INVOKER_ACTION_FAILED;
         }
-      }
+      };
 
       this.getEventType = function coalescenceBase_getEventType(aAction) {
         switch (aAction) {
           case kRemoveElm: case kHideElm:
             return EVENT_HIDE;
           case kAddElm: case kShowElm:
             return EVENT_SHOW;
         }
-      }
+      };
 
       this.getActionName = function coalescenceBase_getActionName(aAction) {
         switch (aAction) {
           case kRemoveElm:
             return "remove";
           case kHideElm:
             return "hide";
           case kAddElm:
             return "add";
           case kShowElm:
             return "show";
           default:
             return "??";
         }
-      }
+      };
 
       this.initSequence = function coalescenceBase_initSequence() {
         // expected events
         var eventType = this.getEventType(aParentAction);
         this.eventSeq = [
           new invokerChecker(eventType, this.parentNode),
           new invokerChecker(EVENT_REORDER, this.hostNode)
         ];
 
         // unexpected events
         this.unexpectedEventSeq = [
           new invokerChecker(this.getEventType(aChildAction), this.childNode),
           new invokerChecker(EVENT_REORDER, this.parentNode)
         ];
-      }
+      };
     }
 
     /**
      * Remove or hide mutation events coalescence testing.
      */
     function removeOrHideCoalescenceBase(aChildID, aParentID,
                                          aChildAction, aParentAction,
                                          aPerformActionOnChildInTheFirstPlace) {
@@ -142,17 +142,17 @@
                                            aPerformActionOnChildInTheFirstPlace);
 
       this.init = function removeOrHideCoalescenceBase_init() {
         this.childNode = getNode(aChildID);
         this.parentNode = getNode(aParentID);
         this.child = getAccessible(this.childNode);
         this.parent = getAccessible(this.parentNode);
         this.hostNode = this.parentNode.parentNode;
-      }
+      };
 
       // Initalization
 
       this.init();
       this.initSequence();
     }
 
     // //////////////////////////////////////////////////////////////////////////
@@ -234,17 +234,17 @@
      * Create and append parent node and create and append child node to it.
      */
     function addParentNChild(aHostID, aPerformActionOnChildInTheFirstPlace) {
       this.init = function addParentNChild_init() {
         this.hostNode = getNode(aHostID);
         this.parentNode = document.createElement("select");
         this.childNode = document.createElement("option");
         this.childNode.textContent = "testing";
-      }
+      };
 
       this.__proto__ = new coalescenceBase(kAddElm, kAddElm,
                                            aPerformActionOnChildInTheFirstPlace);
 
       this.init();
       this.initSequence();
     }
 
@@ -252,17 +252,17 @@
      * Show parent node and show child node to it.
      */
     function showParentNChild(aParentID, aChildID,
                               aPerformActionOnChildInTheFirstPlace) {
       this.init = function showParentNChild_init() {
         this.parentNode = getNode(aParentID);
         this.hostNode = this.parentNode.parentNode;
         this.childNode = getNode(aChildID);
-      }
+      };
 
       this.__proto__ = new coalescenceBase(kShowElm, kShowElm,
                                            aPerformActionOnChildInTheFirstPlace);
 
       this.init();
       this.initSequence();
     }
 
@@ -271,17 +271,17 @@
      */
     function showParentNAddChild(aParentID,
                                  aPerformActionOnChildInTheFirstPlace) {
       this.init = function showParentNAddChild_init() {
         this.parentNode = getNode(aParentID);
         this.hostNode = this.parentNode.parentNode;
         this.childNode = document.createElement("option");
         this.childNode.textContent = "testing";
-      }
+      };
 
       this.__proto__ = new coalescenceBase(kAddElm, kShowElm,
                                            aPerformActionOnChildInTheFirstPlace);
 
       this.init();
       this.initSequence();
     }
 
@@ -300,21 +300,21 @@
         new unexpectedInvokerChecker(EVENT_HIDE, getAccessible(aChild2Id)),
         new unexpectedInvokerChecker(EVENT_REORDER, getAccessible(aParentId))
       ];
 
       this.invoke = function removeGrandChildrenNHideParent_invoke() {
         this.child1.remove();
         this.child2.remove();
         this.parent.hidden = true;
-      }
+      };
 
       this.getID = function removeGrandChildrenNHideParent_getID() {
         return "remove grand children of different parents and then hide their grand parent";
-      }
+      };
     }
 
     /**
      * Remove a child, and then its parent.
      */
     function test3() {
       this.o = getAccessible("t3_o");
       this.ofc = getAccessible("t3_o").firstChild;
@@ -324,26 +324,26 @@
         new invokerChecker(EVENT_REORDER, "t3_lb"),
         new unexpectedInvokerChecker(EVENT_HIDE, this.ofc),
         new unexpectedInvokerChecker(EVENT_REORDER, this.o)
       ];
 
       this.invoke = function test3_invoke() {
         getNode("t3_o").textContent = "";
         getNode("t3_lb").removeChild(getNode("t3_o"));
-      }
+      };
 
       this.finalCheck = function test3_finalCheck() {
         testIsDefunct(this.o);
         testIsDefunct(this.ofc);
-      }
+      };
 
       this.getID = function test3_getID() {
         return "remove a child, and then its parent";
-      }
+      };
     }
 
     /**
      * Remove children, and then a parent of 2nd child.
      */
     function test4() {
       this.o1 = getAccessible("t4_o1");
       this.o1fc = this.o1.firstChild;
@@ -358,27 +358,27 @@
         new unexpectedInvokerChecker(EVENT_REORDER, this.o1),
         new unexpectedInvokerChecker(EVENT_REORDER, this.o2)
       ];
 
       this.invoke = function test4_invoke() {
         getNode("t4_o1").textContent = "";
         getNode("t4_o2").textContent = "";
         getNode("t4_lb").removeChild(getNode("t4_o2"));
-      }
+      };
 
       this.finalCheck = function test4_finalCheck() {
         testIsDefunct(this.o1fc);
         testIsDefunct(this.o2);
         testIsDefunct(this.o2fc);
-      }
+      };
 
       this.getID = function test4_getID() {
         return "remove children, and then a parent of 2nd child";
-      }
+      };
     }
 
     /**
      * Remove a child, remove a parent sibling, remove the parent
      */
     function test5() {
       this.o = getAccessible("t5_o");
       this.ofc = this.o.firstChild;
@@ -393,27 +393,27 @@
         new unexpectedInvokerChecker(EVENT_REORDER, this.o),
         new unexpectedInvokerChecker(EVENT_REORDER, this.lb)
       ];
 
       this.invoke = function test5_invoke() {
         getNode("t5_o").textContent = "";
         getNode("t5").removeChild(getNode("t5_b"));
         getNode("t5_lb").removeChild(getNode("t5_o"));
-      }
+      };
 
       this.finalCheck = function test5_finalCheck() {
         testIsDefunct(this.ofc);
         testIsDefunct(this.o);
         testIsDefunct(this.b);
-      }
+      };
 
       this.getID = function test5_getID() {
         return "remove a child, remove a parent sibling, remove the parent";
-      }
+      };
     }
 
     /**
      * Insert accessibles with a child node moved by aria-owns
      * Markup:
      * <div id="t6_fc">
      *   <div id="t6_owns"></div>
      * </div>

--- a/accessible/tests/mochitest/events/test_contextmenu.html
+++ b/accessible/tests/mochitest/events/test_contextmenu.html
@@ -28,50 +28,50 @@
       this.DOMNode = getNode(aID);
 
       this.eventSeq = [
         new invokerChecker(EVENT_MENUPOPUP_START, getContextMenuNode()),
       ];
 
       this.invoke = function showContextMenu_invoke() {
         synthesizeMouse(this.DOMNode, 4, 4, { type: "contextmenu", button: 2 });
-      }
+      };
 
       this.getID = function showContextMenu_getID() {
         return "show context menu";
-      }
+      };
     }
 
     function selectMenuItem() {
       this.eventSeq = [
         new invokerChecker(EVENT_FOCUS, getFocusedMenuItem)
       ];
 
       this.invoke = function selectMenuItem_invoke() {
         synthesizeKey("VK_DOWN", { });
-      }
+      };
 
       this.getID = function selectMenuItem_getID() {
         return "select first menuitem";
-      }
+      };
     }
 
     function closeContextMenu(aID) {
       this.eventSeq = [
         new invokerChecker(EVENT_MENUPOPUP_END,
                            getAccessible(getContextMenuNode()))
       ];
 
       this.invoke = function closeContextMenu_invoke() {
         synthesizeKey("VK_ESCAPE", { });
-      }
+      };
 
       this.getID = function closeContextMenu_getID() {
         return "close context menu";
-      }
+      };
     }
 
     function getContextMenuNode() {
       return getRootAccessible().DOMDocument.
         getElementById("contentAreaContextMenu");
     }
 
     function getFocusedMenuItem() {

--- a/accessible/tests/mochitest/events/test_descrchange.html
+++ b/accessible/tests/mochitest/events/test_descrchange.html
@@ -23,21 +23,21 @@
   <script type="application/javascript">
     // //////////////////////////////////////////////////////////////////////////
     // Invokers
 
     function setAttr(aID, aAttr, aValue, aChecker) {
       this.eventSeq = [ aChecker ];
       this.invoke = function setAttr_invoke() {
         getNode(aID).setAttribute(aAttr, aValue);
-      }
+      };
 
       this.getID = function setAttr_getID() {
         return "set attr '" + aAttr + "', value '" + aValue + "'";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     // gA11yEventDumpToConsole = true; // debuggin
 
     var gQueue = null;

--- a/accessible/tests/mochitest/events/test_docload.html
+++ b/accessible/tests/mochitest/events/test_docload.html
@@ -46,35 +46,35 @@
 
       this.eventSeq = [
         new invokerChecker(EVENT_REORDER, getAccessible(this.DOMNode)),
         new asyncInvokerChecker(EVENT_DOCUMENT_LOAD_COMPLETE, getIframeDoc)
       ];
 
       this.invoke = function changeIframeSrc_invoke() {
         this.DOMNode.src = aURL;
-      }
+      };
 
       this.finalCheck = function changeIframeSrc_finalCheck() {
         var accTree = {
           role: ROLE_INTERNAL_FRAME,
           children: [
             {
               role: ROLE_DOCUMENT,
               name: aURL == "about:" ? "About:" : aURL
             }
           ]
         };
 
         testAccessibleTree(this.DOMNode, accTree);
-      }
+      };
 
       this.getID = function changeIframeSrc_getID() {
         return "change iframe src on " + aURL;
-      }
+      };
 
       function getIframeDoc() {
         return getAccessible(getNode(aIdentifier).contentDocument);
       }
     }
 
     const kHide = 1;
     const kShow = 2;
@@ -99,58 +99,58 @@
       this.invoke = function morphIFrame_invoke() {
         if (aAction == kHide) {
           this.DOMNode.style.display = "none";
         } else if (aAction == kShow) {
           this.DOMNode.style.display = "block";
         } else {
           this.IFrameContainerDOMNode.removeChild(this.DOMNode);
         }
-      }
+      };
 
       this.finalCheck = function morphIFrame_finalCheck() {
         var accTree = {
           role: ROLE_SECTION,
           children: (aAction == kHide || aAction == kRemove) ? [ ] :
             [
               {
                 role: ROLE_INTERNAL_FRAME,
                 children: [
                   { role: ROLE_DOCUMENT }
                 ]
               }
             ]
         };
 
         testAccessibleTree(this.IFrameContainerDOMNode, accTree);
-      }
+      };
 
       this.getID = function morphIFrame_getID() {
         if (aAction == kRemove)
           return "remove iframe";
 
         return "change display style of iframe to " +
           ((aAction == kHide) ? "none" : "block");
-      }
+      };
     }
 
     function makeIFrameVisible(aID) {
       this.DOMNode = getNode(aID);
 
       this.eventSeq = [
         new invokerChecker(EVENT_REORDER, this.DOMNode.parentNode)
       ];
 
       this.invoke = function makeIFrameVisible_invoke() {
         this.DOMNode.style.visibility = "visible";
-      }
+      };
 
       this.getID = function makeIFrameVisible_getID() {
         return "The accessible for DOM document loaded before it's shown shouldn't have busy state.";
-      }
+      };
     }
 
     function openDialogWnd(aURL) {
       // Get application root accessible.
       var docAcc = getAccessible(document);
       while (docAcc) {
         this.mRootAcc = docAcc;
         try {
@@ -162,21 +162,21 @@
       }
 
       this.eventSeq = [
         new invokerChecker(EVENT_REORDER, this.mRootAcc)
       ];
 
       this.invoke = function openDialogWnd_invoke() {
         this.mDialog = window.openDialog(aURL);
-      }
+      };
 
       this.finalCheck = function openDialogWnd_finalCheck() {
         this.finalCheckImpl();
-      }
+      };
 
       this.finalCheckImpl = function openDialogWnd_finalCheckImpl() {
         var accTree = {
           role: ROLE_APP_ROOT,
           children: [
             {
               role: ROLE_CHROME_WINDOW
             },
@@ -200,21 +200,21 @@
 
         this.mDialog.close();
 
         // close() is asynchronous.
         SimpleTest.executeSoon(function() {
           ok(!isAccessibleInCache(dlgDoc),
              "The document accessible for '" + aURL + "' is in cache still!");
         });
-      }
+      };
 
       this.getID = function openDialogWnd_getID() {
         return "open dialog '" + aURL + "'";
-      }
+      };
     }
 
     function openWndShutdownDoc() {
       this.__proto__ =
         new openDialogWnd("../events/docload_wnd.html");
 
       var thisObj = this;
       var docChecker = {
@@ -239,17 +239,17 @@
             "The document accessible for iframe is in cache still after iframe hide!");
 
         this.finalCheckImpl();
 
         // After the window is closed all alive subdocument accessibles should
         // be shut down.
         ok(!isAccessibleInCache(this.iframeDoc),
            "The document accessible for iframe is in cache still!");
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     var gQueue = null;
 
     // Debug stuff.

--- a/accessible/tests/mochitest/events/test_docload_aria.html
+++ b/accessible/tests/mochitest/events/test_docload_aria.html
@@ -26,21 +26,21 @@
       this.dialogNode = getNode(aID);
 
       this.eventSeq = [
         new invokerChecker(EVENT_DOCUMENT_LOAD_COMPLETE, this.dialogNode)
       ];
 
       this.invoke = function showARIADialog_invoke() {
         this.dialogNode.style.display = "block";
-      }
+      };
 
       this.getID = function showARIADialog_getID() {
         return "show ARIA dialog";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     var gQueue = null;
 
     // Debug stuff.

--- a/accessible/tests/mochitest/events/test_dragndrop.html
+++ b/accessible/tests/mochitest/events/test_dragndrop.html
@@ -27,44 +27,44 @@
     // aria grabbed invoker
     function changeGrabbed(aNodeOrID, aGrabValue) {
       this.DOMNode = getNode(aNodeOrID);
 
       this.invoke = function changeGrabbed_invoke() {
         if (aGrabValue != undefined) {
           this.DOMNode.setAttribute("aria-grabbed", aGrabValue);
         }
-      }
+      };
 
       this.check = function changeGrabbed_check() {
         testAttrs(aNodeOrID, {"grabbed": aGrabValue}, true);
-      }
+      };
 
       this.getID = function changeGrabbed_getID() {
         return prettyName(aNodeOrID) + " aria-grabbed changed";
-      }
+      };
     }
 
     // aria dropeffect invoker
     function changeDropeffect(aNodeOrID, aDropeffectValue) {
       this.DOMNode = getNode(aNodeOrID);
 
       this.invoke = function changeDropeffect_invoke() {
         if (aDropeffectValue != undefined) {
           this.DOMNode.setAttribute("aria-dropeffect", aDropeffectValue);
         }
-      }
+      };
 
       this.check = function changeDropeffect_check() {
         testAttrs(aNodeOrID, {"dropeffect": aDropeffectValue}, true);
-      }
+      };
 
       this.getID = function changeDropeffect_getID() {
         return prettyName(aNodeOrID) + " aria-dropeffect changed";
-      }
+      };
     }
 
     function doTests() {
       // Test aria attribute mutation events
       gQueue = new eventQueue(nsIAccessibleEvent.EVENT_OBJECT_ATTRIBUTE_CHANGED);
 
       var id = "grabbable";
       gQueue.push(new changeGrabbed(id, "true"));

--- a/accessible/tests/mochitest/events/test_focus_aria_activedescendant.html
+++ b/accessible/tests/mochitest/events/test_focus_aria_activedescendant.html
@@ -24,42 +24,42 @@ https://bugzilla.mozilla.org/show_bug.cg
 
     function changeARIAActiveDescendant(aID, aItemID) {
       this.eventSeq = [
         new focusChecker(aItemID)
       ];
 
       this.invoke = function changeARIAActiveDescendant_invoke() {
         getNode(aID).setAttribute("aria-activedescendant", aItemID);
-      }
+      };
 
       this.getID = function changeARIAActiveDescendant_getID() {
         return "change aria-activedescendant on " + aItemID;
-      }
+      };
     }
 
     function insertItemNFocus(aID, aNewItemID) {
       this.eventSeq = [
         new invokerChecker(EVENT_SHOW, aNewItemID),
         new focusChecker(aNewItemID)
       ];
 
       this.invoke = function insertItemNFocus_invoke() {
         var container  = getNode(aID);
         var itemNode = document.createElement("div");
         itemNode.setAttribute("id", aNewItemID);
         itemNode.textContent = aNewItemID;
         container.appendChild(itemNode);
 
         container.setAttribute("aria-activedescendant", aNewItemID);
-      }
+      };
 
       this.getID = function insertItemNFocus_getID() {
         return "insert new node and focus it with ID: " + aNewItemID;
-      }
+      };
     }
 
     var gQueue = null;
     function doTest() {
       gQueue = new eventQueue();
 
       gQueue.push(new synthFocus("listbox", new focusChecker("item1")));
       gQueue.push(new changeARIAActiveDescendant("listbox", "item2"));

--- a/accessible/tests/mochitest/events/test_focus_general.html
+++ b/accessible/tests/mochitest/events/test_focus_general.html
@@ -21,59 +21,59 @@
           src="../states.js"></script>
 
   <script type="application/javascript">
     function focusElmWhileSubdocIsFocused(aID) {
       this.DOMNode = getNode(aID);
 
       this.invoke = function focusElmWhileSubdocIsFocused_invoke() {
         this.DOMNode.focus();
-      }
+      };
 
       this.eventSeq = [
         new focusChecker(this.DOMNode)
       ];
 
       this.unexpectedEventSeq = [
         new invokerChecker(EVENT_FOCUS, this.DOMNode.ownerDocument)
       ];
 
       this.getID = function focusElmWhileSubdocIsFocused_getID() {
         return "Focus element while subdocument is focused " + prettyName(aID);
-      }
+      };
     }
 
     function imageMapChecker(aID) {
       var node = getNode(aID);
       this.type = EVENT_FOCUS;
       this.match = function imageMapChecker_match(aEvent) {
         return aEvent.DOMNode == node;
-      }
+      };
     }
 
     function topMenuChecker() {
       this.type = EVENT_FOCUS;
       this.match = function topMenuChecker_match(aEvent) {
         return aEvent.accessible.role == ROLE_PARENT_MENUITEM;
-      }
+      };
     }
 
     function contextMenuChecker() {
       this.type = EVENT_MENUPOPUP_START;
       this.match = function contextMenuChecker_match(aEvent) {
         return aEvent.accessible.role == ROLE_MENUPOPUP;
-      }
+      };
     }
 
     function focusContextMenuItemChecker() {
       this.__proto__ = new focusChecker();
 
       this.match = function focusContextMenuItemChecker_match(aEvent) {
         return aEvent.accessible.role == ROLE_MENUITEM;
-      }
+      };
     }
 
     /**
      * Do tests.
      */
 
     // gA11yEventDumpID = "eventdump"; // debug stuff
     // gA11yEventDumpToConsole = true;

--- a/accessible/tests/mochitest/events/test_focus_name.html
+++ b/accessible/tests/mochitest/events/test_focus_name.html
@@ -22,17 +22,17 @@
      */
     function actionChecker(aID, aDescription) {
       this.__proto__ = new invokerChecker(EVENT_FOCUS, aID);
 
       this.check = function actionChecker_check(aEvent) {
         var target = aEvent.accessible;
         is(target.description, aDescription,
            "Wrong description for " + prettyName(target));
-      }
+      };
     }
 
     var gFocusHandler = {
       handleEvent: function gFocusHandler_handleEvent(aEvent) {
         var elm = aEvent.target;
         if (elm.nodeType != nsIDOMNode.ELEMENT_NODE)
           return;
 
@@ -78,17 +78,17 @@
       // The aria-describedby is changed on DOM focus. Accessible description
       // should be updated when a11y focus is fired.
       gQueue = new eventQueue(nsIAccessibleEvent.EVENT_FOCUS);
       gQueue.onFinish = function() {
         gButtonElm.removeEventListener("focus", gFocusHandler);
         gButtonElm.removeEventListener("blur", gBlurHandler);
         gTextboxElm.removeEventListener("focus", gFocusHandler);
         gTextboxElm.removeEventListener("blur", gBlurHandler);
-      }
+      };
 
       var descr = "It's a tooltip";
       gQueue.push(new synthFocus("button", new actionChecker("button", descr)));
       gQueue.push(new synthTab("textbox", new actionChecker("textbox", descr)));
 
       gQueue.invoke(); // Will call SimpleTest.finish();
     }
 

--- a/accessible/tests/mochitest/events/test_fromUserInput.html
+++ b/accessible/tests/mochitest/events/test_fromUserInput.html
@@ -28,22 +28,22 @@
         new textChangeChecker(aID, aStart, aEnd, aText, false, aFromUser)
       ];
 
       this.invoke = function removeTextFromInput_invoke() {
         this.DOMNode.focus();
         this.DOMNode.setSelectionRange(aStart, aEnd);
 
         synthesizeKey("VK_DELETE", {});
-      }
+      };
 
       this.getID = function removeTextFromInput_getID() {
         return "Remove text from " + aStart + " to " + aEnd + " for " +
           prettyName(aID);
-      }
+      };
     }
 
     /**
      * Remove text data from text node.
      */
     function removeTextFromContentEditable(aID, aStart, aEnd, aText, aFromUser) {
       this.DOMNode = getNode(aID);
 
@@ -56,22 +56,22 @@
         this.textNode = getNode(aID).firstChild;
         var selection = window.getSelection();
         var range = document.createRange();
         range.setStart(this.textNode, aStart);
         range.setEnd(this.textNode, aEnd);
         selection.addRange(range);
 
         synthesizeKey("VK_DELETE", {});
-      }
+      };
 
       this.getID = function removeTextFromContentEditable_getID() {
         return "Remove text from " + aStart + " to " + aEnd + " for " +
           prettyName(aID);
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
     // gA11yEventDumpID = "eventdump"; // debug stuff
 
     var gQueue = null;
 

--- a/accessible/tests/mochitest/events/test_mutation.html
+++ b/accessible/tests/mochitest/events/test_mutation.html
@@ -55,47 +55,47 @@
         var type = this.getA11yEventType(aEventType);
         for (var idx = 0; idx < this.getEventSeq().length; idx++) {
           if (this.getEventSeq()[idx].type == type) {
             this.getEventSeq()[idx].target = aTarget;
             return idx;
           }
         }
         return -1;
-      }
+      };
 
       /**
        * Replace the default target currently registered for a given event type
        * with the nodes in the targets array.
        */
       this.setTargets = function mutateA11yTree_setTargets(aEventType, aTargets) {
         var targetIdx = this.setTarget(aEventType, aTargets[0]);
 
         var type = this.getA11yEventType(aEventType);
         for (var i = 1; i < aTargets.length; i++) {
           var checker = new invokerChecker(type, aTargets[i]);
           this.getEventSeq().splice(++targetIdx, 0, checker);
         }
-      }
+      };
 
       // Implementation
       this.getA11yEventType = function mutateA11yTree_getA11yEventType(aEventType) {
         if (aEventType == kReorderEvent)
           return nsIAccessibleEvent.EVENT_REORDER;
 
         if (aEventType == kHideEvent)
           return nsIAccessibleEvent.EVENT_HIDE;
 
         if (aEventType == kShowEvent)
           return nsIAccessibleEvent.EVENT_SHOW;
-      }
+      };
 
       this.getEventSeq = function mutateA11yTree_getEventSeq() {
         return this.doNotExpectEvents ? this.unexpectedEventSeq : this.eventSeq;
-      }
+      };
 
       if (aEventTypes & kHideEvent) {
         var checker = new invokerChecker(this.getA11yEventType(kHideEvent),
                                          this.DOMNode);
         this.getEventSeq().push(checker);
       }
 
       if (aEventTypes & kShowEvent) {
@@ -114,36 +114,36 @@
     /**
      * Change CSS style for the given node.
      */
     function changeStyle(aNodeOrID, aProp, aValue, aEventTypes) {
       this.__proto__ = new mutateA11yTree(aNodeOrID, aEventTypes, false);
 
       this.invoke = function changeStyle_invoke() {
         this.DOMNode.style[aProp] = aValue;
-      }
+      };
 
       this.getID = function changeStyle_getID() {
         return aNodeOrID + " change style " + aProp + " on value " + aValue;
-      }
+      };
     }
 
     /**
      * Change class name for the given node.
      */
     function changeClass(aParentNodeOrID, aNodeOrID, aClassName, aEventTypes) {
       this.__proto__ = new mutateA11yTree(aNodeOrID, aEventTypes, false);
 
       this.invoke = function changeClass_invoke() {
         this.parentDOMNode.className = aClassName;
-      }
+      };
 
       this.getID = function changeClass_getID() {
         return aNodeOrID + " change class " + aClassName;
-      }
+      };
 
       this.parentDOMNode = getNode(aParentNodeOrID);
     }
 
     /**
      * Clone the node and append it to its parent.
      */
     function cloneAndAppendToDOM(aNodeOrID, aEventTypes,
@@ -163,41 +163,41 @@
         this.setTargets(kShowEvent, targets);
 
         if (aReorderTargetFunc) {
           var reorderTarget = aReorderTargetFunc.call(null, this.DOMNode);
           this.setTarget(kReorderEvent, reorderTarget);
         }
 
         this.DOMNode.parentNode.appendChild(newElm);
-      }
+      };
 
       this.getID = function cloneAndAppendToDOM_getID() {
         return aNodeOrID + " clone and append to DOM.";
-      }
+      };
     }
 
     /**
      * Removes the node from DOM.
      */
     function removeFromDOM(aNodeOrID, aEventTypes,
                            aTargetsFunc, aReorderTargetFunc) {
       var eventTypes = aEventTypes || kHideEvents;
       var doNotExpectEvents = (aEventTypes == kNoEvents);
 
       this.__proto__ = new mutateA11yTree(aNodeOrID, eventTypes,
                                           doNotExpectEvents);
 
       this.invoke = function removeFromDOM_invoke() {
         this.DOMNode.remove();
-      }
+      };
 
       this.getID = function removeFromDOM_getID() {
         return prettyName(aNodeOrID) + " remove from DOM.";
-      }
+      };
 
       if (aTargetsFunc && (eventTypes & kHideEvent))
         this.setTargets(kHideEvent, aTargetsFunc.call(null, this.DOMNode));
 
       if (aReorderTargetFunc && (eventTypes & kReorderEvent))
         this.setTarget(kReorderEvent,
                        aReorderTargetFunc.call(null, this.DOMNode));
     }
@@ -206,21 +206,21 @@
      * Clone the node and replace the original node by cloned one.
      */
     function cloneAndReplaceInDOM(aNodeOrID) {
       this.__proto__ = new mutateA11yTree(aNodeOrID, kHideAndShowEvents,
                                           false);
 
       this.invoke = function cloneAndReplaceInDOM_invoke() {
         this.DOMNode.parentNode.replaceChild(this.newElm, this.DOMNode);
-      }
+      };
 
       this.getID = function cloneAndReplaceInDOM_getID() {
         return aNodeOrID + " clone and replace in DOM.";
-      }
+      };
 
       this.newElm = this.DOMNode.cloneNode(true);
       this.newElm.removeAttribute("id");
       this.setTarget(kShowEvent, this.newElm);
     }
 
     /**
      * Trigger content insertion (flush layout), removal and insertion of
@@ -236,22 +236,22 @@
         new invokerChecker(EVENT_REORDER, this.containerNode)
       ];
 
       this.invoke = function test1_invoke() {
         this.containerNode.appendChild(this.divNode);
         getComputedStyle(this.divNode, "").color;
         this.containerNode.removeChild(this.divNode);
         this.containerNode.appendChild(this.divNode);
-      }
+      };
 
       this.getID = function test1_getID() {
         return "fuzzy test #1: content insertion (flush layout), removal and" +
           "reinsertion";
-      }
+      };
     }
 
     /**
      * Trigger content insertion (flush layout), removal and insertion of
      * the same element for the different parents.
      */
     function test2(aContainerID, aTmpContainerID) {
       this.divNode = document.createElement("div");
@@ -270,22 +270,22 @@
         new invokerChecker(EVENT_REORDER, this.tmpContainerNode)
       ];
 
       this.invoke = function test2_invoke() {
         this.tmpContainerNode.appendChild(this.divNode);
         getComputedStyle(this.divNode, "").color;
         this.tmpContainerNode.removeChild(this.divNode);
         this.containerNode.appendChild(this.divNode);
-      }
+      };
 
       this.getID = function test2_getID() {
         return "fuzzy test #2: content insertion (flush layout), removal and" +
           "reinsertion under another container";
-      }
+      };
     }
 
     /**
      * Content insertion (flush layout) and then removal (nothing was changed).
      */
     function test3(aContainerID) {
       this.divNode = document.createElement("div");
       this.divNode.setAttribute("id", "div-test3");
@@ -296,100 +296,100 @@
         new invokerChecker(EVENT_HIDE, this.divNode),
         new invokerChecker(EVENT_REORDER, this.containerNode)
       ];
 
       this.invoke = function test3_invoke() {
         this.containerNode.appendChild(this.divNode);
         getComputedStyle(this.divNode, "").color;
         this.containerNode.removeChild(this.divNode);
-      }
+      };
 
       this.getID = function test3_getID() {
         return "fuzzy test #3: content insertion (flush layout) and removal";
-      }
+      };
     }
 
     function insertReferredElm(aContainerID) {
       this.containerNode = getNode(aContainerID);
 
       this.eventSeq = [
         new invokerChecker(EVENT_SHOW, function(aNode) { return aNode.firstChild; }, this.containerNode),
         new invokerChecker(EVENT_SHOW, function(aNode) { return aNode.lastChild; }, this.containerNode),
         new invokerChecker(EVENT_REORDER, this.containerNode)
       ];
 
       this.invoke = function insertReferredElm_invoke() {
         this.containerNode.innerHTML =
           "<span id='insertReferredElms_span'></span><input aria-labelledby='insertReferredElms_span'>";
-      }
+      };
 
       this.getID = function insertReferredElm_getID() {
         return "insert inaccessible element and then insert referring element to make it accessible";
-      }
+      };
     }
 
     function showHiddenParentOfVisibleChild() {
       this.eventSeq = [
         new invokerChecker(EVENT_HIDE, getNode("c4_child")),
         new invokerChecker(EVENT_SHOW, getNode("c4_middle")),
         new invokerChecker(EVENT_REORDER, getNode("c4"))
       ];
 
       this.invoke = function showHiddenParentOfVisibleChild_invoke() {
         getNode("c4_middle").style.visibility = "visible";
-      }
+      };
 
       this.getID = function showHiddenParentOfVisibleChild_getID() {
         return "show hidden parent of visible child";
-      }
+      };
     }
 
     function hideNDestroyDoc() {
       this.txt = null;
       this.eventSeq = [
         new invokerChecker(EVENT_HIDE, () => { return this.txt; })
       ];
 
       this.invoke = function hideNDestroyDoc_invoke() {
         this.txt = getAccessible("c5").firstChild.firstChild;
         this.txt.DOMNode.remove();
-      }
+      };
 
       this.check = function hideNDestroyDoc_check() {
         getNode("c5").remove();
-      }
+      };
 
       this.getID = function hideNDestroyDoc_getID() {
         return "remove text node and destroy a document on hide event";
-      }
+      };
     }
 
     function hideHideNDestroyDoc() {
       this.target = null;
       this.eventSeq = [
         new invokerChecker(EVENT_HIDE, () => { return this.target; })
       ];
 
       this.invoke = function hideHideNDestroyDoc_invoke() {
         var doc = getAccessible("c6").firstChild;
         var l1 = doc.firstChild;
         this.target = l1.firstChild;
         var l2 = doc.lastChild;
         l1.DOMNode.firstChild.remove();
         l2.DOMNode.firstChild.remove();
-      }
+      };
 
       this.check = function hideHideNDestroyDoc_check() {
         getNode("c6").remove();
-      }
+      };
 
       this.getID = function hideHideNDestroyDoc_getID() {
         return "remove text nodes (2 events in the queue) and destroy a document on first hide event";
-      }
+      };
     }
 
     /**
      * Target getters.
      */
     function getFirstChild(aNode) {
       return [aNode.firstChild];
     }

--- a/accessible/tests/mochitest/events/test_mutation.xhtml
+++ b/accessible/tests/mochitest/events/test_mutation.xhtml
@@ -41,21 +41,21 @@
         new invokerChecker(EVENT_SHOW, getButtonFromBinding, this.containerNode),
         new invokerChecker(EVENT_REORDER, this.containerNode)
       ];
 
       this.invoke = function insertBinding_invoke() {
         var span = document.createElement("span");
         span.setAttribute("style", "-moz-binding:url(#button)");
         this.containerNode.appendChild(span);
-      }
+      };
 
       this.getID = function insertBinding_getID() {
         return "insert button binding";
-      }
+      };
     }
 
     /**
      * Do tests.
      */
     var gQueue = null;
     // gA11yEventDumpID = "eventdump"; // debug stuff
     // gA11yEventDumpToConsole = true;

--- a/accessible/tests/mochitest/events/test_namechange.html
+++ b/accessible/tests/mochitest/events/test_namechange.html
@@ -23,39 +23,39 @@
   <script type="application/javascript">
     // //////////////////////////////////////////////////////////////////////////
     // Invokers
 
     function setAttr(aID, aAttr, aValue, aChecker) {
       this.eventSeq = [ aChecker ];
       this.invoke = function setAttr_invoke() {
         getNode(aID).setAttribute(aAttr, aValue);
-      }
+      };
 
       this.getID = function setAttr_getID() {
         return "set attr '" + aAttr + "', value '" + aValue + "'";
-      }
+      };
     }
 
     /**
      * No name change on an accessible, because the accessible is recreated.
      */
     function setAttr_recreate(aID, aAttr, aValue) {
       this.eventSeq = [
         new invokerChecker(EVENT_HIDE, getAccessible(aID)),
         new invokerChecker(EVENT_SHOW, aID)
       ];
       this.invoke = function setAttr_recreate_invoke() {
         todo(false, "No accessible recreation should happen, just name change event");
         getNode(aID).setAttribute(aAttr, aValue);
-      }
+      };
 
       this.getID = function setAttr_recreate_getID() {
         return "set attr '" + aAttr + "', value '" + aValue + "'";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     // gA11yEventDumpToConsole = true; // debuggin
 
     var gQueue = null;

--- a/accessible/tests/mochitest/events/test_selection_aria.html
+++ b/accessible/tests/mochitest/events/test_selection_aria.html
@@ -33,21 +33,21 @@
       ];
 
       this.invoke = function selectItem_invoke() {
         var itemNode = this.selectNode.querySelector("*[aria-selected='true']");
         if (itemNode)
           itemNode.removeAttribute("aria-selected");
 
         this.itemNode.setAttribute("aria-selected", "true");
-      }
+      };
 
       this.getID = function selectItem_getID() {
         return "select item " + prettyName(aItemID);
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     var gQueue = null;
 
     // gA11yEventDumpToConsole = true; // debug stuff

--- a/accessible/tests/mochitest/events/test_statechange.html
+++ b/accessible/tests/mochitest/events/test_statechange.html
@@ -41,17 +41,17 @@
           ok(false, "State change event was expected");
         }
 
         if (!event) { return; }
 
         ok(event.isExtraState, "Extra state change was expected");
         is(event.state, EXT_STATE_EDITABLE, "Wrong state of statechange event");
         ok(event.isEnabled, "Expected editable state to be enabled");
-      }
+      };
 
       this.getID = function editabledoc_getID() {
         return prettyName(aDocNode) + " editable state changed";
       };
     }
 
     function invalidInput(aNodeOrID) {
       this.DOMNode = getNode(aNodeOrID);
@@ -74,76 +74,76 @@
       this.DOMNode = getNode(aID);
 
       this.eventSeq = [
         new stateChangeChecker(STATE_CHECKED, false, aIsChecked, this.DOMNode)
       ];
 
       this.invoke = function changeCheckInput_invoke() {
         this.DOMNode.checked = aIsChecked;
-      }
+      };
 
       this.getID = function changeCheckInput_getID() {
         return "change checked state to '" + aIsChecked + "' for " +
           prettyName(aID);
-      }
+      };
     }
 
     function stateChangeOnFileInput(aID, aAttr, aValue,
                                     aState, aIsExtraState, aIsEnabled) {
       this.fileControlNode = getNode(aID);
       this.fileControl = getAccessible(this.fileControlNode);
       this.browseButton = this.fileControl.firstChild;
       // No state change events on the label.
 
       this.invoke = function stateChangeOnFileInput_invoke() {
         this.fileControlNode.setAttribute(aAttr, aValue);
-      }
+      };
 
       this.eventSeq = [
         new stateChangeChecker(aState, aIsExtraState, aIsEnabled, this.fileControl),
         new stateChangeChecker(aState, aIsExtraState, aIsEnabled, this.browseButton)
       ];
 
       this.getID = function stateChangeOnFileInput_getID() {
         return "inherited state change on file input on attribute '" + aAttr + "' change";
-      }
+      };
     }
 
     function dupeStateChange(aID, aAttr, aValue,
                              aState, aIsExtraState, aIsEnabled) {
       this.eventSeq = [
         new stateChangeChecker(aState, aIsExtraState, aIsEnabled, getNode(aID))
       ];
 
       this.invoke = function dupeStateChange_invoke() {
         getNode(aID).setAttribute(aAttr, aValue);
         getNode(aID).setAttribute(aAttr, aValue);
-      }
+      };
 
       this.getID = function dupeStateChange_getID() {
         return "duped state change events";
-      }
+      };
     }
 
     function oppositeStateChange(aID, aAttr, aState, aIsExtraState) {
       this.eventSeq = [ ];
       this.unexpectedEventSeq = [
         new stateChangeChecker(aState, aIsExtraState, false, getNode(aID)),
         new stateChangeChecker(aState, aIsExtraState, true, getNode(aID))
       ];
 
       this.invoke = function oppositeStateChange_invoke() {
         getNode(aID).setAttribute(aAttr, "false");
         getNode(aID).setAttribute(aAttr, "true");
-      }
+      };
 
       this.getID = function oppositeStateChange_getID() {
         return "opposite state change events";
-      }
+      };
     }
 
     /**
      * Change concomitant ARIA and native attribute at once.
      */
     function echoingStateChange(aID, aARIAAttr, aAttr, aValue,
                                aState, aIsExtraState, aIsEnabled) {
       this.eventSeq = [
@@ -154,21 +154,21 @@
         if (aValue == null) {
           getNode(aID).removeAttribute(aARIAAttr);
           getNode(aID).removeAttribute(aAttr);
 
         } else {
           getNode(aID).setAttribute(aARIAAttr, aValue);
           getNode(aID).setAttribute(aAttr, aValue);
         }
-      }
+      };
 
       this.getID = function echoingStateChange_getID() {
         return "enchoing ARIA and native attributes change";
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
 
     var gQueue = null;
 
     // var gA11yEventDumpID = "eventdump"; // debug stuff

--- a/accessible/tests/mochitest/events/test_text.html
+++ b/accessible/tests/mochitest/events/test_text.html
@@ -43,21 +43,21 @@
      * Remove inaccessible child node containing accessibles.
      */
     function removeChildSpan(aID) {
       this.__proto__ = new textRemoveInvoker(aID, 0, 5, "33322");
 
       this.invoke = function removeChildSpan_invoke() {
         // remove HTML span, a first child of the node
         this.DOMNode.firstChild.remove();
-      }
+      };
 
       this.getID = function removeChildSpan_getID() {
         return "Remove inaccessible span containing accessible nodes" + prettyName(aID);
-      }
+      };
     }
 
     /**
      * Insert inaccessible child node containing accessibles.
      */
     function insertChildSpan(aID, aInsertAllTogether) {
       this.__proto__ = new textInsertInvoker(aID, 0, 5, "33322");
 
@@ -81,61 +81,61 @@
           var fSpan = document.createElement("span");
           fSpan.textContent = "333";
           topSpan.appendChild(fSpan);
 
           var sSpan = document.createElement("span");
           sSpan.textContent = "22";
           topSpan.appendChild(sSpan);
         }
-      }
+      };
 
       this.getID = function insertChildSpan_getID() {
        return "Insert inaccessible span containing accessibles" +
           prettyName(aID);
-      }
+      };
     }
 
     /**
      * Remove child embedded accessible.
      */
     function removeChildDiv(aID) {
       this.__proto__ = new textRemoveInvoker(aID, 5, 6, kEmbedChar);
 
       this.invoke = function removeChildDiv_invoke() {
         var childDiv = this.DOMNode.childNodes[1];
 
         // Ensure accessible is created to get text remove event when it's
         // removed.
         getAccessible(childDiv);
 
         this.DOMNode.removeChild(childDiv);
-      }
+      };
 
       this.getID = function removeChildDiv_getID() {
         return "Remove accessible div from the middle of text accessible " +
           prettyName(aID);
-      }
+      };
     }
 
     /**
      * Insert child embedded accessible.
      */
     function insertChildDiv(aID) {
       this.__proto__ = new textInsertInvoker(aID, 5, 6, kEmbedChar);
 
       this.invoke = function insertChildDiv_invoke() {
         var childDiv = document.createElement("div");
         this.DOMNode.insertBefore(childDiv, this.DOMNode.childNodes[1]);
-      }
+      };
 
       this.getID = function insertChildDiv_getID() {
         return "Insert accessible div into the middle of text accessible " +
           prettyName(aID);
-      }
+      };
     }
 
     /**
      * Remove children from text container from first to last child or vice
      * versa.
      */
     function removeChildren(aID, aLastToFirst, aStart, aEnd, aText) {
       this.__proto__ = new textRemoveInvoker(aID, aStart, aEnd, aText);
@@ -143,63 +143,63 @@
       this.invoke = function removeChildren_invoke() {
         if (aLastToFirst) {
           while (this.DOMNode.firstChild)
             this.DOMNode.removeChild(this.DOMNode.lastChild);
         } else {
           while (this.DOMNode.firstChild)
             this.DOMNode.firstChild.remove();
         }
-      }
+      };
 
       this.getID = function removeChildren_getID() {
         return "remove children of " + prettyName(aID) +
           (aLastToFirst ? " from last to first" : " from first to last");
-      }
+      };
     }
 
     /**
      * Remove text from HTML input.
      */
     function removeTextFromInput(aID, aStart, aEnd, aText) {
       this.__proto__ = new textRemoveInvoker(aID, aStart, aEnd, aText);
 
       this.eventSeq.push(new invokerChecker(EVENT_TEXT_VALUE_CHANGE,
                                             this.DOMNode));
 
       this.invoke = function removeTextFromInput_invoke() {
         this.DOMNode.focus();
         this.DOMNode.setSelectionRange(aStart, aEnd);
 
         synthesizeKey("VK_DELETE", {});
-      }
+      };
 
       this.getID = function removeTextFromInput_getID() {
         return "Remove text from " + aStart + " to " + aEnd + " for " +
           prettyName(aID);
-      }
+      };
     }
 
     /**
      * Add text into HTML input.
      */
     function insertTextIntoInput(aID, aStart, aEnd, aText) {
       this.__proto__ = new textInsertInvoker(aID, aStart, aEnd, aText);
 
       this.eventSeq.push(new invokerChecker(EVENT_TEXT_VALUE_CHANGE,
                                             this.DOMNode));
 
       this.invoke = function insertTextIntoInput_invoke() {
         this.DOMNode.focus();
         synthesizeKey("a", {});
-      }
+      };
 
       this.getID = function insertTextIntoInput_getID() {
         return "Insert text to " + aStart + " for " + prettyName(aID);
-      }
+      };
     }
 
     /**
      * Remove text data from text node of editable area.
      */
     function removeTextFromEditable(aID, aStart, aEnd, aText, aTextNode) {
       this.__proto__ = new textRemoveInvoker(aID, aStart, aEnd, aText);
 
@@ -208,22 +208,22 @@
 
         var selection = window.getSelection();
         var range = document.createRange();
         range.setStart(this.textNode, aStart);
         range.setEnd(this.textNode, aEnd);
         selection.addRange(range);
 
         synthesizeKey("VK_DELETE", {});
-      }
+      };
 
       this.getID = function removeTextFromEditable_getID() {
         return "Remove text from " + aStart + " to " + aEnd + " for " +
           prettyName(aID);
-      }
+      };
 
       this.textNode = getNode(aTextNode);
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Do tests
     gA11yEventDumpToConsole = true; // debugging
 

--- a/accessible/tests/mochitest/events/test_text_alg.html
+++ b/accessible/tests/mochitest/events/test_text_alg.html
@@ -45,23 +45,23 @@
         if (event[3] == kUnexpected)
           this.unexpectedEventSeq.push(checker);
         else
           this.eventSeq.push(checker);
       }
 
       this.invoke = function changeText_invoke() {
         this.textNode.data = aValue;
-      }
+      };
 
       this.getID = function changeText_getID() {
         return "change text '" + shortenString(this.textData) + "' -> '" +
           shortenString(this.textNode.data) + "' for " +
           prettyName(this.containerNode);
-      }
+      };
     }
 
     function expStr(x, doublings) {
       for (var i = 0; i < doublings; ++i)
         x = x + x;
       return x;
     }
 

--- a/accessible/tests/mochitest/events/test_textattrchange.html
+++ b/accessible/tests/mochitest/events/test_textattrchange.html
@@ -40,38 +40,38 @@
         var editor = this.DOMNode.QueryInterface(nsIDOMNSEditableElement).editor;
         var spellChecker = new InlineSpellChecker(editor);
         spellChecker.enabled = true;
 
         // var spellchecker = editor.getInlineSpellChecker(true);
         // spellchecker.enableRealTimeSpell = true;
 
         this.DOMNode.value = "valid text inalid tixt";
-      }
+      };
 
       this.finalCheck = function spelledTextInvoker_finalCheck() {
         var defAttrs = buildDefaultTextAttrs(this.DOMNode, kInputFontSize,
                                              kNormalFontWeight,
                                              kInputFontFamily);
         testDefaultTextAttrs(aID, defAttrs);
 
         var attrs = { };
         var misspelledAttrs = {
           "invalid": "spelling"
         };
 
         testTextAttrs(aID, 0, attrs, defAttrs, 0, 11);
         testTextAttrs(aID, 11, misspelledAttrs, defAttrs, 11, 17);
         testTextAttrs(aID, 17, attrs, defAttrs, 17, 18);
         testTextAttrs(aID, 18, misspelledAttrs, defAttrs, 18, 22);
-      }
+      };
 
       this.getID = function spelledTextInvoker_getID() {
         return "text attribute change for misspelled text";
-      }
+      };
     }
 
     /**
      * Do tests.
      */
     // gA11yEventDumpID = "eventdump"; // debug stuff
     // gA11yEventDumpToConsole = true;
 

--- a/accessible/tests/mochitest/events/test_valuechange.html
+++ b/accessible/tests/mochitest/events/test_valuechange.html
@@ -38,106 +38,106 @@
         // Note: this should not fire an EVENT_VALUE_CHANGE when aria-valuetext
         // is not empty
         if (aValuenow != undefined)
           this.DOMNode.setAttribute("aria-valuenow", aValuenow);
 
         // Note: this should always fire an EVENT_VALUE_CHANGE
         if (aValuetext != undefined)
           this.DOMNode.setAttribute("aria-valuetext", aValuetext);
-      }
+      };
 
       this.check = function changeARIAValue_check() {
         var acc = getAccessible(aNodeOrID, [nsIAccessibleValue]);
         if (!acc)
           return;
 
         // Note: always test against valuetext first because the existence of
         // aria-valuetext takes precedence over aria-valuenow in gecko.
         is(acc.value, (aValuetext != undefined) ? aValuetext : aValuenow,
             "Wrong value of " + prettyName(aNodeOrID));
-      }
+      };
 
       this.getID = function changeARIAValue_getID() {
         return prettyName(aNodeOrID) + " value changed";
-      }
+      };
     }
 
     function changeValue(aID, aValue) {
       this.DOMNode = getNode(aID);
       this.eventSeq = [new invokerChecker(EVENT_TEXT_VALUE_CHANGE,
                                           this.DOMNode)
         ];
 
       this.invoke = function changeValue_invoke() {
         this.DOMNode.value = aValue;
-      }
+      };
 
       this.check = function changeValue_check() {
         var acc = getAccessible(this.DOMNode);
         is(acc.value, aValue, "Wrong value for " + prettyName(aID));
-      }
+      };
 
       this.getID = function changeValue_getID() {
         return prettyName(aID) + " value changed";
-      }
+      };
     }
 
     function changeProgressValue(aID, aValue) {
       this.DOMNode = getNode(aID);
       this.eventSeq = [new invokerChecker(EVENT_VALUE_CHANGE, this.DOMNode)];
 
       this.invoke = function changeProgressValue_invoke() {
          this.DOMNode.value = aValue;
-      }
+      };
 
       this.check = function changeProgressValue_check() {
         var acc = getAccessible(this.DOMNode);
         is(acc.value, aValue + "%", "Wrong value for " + prettyName(aID));
-      }
+      };
 
       this.getID = function changeProgressValue_getID() {
         return prettyName(aID) + " value changed";
-      }
+      };
     }
 
     function changeRangeValue(aID) {
       this.DOMNode = getNode(aID);
       this.eventSeq = [new invokerChecker(EVENT_VALUE_CHANGE, this.DOMNode)];
 
       this.invoke = function changeRangeValue_invoke() {
         synthesizeMouse(getNode(aID), 5, 5, { });
-      }
+      };
 
       this.finalCheck = function changeRangeValue_finalCheck() {
         var acc = getAccessible(this.DOMNode);
         is(acc.value, "0", "Wrong value for " + prettyName(aID));
-      }
+      };
 
       this.getID = function changeRangeValue_getID() {
         return prettyName(aID) + " range value changed";
-      }
+      };
     }
 
     function changeSelectValue(aID, aKey, aValue) {
       this.eventSeq =
         [ new invokerChecker(EVENT_TEXT_VALUE_CHANGE, getAccessible(aID)) ];
 
       this.invoke = function changeSelectValue_invoke() {
         getNode(aID).focus();
         synthesizeKey(aKey, {}, window);
-      }
+      };
 
       this.finalCheck = function changeSelectValue_finalCheck() {
         is(getAccessible(aID).value, aValue, "Wrong value for " + prettyName(aID));
-      }
+      };
 
       this.getID = function changeSelectValue_getID() {
         return `${prettyName(aID)} closed select value change on '${aKey}'' key press`;
-      }
+      };
     }
 
     // enableLogging("DOMEvents");
     // gA11yEventDumpToConsole = true;
     function doTests() {
       // Test initial values
       testValue("slider_vn", "5", 5, 0, 1000, 0);
       testValue("slider_vnvt", "plain", 0, 0, 5, 0);

--- a/accessible/tests/mochitest/focus/test_focusedChild.html
+++ b/accessible/tests/mochitest/focus/test_focusedChild.html
@@ -23,45 +23,45 @@
       this.eventSeq = [ new invokerChecker(EVENT_FOCUS,
                                            getDialogAccessible,
                                            this) ];
 
       this.invoke = function openWnd_invoke() {
         this.dialog = window.openDialog("about:mozilla",
                                         "AboutMozilla",
                                         "chrome,width=600,height=600");
-      }
+      };
 
       this.finalCheck = function openWnd_finalCheck() {
         var app = getApplicationAccessible();
         is(app.focusedChild, getDialogAccessible(this),
            "Wrong focused child");
 
         this.dialog.close();
-      }
+      };
 
       this.getID = function openWnd_getID() {
         return "focusedChild for application accessible";
-      }
+      };
 
       function getDialogAccessible(aInvoker) {
         return getAccessible(aInvoker.dialog.document);
       }
     }
 
     gA11yEventDumpToConsole = true;
     var gQueue = null;
 
     function doTest() {
       enableLogging("focus,doclifecycle");
       gQueue = new eventQueue();
 
       gQueue.push(new openWnd());
 
-      gQueue.onFinish = function() { disableLogging(); }
+      gQueue.onFinish = function() { disableLogging(); };
       gQueue.invoke(); // Will call SimpleTest.finish();
     }
 
     SimpleTest.waitForExplicitFinish();
     addA11yLoadEvent(doTest);
   </script>
 </head>
 

--- a/accessible/tests/mochitest/focus/test_takeFocus.html
+++ b/accessible/tests/mochitest/focus/test_takeFocus.html
@@ -24,21 +24,21 @@
 
     function takeFocusInvoker(aID) {
       this.accessible = getAccessible(aID);
 
       this.eventSeq = [ new focusChecker(this.accessible) ];
 
       this.invoke = function takeFocusInvoker_invoke() {
         this.accessible.takeFocus();
-      }
+      };
 
       this.getID = function takeFocusInvoker_getID() {
         return "takeFocus for " + prettyName(aID);
-      }
+      };
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Test
 
     // gA11yEventDumpToConsole = true; // debug stuff
 
     var gQueue = null;

--- a/accessible/tests/mochitest/grid.js
+++ b/accessible/tests/mochitest/grid.js
@@ -1,74 +1,74 @@
 const nsIDOMKeyEvent = Components.interfaces.nsIDOMKeyEvent;
 
 /**
  * Create grid object based on HTML table.
  */
 function grid(aTableIdentifier) {
   this.getRowCount = function getRowCount() {
     return this.table.rows.length - (this.table.tHead ? 1 : 0);
-  }
+  };
   this.getColsCount = function getColsCount() {
     return this.table.rows[0].cells.length;
-  }
+  };
 
   this.getRowAtIndex = function getRowAtIndex(aIndex) {
     return this.table.rows[this.table.tHead ? aIndex + 1 : aIndex];
-  }
+  };
 
   this.getMaxIndex = function getMaxIndex() {
     return this.getRowCount() * this.getColsCount() - 1;
-  }
+  };
 
   this.getCellAtIndex = function getCellAtIndex(aIndex) {
     var colsCount = this.getColsCount();
 
     var rowIdx = Math.floor(aIndex / colsCount);
     var colIdx = aIndex % colsCount;
 
     var row = this.getRowAtIndex(rowIdx);
     return row.cells[colIdx];
-  }
+  };
 
   this.getIndexByCell = function getIndexByCell(aCell) {
     var colIdx = aCell.cellIndex;
 
     var rowIdx = aCell.parentNode.rowIndex;
     if (this.table.tHead)
       rowIdx -= 1;
 
     var colsCount = this.getColsCount();
     return rowIdx * colsCount + colIdx;
-  }
+  };
 
   this.getCurrentCell = function getCurrentCell() {
     var rowCount = this.table.rows.length;
     var colsCount = this.getColsCount();
     for (var rowIdx = 0; rowIdx < rowCount; rowIdx++) {
       for (var colIdx = 0; colIdx < colsCount; colIdx++) {
         var cell = this.table.rows[rowIdx].cells[colIdx];
         if (cell.hasAttribute("tabindex"))
           return cell;
       }
     }
     return null;
-  }
+  };
 
   this.initGrid = function initGrid() {
     this.table.addEventListener("keypress", this);
     this.table.addEventListener("click", this);
-  }
+  };
 
   this.handleEvent = function handleEvent(aEvent) {
     if (aEvent instanceof nsIDOMKeyEvent)
       this.handleKeyEvent(aEvent);
     else
       this.handleClickEvent(aEvent);
-  }
+  };
 
   this.handleKeyEvent = function handleKeyEvent(aEvent) {
     if (aEvent.target.localName != "td")
       return;
 
     var cell = aEvent.target;
     switch (aEvent.keyCode) {
       case nsIDOMKeyEvent.DOM_VK_UP:
@@ -110,27 +110,27 @@ function grid(aTableIdentifier) {
         if (idx < this.getMaxIndex()) {
           cell.removeAttribute("tabindex");
           var nextcell = this.getCellAtIndex(idx + 1);
           nextcell.setAttribute("tabindex", "0");
           nextcell.focus();
         }
         break;
     }
-  }
+  };
 
   this.handleClickEvent = function handleClickEvent(aEvent) {
     if (aEvent.target.localName != "td")
       return;
 
     var curCell = this.getCurrentCell();
     var cell = aEvent.target;
 
     if (cell != curCell) {
       curCell.removeAttribute("tabindex");
       cell.setAttribute("tabindex", "0");
       cell.focus();
     }
-  }
+  };
 
   this.table = getNode(aTableIdentifier);
   this.initGrid();
 }