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. To indicate that this expected callback did fire, remove this
+        // timeoutID from the list of IDs we are maintaining.
+        // 2. Execute the callback that has been passed-in.
+        var callbackWrapper = function(callback, timeoutIDs, index) {
+          timeoutIDs.splice(index, 1);

[wolenetz, 2013/08/01 18:32:24]

I don't think this will always work as intended. Example:
expectDelayedCallback(callback1, 50);
--> timeoutIDs[0] = id of callback1 wrapper
--> callback1 wrapper will be told to use index 0
expectDelayedCallback(callback2, 1000);
--> timeoutIDs[1] = id of callback2 wrapper
--> callback2 wrapper will be told to use index 1
... ~50 ms elapses and callback1 wrapper is called
--> timeoutIDs resulting from splice(0,1) is [callback2 ID (at index 0, *not at
index 1*)]
... ~950 more ms elapse and callback2 wrapper is called
--> timeoutIDs resulting from splice(1,1) is still [callback2 ID].

Takeaway is that the wrapper shouldn't assume constant index. Rather, it should
remove the specific timeoutID to which it is associated. One way to do this is
to have a wrapper object for the timeoutID be defined and registered to be
passed in the setTimeout call, and then immediately update that wrapper object
with the timeoutID that was returned from the setTimeout call (and use that
wrapper object's timeoutID when the callback wrapper is called to remove the
correct timeoutID from the manager's timeoutIDs).

[anandc, 2013/08/01 22:10:10]

This was really useful. Thanks. Done.

+          callback();
+        }
+
+        // Execute the wrapper after the specified delay.
+        var timeoutIDs = this.timeoutIDs_;

[wolenetz, 2013/08/01 18:32:24]

nit: why not just use this.timeoutIDs_ everywhere, even in the callback wrapper?
It's at least a redundant argument currently.

[anandc, 2013/08/01 22:10:10]

Done in most places.

There is a problem with the reference used when this.timeoutIDs_ is passed as a
parameter when calling callbackWrapper in the line below.

It results in the following error:
Uncaught TypeError: Cannot convert undefined or null to object

So keeping a local variable here just for that case. 

+        var index = timeoutIDs.length;
+        var timeoutID = setTimeout(function() {callbackWrapper(callback, timeoutIDs, index);}, delay);
+        // Add to list of timeoutIDs, which we'll use eventually to check that
+        // all expected delayed callbacks did get executed.
+        timeoutIDs[index] = 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);