Streams Implementation Update: Reader name and Stream methods

LayoutTests/http/tests/xmlhttprequest/resources/response-stream.js

 var global = this;
 if (global.importScripts) {
     // Worker case
     importScripts('/resources/testharness.js');
 }
 
 var test = async_test('Test response of XMLHttpRequest with responseType set to "stream" for various readyState.');
 
 test.step(function() {
     var xhr = new XMLHttpRequest;
 
     xhr.responseType = 'stream';
     assert_equals(xhr.responseType, 'stream', 'xhr.responseType');
 
     assert_equals(xhr.readyState, xhr.UNSENT, 'xhr.readyState');
     assert_equals(xhr.response, null, 'xhr.response during UNSENT');
 
     var seenStates = [];
 
-    function readStream(stream) {
+    function readStream(reader) {
         var chunks = [];
         function rec(resolve, reject) {
-            while (stream.state === 'readable') {
-                chunks.push(stream.read());
+            while (reader.state === 'readable') {
+                chunks.push(reader.read());
             }
-            if (stream.state === 'closed') {
+            if (reader.state === 'closed') {
                 resolve(chunks);
                 return;
             }
-            stream.ready.then(function() {
+            reader.ready.then(function() {
                 rec(resolve, reject);
             }).catch(reject);
         }
         return new Promise(rec);
     }
     var streamPromise = undefined;
 
     xhr.onreadystatechange = test.step_func(function() {
         // onreadystatechange can be invoked multiple times in LOADING state.
         if (seenStates.length == 0 || xhr.readyState != seenStates[seenStates.length - 1])
@@ skipping 10 matching lines @@
 
         case xhr.HEADERS_RECEIVED:
             assert_equals(xhr.response, null, 'xhr.response during HEADERS_RECEIVED');
             return;
 
         case xhr.LOADING:
             assert_not_equals(xhr.response, null, 'xhr.response during LOADING');
             assert_true(xhr.response instanceof ReadableStream,
                 'xhr.response should be ReadableStream during LOADING');
             if (streamPromise === undefined) {
-                streamPromise = readStream(xhr.response);
+                streamPromise = readStream(xhr.response.getReader());
             }
-            streamPromise.then(test.step_func(function(chunks) {
+            streamPromise.then(function(chunks) {

[tyoshino (SeeGerritForStatus), 2015/03/17 05:14:39]

add
test.step_func(

[yhirano, 2015/03/17 05:24:15]

We don't need it because we catch the exception afterward.

[tyoshino (SeeGerritForStatus), 2015/03/17 07:09:37]

True but it's not 'failed to read the response stream: ' but assertion failure.
I'm fine with either but prefer getting AssertionErrors handled by "test".

[yhirano, 2015/03/17 07:21:38]

Fixed.

                 assert_equals(xhr.status, 200, 'xhr.status');
 
                 // Check that we saw all states.
                 assert_array_equals(seenStates,
                     [xhr.OPENED, xhr.HEADERS_RECEIVED, xhr.LOADING, xhr.DONE]);
-                assert_equals(xhr.response.state, 'closed', 'stream status');
                 var size = 0;
                 for (var i = 0; i < chunks.length; ++i) {
                     size += chunks[i].byteLength;
                 }
                 assert_equals(size, 103746, 'response size');
+                return xhr.response.closed;
+            }).then(function() {
                 test.done();
-            }), test.step_func(function(e) {
+            }).catch(test.step_func(function(e) {
                 assert_unreached('failed to read the response stream: ' + e);
             }));
             return;
 
         case xhr.DONE:
             return;
 
         default:
             assert_unreached('Unexpected readyState: ' + xhr.readyState)
             return;
         }
     });
 
     xhr.open('GET', '/resources/test.ogv', true);
     xhr.send();
 });
 
 if (global.importScripts) {
     // Worker case
     done();
 }