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_ = new Array();

[wolenetz, 2013/08/02 20:04:25]

new Array() is the same as []. At least according to JSON.stringify(). Do you
mean to use {} or []? Any of these three appear to work when I tested in private
(with the caveat that removing '[i]' in the enumeration below is necessary to
make any of these options work - see my later comment), so I'm not sure why 'new
Array()' is used here. Also, I'm not sure Array is most efficient here vs just
Object properties by way of {}.

[anandc, 2013/08/02 20:40:38]

Thanks for trying out the different options. Going with {} now.

     };
 
     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)
+    {
+        var timeoutIDHolder = 0;
+        // 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) {
+          delete timeoutIDs[timeoutIDHolder];
+          callback();
+        }
+
+        // Execute the wrapper after the specified delay.
+        var timeoutIDs = this.timeoutIDs_;
+        timeoutIDHolder = 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.
+        this.timeoutIDs_[timeoutIDHolder] = timeoutIDHolder;
+    };
+
     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
+            for (var i in test.eventExpectations_.timeoutIDs_[i]) {

[wolenetz, 2013/08/02 20:04:25]

I believe this [i] breaks the enumeration code.
Example (compare the resulting s and v, below):
a=new Array();
--> []
a
--> []
a[100]=100;
--> 100
a
--> Array[101]
s = new String();
--> String {}
for (var i in a) { s+=(a[i]).toString()+',' }
--> "100,"
s
--> "100,"
v = new String();
--> String {}
for (var i in a[i]) { v+=(a[i]).toString()+',' }
--> undefined
v
--> String {}

[anandc, 2013/08/02 20:40:38]

Stupid bug. Thanks for catching. Fixed.

+                clearTimeout(test.eventExpectations_.timeoutIDs_[i]);
+            }
+
+            if (test.status == test.PASS) {
                 assert_false(test.eventExpectations_.expectingEvents(), "No pending event expectations.");
+                assert_equals(Object.keys(test.eventExpectations_.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);