Added virtual test suite with 1MB MSE buffers

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

 (function(window) {
     // Set the testharness.js timeout to 120 seconds so that it is higher than
     // the LayoutTest timeout. This prevents testharness.js from prematurely
     // terminating tests and allows the LayoutTest runner to control when to
     // timeout the test.
     setup({ explicit_timeout: 120000 });
 
     var SEGMENT_INFO_LIST = [
         {
             url: '/media/resources/media-source/webm/test.webm',
@@ skipping 108 matching lines @@
             var info = this.eventTargetList_[i];
             if (info.target == target) {
                 return info.expectations;
             }
         }
         var expectations = [];
         this.eventTargetList_.push({ 'target': target, 'expectations': expectations });
         return expectations;
     };
 
-    function loadData_(test, url, callback, isBinary)
+    function loadData_(test, url, callback, responseType)
     {
         var request = new XMLHttpRequest();
         request.open("GET", url, true);
-        if (isBinary) {
-            request.responseType = 'arraybuffer';
+        if (responseType !== undefined) {
+            request.responseType = responseType;
         }
         request.onload = test.step_func(function(event)
         {
             if (request.status != 200) {
                 assert_unreached("Unexpected status code : " + request.status);
                 return;
             }
             var response = request.response;
-            if (isBinary) {
+            if (responseType !== undefined && responseType == 'arraybuffer') {
                 response = new Uint8Array(response);
             }
             callback(response);
         });
         request.onerror = test.step_func(function(event)
         {
             assert_unreached("Unexpected error");
         });
         request.send();
     }
@@ skipping 12 matching lines @@
         }
 
         mediaSource.addEventListener('sourceopen', eventHandler);
         mediaTag.src = mediaSourceURL;
     }
 
     var MediaSourceUtil = {};
 
     MediaSourceUtil.loadTextData = function(test, url, callback)
     {
-        loadData_(test, url, callback, false);
+        loadData_(test, url, callback);
     };
 
     MediaSourceUtil.loadBinaryData = function(test, url, callback)
     {
-        loadData_(test, url, callback, true);
+        loadData_(test, url, callback, 'arraybuffer');
+    };
+
+    MediaSourceUtil.loadDataStream = function(test, url, callback)
+    {
+        loadData_(test, url, callback, 'legacystream');
     };
 
     MediaSourceUtil.fetchManifestAndData = function(test, manifestFilename, callback)
     {
         var baseURL = '/media/resources/media-source/';
         var manifestURL = baseURL + manifestFilename;
         MediaSourceUtil.loadTextData(test, manifestURL, function(manifestText)
         {
             var manifest = JSON.parse(manifestText);
 
@@ skipping 22 matching lines @@
         var numBytes = 0;
         var segmentIndex = 0;
         while (segmentIndex < mediaInfo.length && mediaInfo[segmentIndex].timecode <= playbackTimeToAdd)
         {
           numBytes += mediaInfo[segmentIndex].size;
           ++segmentIndex;
         }
         return mediaData.subarray(start, numBytes + start);
     }
 
+    // Fills up the sourceBuffer by repeatedly calling doAppendDataFunc, which is expected to append some data
+    // to the sourceBuffer, until a QuotaExceeded exception is thrown. Then it calls the onCaughtQuotaExceeded callback.
+    MediaSourceUtil.fillUpSourceBufferHelper = function(test, sourceBuffer, doAppendDataFunc, onCaughtQuotaExceeded)
+    {
+        // We are appending data repeatedly in sequence mode, there should be no gaps.
+        assert_equals(sourceBuffer.mode, 'sequence');
+        assert_false(sourceBuffer.buffered.length > 1, 'unexpected gap in buffered ranges.');
+        try {
+            doAppendDataFunc();
+        } catch(ex) {
+            assert_equals(ex.name, 'QuotaExceededError');
+            onCaughtQuotaExceeded();
+        }
+        test.expectEvent(sourceBuffer, 'updateend', 'append ended.');
+        test.waitForExpectedEvents(function() { MediaSourceUtil.fillUpSourceBufferHelper(test, sourceBuffer, doAppendDataFunc, onCaughtQuotaExceeded); });
+    };
+
+    MediaSourceUtil.fillUpSourceBuffer = function(test, mediaSource, onBufferFull)
+    {
+        MediaSourceUtil.fetchManifestAndData(test, 'webm/test-a-5min-44100Hz-1ch-manifest.json', function(type, mediaData)

[wolenetz, 2016/08/02 21:56:36]

nit: (not a regression, and certainly not a strong feeling, just a note if you
could fix this easily here and now, please try to:) Allow for webm-lacking
implementations to also pass this? It might ease interop test suite merger of
this. (Ditto in the stream version, below, though the interop suite will likely
drop appendStream since that's the current MSE v1 consensus).

[servolk, 2016/08/02 22:59:15]

Sure we can easily pass in the manifest/stream URLs as input params in here, if
that's what you mean. Done in the latest patchset.

+        {
+            var sourceBuffer = mediaSource.addSourceBuffer(MediaSourceUtil.AUDIO_ONLY_TYPE);
+            sourceBuffer.mode = 'sequence';
+
+            var appendedDataSize = 0;
+            MediaSourceUtil.fillUpSourceBufferHelper(test, sourceBuffer,
+                function () { // doAppendDataFunc
+                    appendedDataSize += mediaData.length;
+                    sourceBuffer.appendBuffer(mediaData);
+                },
+                function () { // onCaughtQuotaExceeded
+                    onBufferFull(appendedDataSize);
+                });
+        });
+    };
+
+    MediaSourceUtil.fillUpSourceBufferViaAppendStream = function (test, mediaSource, sourceBuffer, onBufferFull, appendSize)
+    {
+        var mediaURL = "/media/resources/media-source/webm/test-a-5min-44100Hz-1ch.webm";
+        var appendedDataSize = 0;
+        function appendStreamData() {
+            MediaSourceUtil.loadDataStream(test, mediaURL, function(response)
+            {
+                // We are appending data repeatedly in sequence mode, there should be no gaps.
+                assert_false(sourceBuffer.buffered.length > 1, "unexpected gap in buffered ranges.");
+                try {
+                    if (appendSize !== undefined) {
+                      appendedDataSize += appendSize;
+                      sourceBuffer.appendStream(response, appendSize);
+                    } else {
+                      sourceBuffer.appendStream(response);
+                    }
+                } catch(ex) {
+                    assert_equals(ex.name, 'QuotaExceededError');
+                    onBufferFull(appendedDataSize);
+                }
+                test.expectEvent(sourceBuffer, "updateend", "Append ended.");
+                test.waitForExpectedEvents(appendStreamData);
+            });
+        }
+        // Start appending data
+        appendStreamData();
+    };
+
+
     function getFirstSupportedType(typeList)
     {
         for (var i = 0; i < typeList.length; ++i) {
             if (MediaSource.isTypeSupported(typeList[i]))
                 return typeList[i];
         }
         return "";
     }
 
     function getSegmentInfo()
@@ skipping 165 matching lines @@
         assert_equals(actual, expected, description);
     };
 
     window['assertSeekableEquals'] = function(obj, expected, description)
     {
         var actual = timeRangesToString(obj.seekable);
         assert_equals(actual, expected, description);
     };
 
 })(window);