The Tor Browser: widget/tests/window_wheeltransaction.xul@97036ab72558 (annotated)

widget/tests/window_wheeltransaction.xul@97036ab72558 (annotated)

widget/tests/window_wheeltransaction.xul

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 <?xml version="1.0"?>
 <?xml-stylesheet href="chrome://global/skin" type="text/css"?>
 <window title="Wheel scroll tests"
   width="600" height="600"
   onload="onload();"
   onunload="onunload();"
   xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
   <script type="application/javascript"
           src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js" />
 <body xmlns="http://www.w3.org/1999/xhtml">
 <style type="text/css">
   #rootview {
     overflow: auto;
     width: 400px;
     height: 400px;
     border: 1px solid;
   }
   #container {
     overflow: auto;
     width: 600px;
     height: 600px;
   }
   #rootview pre {
     margin: 20px 0 20px 20px;
     padding: 0;
     overflow: auto;
     display: block;
     width: 100px;
     height: 100.5px;
     font-size: 16px;
   }
 </style>
 <div id="rootview" onscroll="onScrollView(event);">
   <div id="container">
     <pre id="subview1" onscroll="onScrollView(event);">
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
     </pre>
     <pre id="subview2" onscroll="onScrollView(event);">
 Text.
 Text.
 Text.
 Text.
 Text.
 Text.
 Text.
 Text.
 Text.
 Text.
     </pre>
     <pre id="subview3" onscroll="onScrollView(event);">
 Text. Text. Text. Text. Text. Text. Text. Text. Text. Text. Text.
     </pre>
   </div>
 </div>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 </pre>
 </body>
 <script class="testbody" type="application/javascript">
 <![CDATA[
 function ok(aCondition, aMessage)
 {
   window.opener.wrappedJSObject.SimpleTest.ok(aCondition, aMessage);
 }
 function is(aLeft, aRight, aMessage)
 {
   window.opener.wrappedJSObject.SimpleTest.is(aLeft, aRight, aMessage);
 }
 function isnot(aLeft, aRight, aMessage)
 {
   window.opener.wrappedJSObject.SimpleTest.isnot(aLeft, aRight, aMessage);
 }
 var gCurrentTestListStatus = { nextListIndex: 0 };
 var gCurrentTest;
 const kListenEvent_None                 = 0;
 const kListenEvent_OnScroll             = 1;
 const kListenEvent_OnScrollFailed       = 2;
 const kListenEvent_OnTransactionTimeout = 4;
 const kListenEvent_All = kListenEvent_OnScroll |
                          kListenEvent_OnScrollFailed |
                          kListenEvent_OnTransactionTimeout;
 var gLitesnEvents = kListenEvent_None;
 /**
  * At unexpected transaction timeout, we need to stop *all* timers.  But it is
  * difficult and it can be create more complex testing code.  So, we should use
  * only one timer at one time.  For that, we must store the timer id to this
  * variable.  And the functions which may be called via a timer must clear the
  * current timer by |_clearTimer| function.
  */
 var gTimer;
 var gPrefSvc = Components.classes["@mozilla.org/preferences-service;1"].
                getService(Components.interfaces.nsIPrefBranch);
 const kPrefSmoothScroll = "general.smoothScroll";
 const kPrefNameTimeout = "mousewheel.transaction.timeout";
 const kPrefNameIgnoreMoveDelay = "mousewheel.transaction.ignoremovedelay";
 const kDefaultTimeout = gPrefSvc.getIntPref(kPrefNameTimeout);
 const kDefaultIgnoreMoveDelay = gPrefSvc.getIntPref(kPrefNameIgnoreMoveDelay);
 gPrefSvc.setBoolPref(kPrefSmoothScroll, false);
 var gTimeout, gIgnoreMoveDelay;
 var gEnoughForTimeout, gEnoughForIgnoreMoveDelay;
 function setTimeoutPrefs(aTimeout, aIgnoreMoveDelay)
 {
   gPrefSvc.setIntPref(kPrefNameTimeout, aTimeout);
   gPrefSvc.setIntPref(kPrefNameIgnoreMoveDelay, aIgnoreMoveDelay);
   gTimeout = aTimeout;
   gIgnoreMoveDelay = aIgnoreMoveDelay;
   gEnoughForTimeout = gTimeout * 2;
   gEnoughForIgnoreMoveDelay = gIgnoreMoveDelay * 1.2;
 }
 function resetTimeoutPrefs()
 {
   if (gTimeout == kDefaultTimeout)
     return;
   setTimeoutPrefs(kDefaultTimeout, kDefaultIgnoreMoveDelay);
   initTestList();
 }
 function growUpTimeoutPrefs()
 {
   if (gTimeout != kDefaultTimeout)
     return;
   setTimeoutPrefs(5000, 1000);
   initTestList();
 }
 // setting enough time for testing.
 gPrefSvc.setIntPref(kPrefNameTimeout, gTimeout);
 gPrefSvc.setIntPref(kPrefNameIgnoreMoveDelay, gIgnoreMoveDelay);
 var gRootView = document.getElementById("rootview");
 var gSubView1 = document.getElementById("subview1");
 var gSubView2 = document.getElementById("subview2");
 var gSubView3 = document.getElementById("subview3");
 gRootView.addEventListener("MozMouseScrollFailed", onMouseScrollFailed, false);
 gRootView.addEventListener("MozMouseScrollTransactionTimeout",
                            onTransactionTimeout, false);
 function finish()
 {
   window.close();
 }
 function onload()
 {
   runNextTestList();
 }
 function onunload()
 {
   resetTimeoutPrefs();
   gPrefSvc.clearUserPref(kPrefSmoothScroll);
   disableNonTestMouseEvents(false);
   window.opener.wrappedJSObject.SimpleTest.finish();
 }
 const kSubView1Offset = { x: 20, y: 20 };
 const kSubView2Offset = { x: 20, y: 20 + 100 + 20 };
 const kSubView3Offset = { x: 20, y: 20 + (100 + 20) * 2 };
 function _getSubViewTestPtForV(aPt)
 {
   return { x: aPt.x + 10, y: aPt.y + 10 };
 }
 const kPtInRootViewForV = { x: kSubView1Offset.x + 10,
                             y: kSubView1Offset.y - 10 };
 const kPtInSubView1ForV = _getSubViewTestPtForV(kSubView1Offset);
 const kPtInSubView2ForV = _getSubViewTestPtForV(kSubView2Offset);
 const kPtInSubView3ForV = _getSubViewTestPtForV(kSubView3Offset);
 function _convertTestPtForH(aPt)
 {
   return { x: aPt.y, y: aPt.x };
 }
 const kPtInRootViewForH = _convertTestPtForH(kPtInRootViewForV);
 const kPtInSubView1ForH = _convertTestPtForH(kPtInSubView1ForV);
 const kPtInSubView2ForH = _convertTestPtForH(kPtInSubView2ForV);
 const kPtInSubView3ForH = _convertTestPtForH(kPtInSubView3ForV);
 /**
  * Define the tests here:
  *   Scrolls are processed async always.  Therefore, we need to call all tests
  *   by timer.  gTestLists is array of testing lists. In other words, an item
  *   of gTestList is a group of one or more testing. Each items has following
  *   properties:
  *
  *     - retryWhenTransactionTimeout
  *         The testing of wheel transaction might be fialed randomly by
  *         timeout.  Then, automatically the failed test list will be retested
  *         automatically only this number of times.
  *
  *     - steps
  *         This property is array of testing.  Each steps must have following
  *         properties at least.
  *
  *         - func
  *             This property means function which will be called via
  *             |setTimeout|.  The function cannot have params.  If you need
  *             some additional parameters, you can specify some original
  *             properties for the test function.  If you do so, you should
  *             document it in the testing function.
  *         - delay
  *             This property means delay time until the function to be called.
  *             I.e., the value used for the second param of |setTimeout|.
  *
  *         And also you need one more property when you call a testing function.
  *
  *         - description
  *             This property is description of the test.  This is used for
  *             logging.
  *
  *         At testing, you can access to current step via |gCurrentTest|.
  */
 var gTestLists;
 function initTestList()
 {
   gTestLists = [
     /**************************************************************************
      * Continuous scrolling test for |gRootView|
      *   |gRootView| has both scrollbars and it has three children which are
      *   |gSubView1|, |gSubView2| and |gSubView3|.  They have scrollbars.  If
      *   the current transaction targets |gRootView|, other children should not
      *   be scrolled even if the wheel events are fired on them.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Vertical wheel events should scroll |gRootView| even if the position
         // of wheel events in a child view which has scrollbar.
         { func: testContinuousScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Continuous scrolling test for root view (vertical/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Continuous scrolling test for root view (vertical/backward)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Horizontal wheel events should scroll |gRootView| even if the
         // position of wheel events in a child view which has scrollbar.
         { func: testContinuousScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Continuous scrolling test for root view (horizontal/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Continuous scrolling test for root view (horizontal/backward)" }
       ]
     },
     /**************************************************************************
      * Continuous scrolling test for |gSubView1|
      *   |gSubView1| has both scrollbars.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Vertical wheel events should scroll |gSubView1|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Continuous scrolling test for sub view 1 (vertical/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: false, isVertical: true, expectedView: gSubView1,
           description: "Continuous scrolling test for sub view 1 (vertical/backward)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Horitontal wheel events should scroll |gSubView1|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           description: "Continuous scrolling test for sub view 1 (horizontal/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: false, isVertical: false, expectedView: gSubView1,
           description: "Continuous scrolling test for sub view 1 (horizontal/backward)" }
       ]
     },
     /**************************************************************************
      * Continuous scrolling test for |gSubView2|
      *   |gSubView2| has only vertical scrollbar.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Vertical wheel events should scroll |gSubView2|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView2ForV,
           isForward: true, isVertical: true, expectedView: gSubView2,
           description: "Continuous scrolling test for sub view 2 (vertical/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView2ForV,
           isForward: false, isVertical: true, expectedView: gSubView2,
           description: "Continuous scrolling test for sub view 2 (vertical/backward)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Horizontal wheel events should scroll its nearest scrollable ancestor
         // view, i.e., it is |gRootView|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView2ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Continuous scrolling test for sub view 2 (horizontal/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView2ForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Continuous scrolling test for sub view 2 (horizontal/backward)" }
       ]
     },
     /**************************************************************************
      * Continuous scrolling test for |gSubView3|
      *   |gSubView3| has only horizontal scrollbar.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Vertical wheel events should scroll its nearest scrollable ancestor
         // view, i.e., it is |gRootView|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView3ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Continuous scrolling test for sub view 3 (vertical/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView3ForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Continuous scrolling test for sub view 3 (vertical/backward)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Horitontal wheel events should scroll |gSubView3|.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView3ForH,
           isForward: true, isVertical: false, expectedView: gSubView3,
           description: "Continuous scrolling test for sub view 3 (horizontal/forward)" },
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView3ForH,
           isForward: false, isVertical: false, expectedView: gSubView3,
           description: "Continuous scrolling test for sub view 3 (horizontal/backward)" }
       ]
     },
     /**************************************************************************
      * Don't reset transaction by a different direction wheel event
      *   Even if a wheel event doesn't same direction as last wheel event, the
      *   current transaction should not be reset.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical -> Horizontal
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView| by a vertical wheel
         // event.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Don't reset transaction by a different direction wheel event (1-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Don't reset transaction by a different direction wheel event (1-2)" },
         // Send a horizontal wheel event over |gSubView1| but |gRootView| should
         // be scrolled.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Don't reset transaction by a different direction wheel event (1-3)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal -> Vertical
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView| by a horizontal wheel
         // event.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Don't reset transaction by a different direction wheel event (2-1)" },
         // Scroll back to left-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Don't reset transaction by a different direction wheel event (2-2)" },
         // Send a vertical wheel event over |gSubView1| but |gRootView| should
         // be scrolled.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Don't reset transaction by a different direction wheel event (2-3)" }
       ]
     },
     /**************************************************************************
      * Don't reset transaction even if a wheel event cannot scroll
      *   Even if a wheel event cannot scroll to specified direction in the
      *   current target view, the transaction should not be reset.  E.g., there
      *   are some devices which can scroll obliquely.  If so, probably, users
      *   cannot input only intended direction.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // A view only has vertical scrollbar case.
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gSubView2|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView2ForV,
           isForward: true, isVertical: true, expectedView: gSubView2,
           description: "Don't reset transaction even if a wheel event cannot scroll (1-1)" },
         // |gSubView2| doesn't have horizontal scrollbar but should not scroll
         // any views.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView2ForV,
           isForward: true, isVertical: false, expectedView: null,
           description: "Don't reset transaction even if a wheel event cannot scroll (1-2)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // A view only has horizontal scrollbar case.
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gSubView3|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView3ForV,
           isForward: true, isVertical: false, expectedView: gSubView3,
           description: "Don't reset transaction even if a wheel event cannot scroll (2-1)" },
         // |gSubView3| doesn't have vertical scrollbar but should not scroll any
         // views.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView3ForV,
           isForward: true, isVertical: true, expectedView: null,
           description: "Don't reset transaction even if a wheel event cannot scroll (2-2)" }
       ]
     },
     /**************************************************************************
      * Reset transaction by mouse down/mouse up events
      *   Mouse down and mouse up events should cause resetting the current
      *   transaction.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by mouse down/mouse up events (v-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by mouse down/mouse up events (v-2)" },
         // Send mouse button events which should reset the current transaction.
         // So, the next wheel event should scroll |gSubView1|.
         { func: sendMouseButtonEvents, delay: 0,
           description: "sendMouseButtonEvents" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Reset transaction by mouse down/mouse up events (v-3)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Reset transaction by mouse down/mouse up events (h-1)" },
         // Scroll back to left-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Reset transaction by mouse down/mouse up events (h-2)" },
         // Send mouse button events which should reset the current transaction.
         // So, the next wheel event should scroll |gSubView1|.
         { func: sendMouseButtonEvents, delay: 0,
           description: "sendMouseButtonEvents" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           description: "Reset transaction by mouse down/mouse up events (h-3)" }
       ]
     },
     /**************************************************************************
      * Reset transaction by a key event
      *   A key event should cause resetting the current transaction.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a key event (v-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a key event (v-2)" },
         // Send a key event which should reset the current transaction.  So, the
         // next wheel event should scroll |gSubView1|.
         { func: sendKeyEvents, delay: 0, key: "a",
           description: "sendKeyEvents" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Reset transaction by a key event (v-3)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Reset transaction by a key event (h-1)" },
         // Scroll back to left-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Reset transaction by a key event (h-2)" },
         // Send a key event which should reset the current transaction.  So, the
         // next wheel event should scroll |gSubView1|.
         { func: sendKeyEvents, delay: 0, key: "a",
           description: "sendKeyEvents" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           description: "Reset transaction by a key event (h-3)" }
       ]
     },
     /**************************************************************************
      * Reset transaction by a mouse move event
      *   A mouse move event can cause reseting the current transaction even if
      *   mouse cursor is inside the target view of current transaction. Only
      *   when a wheel event is fired after |gIgnoreMoveDelay| milliseconds since
      *   the first mouse move event from last wheel event, the transaction
      *   should be reset.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a mouse move event (v-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a mouse move event (v-2)" },
         // Send a mouse move event immediately after last wheel event, then,
         // current transaction should be kept.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInSubView1ForV,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-3)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-4)" },
         // Send a mouse move event after |gIgnoreMoveDelay| milliseconds since
         // last wheel event, then, current transaction should be kept.
         { func: sendMouseMoveEvent, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForV,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-5)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-6)" },
         // Send a wheel event after |gIgnoreMoveDelay| milliseconds since last
         // mouse move event but it is fired immediately after the last wheel
         // event, then, current transaction should be kept.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInSubView1ForV,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-7)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (v-8)" },
         // Send a wheel event after |gIgnoreMoveDelay| milliseconds have passed
         // since last mouse move event which is fired after |gIgnoreMoveDelay|
         // milliseconds since last wheel event, then, current transaction should
         // be reset.
         { func: sendMouseMoveEvent, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForV,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           canFailRandomly: { possibleView: gRootView },
           description: "Reset transaction by a mouse move event (v-9)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-2)" },
         // Send a mouse move event immediately after last wheel event, then,
         // current transaction should be kept.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInSubView1ForH,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-3)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-4)" },
         // Send a mouse move event after |gIgnoreMoveDelay| milliseconds since
         // last wheel event, then, current transaction should be kept.
         { func: sendMouseMoveEvent, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForH,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-5)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-6)" },
         // Send a wheel event after |gIgnoreMoveDelay| milliseconds since last
         // mouse move event but it is fired immediately after the last wheel
         // event, then, current transaction should be kept.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInSubView1ForH,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-7)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Reset transaction by a mouse move event (h-8)" },
         // Send a wheel event after |gIgnoreMoveDelay| milliseconds have passed
         // since last mouse move event which is fired after |gIgnoreMoveDelay|
         // milliseconds since last wheel event, then, current transaction should
         // be reset.
         { func: sendMouseMoveEvent, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForH,
           description: "sendMouseMoveEvent" },
         { func: testOneTimeScroll, delay: gEnoughForIgnoreMoveDelay,
           offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           canFailRandomly: { possibleView: gRootView },
           description: "Reset transaction by a mouse move event (h-9)" }
       ]
     },
     /**************************************************************************
      * Reset transaction by a mouse move event on outside of view
      *   When mouse cursor is moved to outside of the current target view, the
      *   transaction should be reset immediately.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gSubView1|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Reset transaction by a mouse move event on outside of view (v-1)" },
         // Send mouse move event over |gRootView|.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInRootViewForV,
           description: "sendMouseMoveEvent" },
         // Send Wheel event over |gRootView| which should be scrolled.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a mouse move event on outside of view (v-2)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Create a transaction which targets |gSubView1|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Reset transaction by a mouse move event on outside of view (h-1)" },
         // Send mouse move event over |gRootView|.
         { func: sendMouseMoveEvent, delay: 0, offset: kPtInRootViewForH,
           description: "sendMouseMoveEvent" },
         // Send Wheel event over |gRootView| which should be scrolled.
         { func: testOneTimeScroll, delay: 0,  offset: kPtInRootViewForH,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Reset transaction by a mouse move event on outside of view (h-2)" }
       ]
     },
     /**************************************************************************
      * Timeout test
      *   A view should not be scrolled during another to be transaction for
      *   another view scrolling. However, a wheel event which is sent after
      *   timeout, a view which is under the mouse cursor should be scrolled.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // First, create a transaction which should target the |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Timeout test (v-1)" },
         // Scroll back to top-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           description: "Timeout test (v-2)" },
         // A wheel event over |gSubView1| should not scroll it during current
         // transaction.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Timeout test (v-3)" },
         // Scroll back to top-most again.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: false, isVertical: true, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Timeout test (v-4)" },
         // A wheel event over |gSubView1| after timeout should scroll
         // |gSubView1|.
         { func: testOneTimeScroll, delay: gEnoughForTimeout,
           offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           isTimeoutTesting: true,
           description: "Timeout test (v-5)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // First, create a transaction which should target the |gRootView|.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Timeout test (h-1)" },
         // Scroll back to left-most for easy cursor position specifying.
         { func: testOneTimeScroll, delay: 0, offset: kPtInRootViewForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           description: "Timeout test (h-2)" },
         // A wheel event over |gSubView1| should not scroll it during current
         // transaction.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Timeout test (h-3)" },
         // Scroll back to left-most again.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: false, isVertical: false, expectedView: gRootView,
           canFailRandomly: { possibleView: gSubView1 },
           description: "Timeout test (h-4)" },
         // A wheel event over |gSubView1| after timeout should scroll
         // |gSubView1|.
         { func: testOneTimeScroll, delay: gEnoughForTimeout,
           offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           isTimeoutTesting: true,
           description: "Timeout test (h-5)" }
       ]
     },
     /**************************************************************************
      * Timeout test even with many wheel events
      *   This tests whether timeout is occurred event if wheel events are sent.
      *   The transaction should not be updated by non-scrollable wheel events.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Vertical case
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Scroll |gSubView1| to bottom-most.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           description: "Timeout test even with many wheel events (v-1)" },
         // Don't scroll any views before timeout.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: null,
           canFailRandomly: { possibleView: gRootView },
           description: "Timeout test even with many wheel events (v-2)" },
         // Recreate a transaction which is scrolling |gRootView| after time out.
         { func: testRestartScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gRootView,
           description: "Timeout test even with many wheel events (v-3)" }
       ]
     },
     { retryWhenTransactionTimeout: 5,
       steps: [
         // Horizontal case
         { func: initElements, delay: 0, forVertical: false,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         // Scroll |gSubView1| to right-most.
         { func: testContinuousScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gSubView1,
           description: "Timeout test even with many wheel events (h-1)" },
         // Don't scroll any views before timeout.
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: null,
           canFailRandomly: { possibleView: gRootView },
           description: "Timeout test even with many wheel events (h-2)" },
         // Recreate a transaction which is scrolling |gRootView| after time out.
         { func: testRestartScroll, delay: 0, offset: kPtInSubView1ForH,
           isForward: true, isVertical: false, expectedView: gRootView,
           description: "Timeout test even with many wheel events (h-3)" }
       ]
     },
     /**************************************************************************
      * Very large scrolling wheel event
      *   If the delta value is larger than the scrolling page size, it should be
      *   scrolled only one page instead of the delta value.
      **************************************************************************/
     { retryWhenTransactionTimeout: 5,
       steps: [
         { func: initElements, delay: 0, forVertical: true,
           description: "initElements" },
         { func: clearWheelTransaction, delay: 0,
           description: "clearWheelTransaction" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           delta: 5000,
           description: "Very large delta scrolling (v-1)" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: true, expectedView: gSubView1,
           delta: 5000,
           description: "Very large delta scrolling (v-2)" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: false, expectedView: gSubView1,
           delta: 5000,
           description: "Very large delta scrolling (h-1)" },
         { func: testOneTimeScroll, delay: 0, offset: kPtInSubView1ForV,
           isForward: true, isVertical: false, expectedView: gSubView1,
           delta: 5000,
           description: "Very large delta scrolling (h-2)" }
       ]
     }
   ];
 }
 /******************************************************************************
  * Actions for preparing tests
  ******************************************************************************/
 function initElements()
 {
   _clearTimer();
   function resetScrollPosition(aElement)
   {
     aElement.scrollTop = 0;
     aElement.scrollLeft = 0;
   }
   function initInRootView(aElement, aPt)
   {
     aElement.offset =
       gCurrentTest.forVertical ? aPt : { x: aPt.y, y: aPt.x };
   }
   const kDisplay = gCurrentTest.forVertical ? "block" : "inline-block";
   gSubView1.style.display = kDisplay;
   gSubView2.style.display = kDisplay;
   gSubView3.style.display = kDisplay;
   resetScrollPosition(gRootView);
   resetScrollPosition(gSubView1);
   resetScrollPosition(gSubView2);
   resetScrollPosition(gSubView3);
   runNextTestStep();
 }
 function clearWheelTransaction()
 {
   _clearTimer();
   _clearTransaction();
   runNextTestStep();
 }
 function sendKeyEvents()
 {
   _clearTimer();
   synthesizeKey(gCurrentTest.key, {}, window);
   runNextTestStep();
 }
 function sendMouseButtonEvents()
 {
   _clearTimer();
   synthesizeMouse(gRootView, -1, -1, { type:"mousedown" }, window);
   synthesizeMouse(gRootView, -1, -1, { type:"mouseup" }, window);
   runNextTestStep();
 }
 function sendMouseMoveEvent()
 {
   _clearTimer();
   _fireMouseMoveEvent(gCurrentTest.offset);
   runNextTestStep();
 }
 /******************************************************************************
  * Utilities for testing functions
  ******************************************************************************/
 function _clearTransaction()
 {
   synthesizeMouse(gRootView, -1, -1, { type:"mousedown" }, window);
   synthesizeMouse(gRootView, -1, -1, { type:"mouseup" }, window);
 }
 function _saveScrollPositions()
 {
   function save(aElement)
   {
     aElement.prevTop = aElement.scrollTop;
     aElement.prevLeft = aElement.scrollLeft;
   }
   save(gRootView);
   save(gSubView1);
   save(gSubView2);
   save(gSubView3);
 }
 function _fireMouseMoveEvent(aOffset)
 {
   synthesizeMouse(gRootView, aOffset.x, aOffset.y, { type:"mousemove" }, window);
 }
 function _fireWheelScrollEvent(aOffset, aIsVertical, aForward, aDelta)
 {
   var event = { deltaMode: WheelEvent.DOM_DELTA_LINE };
   if (aIsVertical) {
     event.deltaY = aForward ? aDelta : -aDelta;
   } else {
     event.deltaX = aForward ? aDelta : -aDelta;
   }
   synthesizeWheel(gRootView, aOffset.x, aOffset.y, event, window);
 }
 function _canScroll(aElement, aIsVertical, aForward)
 {
   if (aIsVertical) {
     if (!aForward)
       return aElement.scrollTop > 0;
     return aElement.scrollHeight > aElement.scrollTop + aElement.clientHeight;
   }
   if (!aForward)
     return aElement.scrollLeft > 0;
   return aElement.scrollWidth > aElement.scrollLeft + aElement.clientWidth;
 }
 const kNotScrolled      = 0;
 const kScrolledToTop    = 1;
 const kScrolledToBottom = 2;
 const kScrolledToLeft   = 4;
 const kScrolledToRight  = 8;
 const kScrolledVertical   = kScrolledToTop | kScrolledToBottom;
 const kScrolledHorizontal = kScrolledToLeft | kScrolledToRight;
 function _getScrolledState(aElement)
 {
   var ret = kNotScrolled;
   if (aElement.scrollTop != aElement.prevTop) {
     ret |= aElement.scrollTop < aElement.prevTop ? kScrolledToTop :
                                                    kScrolledToBottom;
   }
   if (aElement.scrollLeft != aElement.prevLeft) {
     ret |= aElement.scrollLeft < aElement.prevLeft ? kScrolledToLeft :
                                                      kScrolledToRight;
   }
   return ret;
 }
 function _getExpectedScrolledState()
 {
   return gCurrentTest.isVertical ?
            gCurrentTest.isForward ? kScrolledToBottom : kScrolledToTop :
            gCurrentTest.isForward ? kScrolledToRight : kScrolledToLeft;
 }
 function _getScrolledStateText(aScrolledState)
 {
   if (aScrolledState == kNotScrolled)
     return "Not scrolled";
   var s = "scrolled to ";
   if (aScrolledState & kScrolledVertical) {
     s += aScrolledState & kScrolledToTop ? "backward" : "forward";
     s += " (vertical)"
     if (aScrolledState & kScrolledHorizontal)
       s += " and to ";
   }
   if (aScrolledState & kScrolledHorizontal) {
     s += aScrolledState & kScrolledToLeft ? "backward" : "forward";
     s += " (horizontal)"
   }
   return s;
 }
 function _getCurrentTestList()
 {
   return gTestLists[gCurrentTestListStatus.nextListIndex - 1];
 }
 function _clearTimer()
 {
   clearTimeout(gTimer);
   gTimer = 0;
 }
 /******************************************************************************
  * Testing functions
  ******************************************************************************/
 /**
  * Note that testing functions must set following variables:
  *
  *   gCurrentTest.repeatTest:  See comment in |continueTest|.
  *   gCurrentTest.autoRepeatDelay:  See comment in |continueTest|.
  *   gListenScrollEvent: When this is not true, the event handlers ignores the
  *                       events.
  */
 function testContinuousScroll()
 {
   /**
    * Testing continuous scrolling.  This function synthesizes a wheel event.  If
    * the test was success, this function will be recalled automatically.
    * And when a generating wheel event cannot scroll the expected view, this
    * function fires the wheel event only one time.
    *
    * @param gCurrentTest.offset
    *          The cursor position of firing wheel event.  The values are offset
    *          from |gRootView|.
    * @param gCurrentTest.isVertical
    *          Whether the wheel event is for virtical scrolling or horizontal.
    * @param gCurrentTest.isForward
    *          Whether the wheel event is to forward or to backward.
    * @param gCurrentTest.expectedView
    *          The expected view which will be scrolled by wheel event. This
    *          value must not be null.
    */
   _clearTimer();
   _saveScrollPositions();
   if (!gCurrentTest.expectedView) {
     runNextTestStep();
     return;
   }
   gLitesnEvents = kListenEvent_All;
   gCurrentTest.repeatTest = true;
   gCurrentTest.autoRepeatDelay = 0;
   if (!_canScroll(gCurrentTest.expectedView,
                   gCurrentTest.isVertical, gCurrentTest.isForward)) {
     gCurrentTest.expectedView = null;
   }
   var delta = gCurrentTest.delta ? gCurrentTest.delta : 4;
   _fireWheelScrollEvent(gCurrentTest.offset,
                         gCurrentTest.isVertical, gCurrentTest.isForward, delta);
 }
 function testOneTimeScroll()
 {
   /**
    * Testing one wheel event.  |runNextTestStep| will be called immediately
    * after this function by |onScrollView| or |onTimeout|.
    *
    * @param gCurrentTest.offset
    *          The cursor position of firing wheel event.  The values are offset
    *          from |gRootView|.
    * @param gCurrentTest.isVertical
    *          Whether the wheel event is for virtical scrolling or horizontal.
    * @param gCurrentTest.isForward
    *          Whether the wheel event is to forward or to backward.
    * @param gCurrentTest.expectedView
    *          The expected view which will be scrolled by wheel event. This
    *          value can be null.  It means any views should not be scrolled.
    */
   _clearTimer();
   _saveScrollPositions();
   gLitesnEvents = kListenEvent_All;
   gCurrentTest.repeatTest = false;
   gCurrentTest.autoRepeatDelay = 0;
   var delta = gCurrentTest.delta ? gCurrentTest.delta : 4;
   _fireWheelScrollEvent(gCurrentTest.offset,
                         gCurrentTest.isVertical, gCurrentTest.isForward, delta);
 }
 function testRestartScroll()
 {
   /**
    * Testing restart to scroll in expected view after timeout from the current
    * transaction.  This function recall this itself until to success this test
    * or timeout from this test.
    *
    * @param gCurrentTest.offset
    *          The cursor position of firing wheel event.  The values are offset
    *          from |gRootView|.
    * @param gCurrentTest.isVertical
    *          Whether the wheel event is for virtical scrolling or horizontal.
    * @param gCurrentTest.isForward
    *          Whether the wheel event is to forward or to backward.
    * @param gCurrentTest.expectedView
    *          The expected view which will be scrolled by wheel event. This
    *          value must not be null.
    */
   _clearTimer();
   _saveScrollPositions();
   if (!gCurrentTest.wasTransactionTimeout) {
     gCurrentTest.repeatTest = true;
     gCurrentTest.autoRepeatDelay = gTimeout / 3;
     gLitesnEvents = kListenEvent_All;
     gCurrentTest.isTimeoutTesting = true;
     if (gCurrentTest.expectedView) {
       gCurrentTest.expectedViewAfterTimeout = gCurrentTest.expectedView;
       gCurrentTest.expectedView = null;
     }
   } else {
     gCurrentTest.repeatTest = false;
     gCurrentTest.autoRepeatDelay = 0;
     gLitesnEvents = kListenEvent_All;
     gCurrentTest.isTimeoutTesting = false;
     gCurrentTest.expectedView = gCurrentTest.expectedViewAfterTimeout;
   }
   var delta = gCurrentTest.delta ? gCurrentTest.delta : 4;
   _fireWheelScrollEvent(gCurrentTest.offset,
                         gCurrentTest.isVertical, gCurrentTest.isForward, delta);
 }
 /******************************************************************************
  * Event handlers
  ******************************************************************************/
 function onScrollView(aEvent)
 {
   /**
    * Scroll event handler of |gRootView|, |gSubView1|, |gSubView2| and
    * |gSubView3|.  If testing is failed, this function cancels all left tests.
    * For checking the event is expected, the event firer must call
    * |_saveScrollPositions|.
    *
    * @param gCurrentTest.expectedView
    *          The expected view which should be scrolled by the wheel event.
    *          This value can be null.  It means any views should not be
    *          scrolled.
    * @param gCurrentTest.isVertical
    *          The expected view should be scrolled vertical or horizontal.
    * @param gCurrentTest.isForward
    *          The expected view should be scrolled to forward or backward.
    * @param gCurrentTest.canFailRandomly
    *          If this is not undefined, this test can fail by unexpected view
    *          scrolling which is caused by unexpected timeout.  If this is
    *          defined, |gCurrentTest.possibleView| must be set.  If the view is
    *          same as the event target, the failure can be random.  At this
    *          time, we should retry the current test list.
    */
   if (!(gLitesnEvents & kListenEvent_OnScroll))
     return;
   // Now testing a timeout, but a view is scrolled before timeout.
   if (gCurrentTest.isTimeoutTesting && !gCurrentTest.wasTransactionTimeout) {
     is(aEvent.target.id, "",
        "The view scrolled before timeout (the expected view after timeout is " +
          gCurrentTest.expectedView ? gCurrentTest.expectedView.id : "null" +
          "): " + gCurrentTest.description);
     runNextTestList();
     return;
   }
   // Check whether the scrolled event should be fired or not.
   if (!gCurrentTest.expectedView) {
     is(aEvent.target.id, "",
          "no views should be scrolled (" +
          _getScrolledStateText(_getScrolledState(aEvent.target)) + "): " +
          gCurrentTest.description);
     runNextTestList();
     return;
   }
   // Check whether the scrolled view is expected or not.
   if (aEvent.target != gCurrentTest.expectedView) {
     // If current test can fail randomly and the possible view is same as the
     // event target, this failure may be caused by unexpected timeout.
     // At this time, we should retry the current tests with slower settings.
     if (gCurrentTest.canFailRandomly &&
         gCurrentTest.canFailRandomly.possibleView == aEvent.target &&
         gCurrentTestListStatus.retryWhenTransactionTimeout > 0) {
       gCurrentTestListStatus.retryWhenTransactionTimeout--;
       retryCurrentTestList();
       return;
     }
     is(aEvent.target.id, gCurrentTest.expectedView.id,
        "wrong view was scrolled: " + gCurrentTest.description);
     runNextTestList();
     return;
   }
   // Check whether the scrolling direction is expected or not.
   var expectedState = _getExpectedScrolledState();
   var currentState = _getScrolledState(aEvent.target);
   if (expectedState != currentState) {
     is(_getScrolledStateText(currentState),
        _getScrolledStateText(expectedState),
        "scrolled to wrong direction: " + gCurrentTest.description);
     runNextTestList();
     return;
   }
   ok(true, "passed: " + gCurrentTest.description);
   continueTest();
 }
 function onMouseScrollFailed()
 {
   /**
    * Scroll failed event handler. If testing is failed, this function cancels
    * all remains of current test-list, and go to next test-list.
    *
    * NOTE: This event is fired immediately after |_fireWheelScrollEvent|.
    *
    * @param gCurrentTest.expectedView
    *          The expected view which should be scrolled by the wheel event.
    *          This value can be null.  It means any views should not be
    *          scrolled.  When this is not null, this event means the test may
    *          be failed.
    */
   if (!(gLitesnEvents & kListenEvent_OnScrollFailed))
     return;
   ok(!gCurrentTest.expectedView,
      "failed to scroll on current target: " + gCurrentTest.description);
   if (gCurrentTest.expectedView) {
     runNextTestList();
     return;
   }
   continueTest();
 }
 function onTransactionTimeout()
 {
   /**
    * Scroll transaction timeout event handler.  If the timeout is unexpected,
    * i.e., |gCurrentTest.isTimeoutTesting| is not true, this function retry
    * the current test-list.  However, if the current test-list failed by timeout
    * |gCurrentTestListStatus.retryWhenTransactionTimeout| times already, marking
    * to failed the current test-list, and go to next test-list.
    *
    * @param gCurrentTest.expectedView
    *          The expected view which should be scrolled by the wheel event.
    *          This value can be null.  It means any views should not be
    *          scrolled.  When this is not null, this event means the testing may
    *          be failed.
    * @param gCurrentTest.isTimeoutTesting
    *          If this value is true, the current testing have waited this
    *          event.  Otherwise, the testing may be failed.
    * @param gCurrentTestListStatus.retryWhenTransactionTimeout
    *          If |gCurrentTest.isTimeoutTesting| is not true but this event is
    *          fired, the failure may be randomly.  Then, this event handler
    *          retry to test the current test-list until this cound will be zero.
    */
   if (!gCurrentTest.isTimeoutTesting &&
       gCurrentTestListStatus.retryWhenTransactionTimeout > 0) {
     gCurrentTestListStatus.retryWhenTransactionTimeout--;
     // retry current test list
     retryCurrentTestList();
     return;
   }
   gCurrentTest.wasTransactionTimeout = true;
   if (!(gLitesnEvents & kListenEvent_OnTransactionTimeout))
     return;
   ok(gCurrentTest.isTimeoutTesting,
      "transaction timeout: " + gCurrentTest.description);
   if (!gCurrentTest.isTimeoutTesting) {
     runNextTestList();
     return;
   }
   continueTest();
 }
 /******************************************************************************
  * Main function for this tests
  ******************************************************************************/
 function runNextTestStep()
 {
   // When this is first time or the current test list is finised, load next
   // test-list.
   _clearTimer();
   if (!gCurrentTest)
     runNextTestList();
   else
     runTestStepAt(gCurrentTestListStatus.nextStepIndex);
 }
 function runNextTestList()
 {
   _clearTimer();
   gLitesnEvents = kListenEvent_None;
   _clearTransaction();
   resetTimeoutPrefs();
   if (gCurrentTestListStatus.nextListIndex >= gTestLists.length) {
     finish();
     return;
   }
   gCurrentTestListStatus.nextListIndex++;
   gCurrentTestListStatus.retryWhenTransactionTimeout =
     _getCurrentTestList().retryWhenTransactionTimeout;
   runTestStepAt(0);
 }
 function runTestStepAt(aStepIndex)
 {
   _clearTimer();
   disableNonTestMouseEvents(true);
   // load a step of testing.
   gCurrentTestListStatus.nextStepIndex = aStepIndex;
   gCurrentTest =
     _getCurrentTestList().steps[gCurrentTestListStatus.nextStepIndex++];
   if (gCurrentTest) {
     gCurrentTest.wasTransactionTimeout = false;
     gTimer = setTimeout(gCurrentTest.func, gCurrentTest.delay);
   } else {
     // If current test-list doesn't have more testing, go to next test-list
     // after cleaning up the current transaction.
     _clearTransaction();
     runNextTestList();
   }
 }
 function retryCurrentTestList()
 {
   _clearTimer();
   gLitesnEvents = kListenEvent_None;
   _clearTransaction();
   ok(true, "WARNING: retry current test-list...");
   growUpTimeoutPrefs(); // retry the test with longer timeout settings.
   runTestStepAt(0);
 }
 function continueTest()
 {
   /**
    * This function is called from an event handler when a test succeeded.
    *
    * @param gCurrentTest.repeatTest
    *          When this is true, onScrollView calls |gCurrentTest.func|. So,
    *          same test can repeat.  Otherwise, this calls |runNextTestStep|.
    * @param gCurrentTest.autoRepeatDelay
    *          The delay value in milliseconds, this is used to call
    *          |gCurrentTest.func| via |setTimeout|.
    */
   _clearTimer();
   gLitesnEvents = kListenEvent_OnTransactionTimeout;
   // We should call each functions via setTimeout. Because sometimes this test
   // is broken by stack overflow.
   if (gCurrentTest.repeatTest) {
     gTimer = setTimeout(gCurrentTest.func, gCurrentTest.autoRepeatDelay);
   } else {
     gTimer = setTimeout(runNextTestStep, 0);
   }
 }
 ]]>
 </script>
 </window>

The Tor Browser / annotate

widget/tests/window_wheeltransaction.xul@97036ab72558 (annotated)

widget/tests/window_wheeltransaction.xul