Layout Test for basic MSE seek scenario.

LayoutTests/http/tests/media/media-source/mediasource-util.js

 (function(window) {
     EventExpectationsManager = function(test)
     {
         this.test_ = test;
         this.eventTargetList_ = [];
         this.waitCallbacks_ = [];
+        this.timeoutIDs_ = [];
     };
 
     EventExpectationsManager.prototype.expectEvent = function(object, eventName, description)
     {
         var eventInfo = { 'target': object, 'type': eventName, 'description': description};
         var expectations = this.getExpectations_(object);
         expectations.push(eventInfo);
 
         var t = this;
         var waitHandler = this.test_.step_func(function() { t.handleWaitCallback_(); });
         var eventHandler = this.test_.step_func(function(event)
         {
             object.removeEventListener(eventName, eventHandler);
             var expected = expectations[0];
             assert_equals(event.target, expected.target, "Event target match.");
             assert_equals(event.type, expected.type, "Event types match.");
             assert_equals(eventInfo.description, expected.description, "Descriptions match for '" +  event.type + "'.");
 
             expectations.shift(1);
             if (t.waitCallbacks_.length > 0)
                 setTimeout(waitHandler, 0);
         });
         object.addEventListener(eventName, eventHandler);
     };
 
+    EventExpectationsManager.prototype.expectDelayedCallback = function(callback, delay)
+    {
+        // Define a wrapper function that will:
+        // 1. Execute the callback that has been passed-in.
+        // 2. Clean-up the list of timeoutIDs, removing the first in the list

[wolenetz, 2013/08/01 00:16:15]

I don't think we should require that the timeoutIDs be in chronological order.
Regardless, the wrapper should remove exactly the timeoutID that was created for
it. Otherwise, clearTimeout() later during test.done() could clear the wrong
ID(s). Maybe you could use a new utility function within the manager to remove a
specific ID from the EventExpectationsManager's timeoutIDs_, to make the wrapper
simpler.

[anandc, 2013/08/01 18:12:03]

Makes sense. Done.

There also was a bug where, if the callback happened to also call test.done(),
the timeoutID for that callback wouldn't get removed. (This was found in testing
prior to PS7 being uploaded, but fix didn't get committed with it.) The bug has
been fixed by removing the ID first then invoking the callback.

+        // ("first" chronologically)
+        var callbackWrapper = function(callback, timeoutIDs) {
+          callback();
+          timeoutIDs.shift();
+        }
+
+        // Execute the wrapper after the specified delay.
+        var timeoutIDs = this.timeoutIDs_;
+        var timeoutID = setTimeout(function() {callbackWrapper(callback, timeoutIDs);}, delay);
+        // Add to list of timeoutIDs, which we'll use eventually to check that
+        // all expected delayed callbacks did get executed.
+        timeoutIDs.push(timeoutID);
+    };
+
     EventExpectationsManager.prototype.waitForExpectedEvents = function(callback)
     {
         this.waitCallbacks_.push(callback);
         setTimeout(this.handleWaitCallback_.bind(this), 0);
     };
 
     EventExpectationsManager.prototype.expectingEvents = function()
     {
         for (var i = 0; i < this.eventTargetList_.length; ++i) {
             if (this.eventTargetList_[i].expectations.length > 0) {
@@ skipping 127 matching lines @@
         {
             object.addEventListener(eventName, test.step_func(function(event) { test.done(); }));
         };
 
         test.eventExpectations_ = new EventExpectationsManager(test);
         test.expectEvent = function(object, eventName, description)
         {
             test.eventExpectations_.expectEvent(object, eventName, description);
         };
 
+        test.expectDelayedCallback = function(callback, delay)
+        {
+            test.eventExpectations_.expectDelayedCallback(callback, delay);
+        }
+
         test.waitForExpectedEvents = function(callback)
         {
             test.eventExpectations_.waitForExpectedEvents(callback);
         };
 
         var oldTestDone = test.done.bind(test);
         test.done = function()
         {
-            if (test.status == test.PASS)
+            // loop through and clear timeoutIDs
+            var timeoutIDs = test.eventExpectations_.timeoutIDs_;
+            for (var i = 0; i < timeoutIDs.length; ++i) {
+                clearTimeout(timeoutIDs[i]);
+            }
+
+            if (test.status == test.PASS) {
                 assert_false(test.eventExpectations_.expectingEvents(), "No pending event expectations.");
+                assert_equals(timeoutIDs.length, 0);
+            }
             oldTestDone();
         };
     };
 
     window['MediaSourceUtil'] = MediaSourceUtil;
     window['media_test'] = function(testFunction, description, options)
     {
         options = options || {};
         return async_test(function(test)
         {
@@ skipping 21 matching lines @@
             };
 
             openMediaSource_(test, mediaTag, function(mediaSource)
             {
                 testFunction(test, mediaTag, mediaSource);
             });
         }, description, options);
 
     };
 })(window);