Enabled asynchronous response filters.

Also updated externs. Issue #610 Change-Id: I4c9539442d6fb77781296ea1acf123b3653e3b40
shaka-project · Jan 9, 2017 · 8b2212c · 8b2212c
1 parent 9ce802d
commit 8b2212c
Show file tree

Hide file tree

Showing 5 changed files with 110 additions and 12 deletions.
diff --git a/externs/shaka/net.js b/externs/shaka/net.js
@@ -131,9 +131,12 @@ shakaExtern.SchemePlugin;
 /**
  * Defines a filter for requests.  This filter takes the request and modifies
  * it before it is sent to the scheme plugin.
+ * A request filter can run asynchronously by returning a promise; in this case,
+ * the request will not be sent until the promise is resolved.
  *
  * @typedef {!function(shaka.net.NetworkingEngine.RequestType,
- *                     shakaExtern.Request)}
+ *                     shakaExtern.Request):
+             (Promise|undefined)}
  * @exportDoc
  */
 shakaExtern.RequestFilter;
@@ -142,9 +145,11 @@ shakaExtern.RequestFilter;
 /**
  * Defines a filter for responses.  This filter takes the response and modifies
  * it before it is returned.
+ * A response filter can run asynchronously by returning a promise.
  *
  * @typedef {!function(shaka.net.NetworkingEngine.RequestType,
- *                     shakaExtern.Response)}
+ *                     shakaExtern.Response):
+              (Promise|undefined)}
  * @exportDoc
  */
 shakaExtern.ResponseFilter;
diff --git a/lib/dash/dash_parser.js b/lib/dash/dash_parser.js
@@ -1388,6 +1388,7 @@ shaka.dash.DashParser.prototype.requestInitSegment_ = function(
  *
  * @param {shaka.net.NetworkingEngine.RequestType} type
  * @param {!shakaExtern.Response} response
+ * @return {(Promise|undefined)}
  * @private
  */
 shaka.dash.DashParser.prototype.emsgResponseFilter_ = function(type, response) {

diff --git a/lib/net/networking_engine.js b/lib/net/networking_engine.js
@@ -357,18 +357,30 @@ shaka.net.NetworkingEngine.prototype.send_ = function(
   return plugin(request.uris[index], request, type).then(function(response) {
     if (response.timeMs === undefined)
       response.timeMs = Date.now() - startTimeMs;
-
-    // Since we are inside a promise, no need to catch errors; they will result
-    // in a failed promise.
     var filterStartMs = Date.now();
-    var responseFilters = this.responseFilters_;
-    for (var i = 0; i < responseFilters.length; i++) {
-      responseFilters[i](type, response);
-    }
-    response.timeMs += Date.now() - filterStartMs;
-    response.timeMs += requestFilterTime;
 
-    return response;
+    var responseFilters = this.responseFilters_;
+    var p = Promise.resolve();
+    responseFilters.forEach(function(responseFilter) {
+      // Response filters are resolved sequentially.
+      p = p.then(function() {
+        return Promise.resolve(responseFilter(type, response));
+      }.bind(this));
+    });
+
+    // Catch any errors thrown by response filters, and substitute
+    // them with a Shaka-native error.
+    p = p.catch(function(e) {
+      throw new shaka.util.Error(shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.RESPONSE_FILTER_ERROR, e);
+    });
+
+    return p.then(function() {
+      response.timeMs += Date.now() - filterStartMs;
+      response.timeMs += requestFilterTime;
+
+      return response;
+    });
   }.bind(this));
 };
 

diff --git a/lib/util/error.js b/lib/util/error.js
@@ -182,6 +182,12 @@ shaka.util.Error.Code = {
    */
   'REQUEST_FILTER_ERROR': 1006,
 
+  /**
+   * A response filter threw an error.
+   * <br> error.data[0] is the original error.
+   */
+  'RESPONSE_FILTER_ERROR': 1007,
+
 
   /** The text parser failed to parse a text stream due to an invalid header. */
   'INVALID_TEXT_HEADER': 2000,

diff --git a/test/net/networking_engine_unit.js b/test/net/networking_engine_unit.js
@@ -328,21 +328,33 @@ describe('NetworkingEngine', /** @suppress {accessControls} */ function() {
     });
 
     it('waits for asynchronous filters', function(done) {
+      var responseFilter = jasmine.createSpy('response filter');
+      networkingEngine.registerResponseFilter(responseFilter);
+
       var p = new shaka.util.PublicPromise();
+      var p2 = new shaka.util.PublicPromise();
       filter.and.returnValue(p);
+      responseFilter.and.returnValue(p2);
       var request = createRequest('resolve://foo');
       var r = networkingEngine.request(requestType, request);
       Util.capturePromiseStatus(r);
 
       Util.delay(0.1).then(function() {
         expect(filter).toHaveBeenCalled();
         expect(resolveScheme).not.toHaveBeenCalled();
+        expect(responseFilter).not.toHaveBeenCalled();
         expect(r.status).toBe('pending');
         p.resolve();
 
         return Util.delay(0.1);
       }).then(function() {
         expect(resolveScheme).toHaveBeenCalled();
+        expect(responseFilter).toHaveBeenCalled();
+        expect(r.status).toBe('pending');
+        p2.resolve();
+
+        return Util.delay(0.1);
+      }).then(function() {
         expect(r.status).toBe('resolved');
         done();
       }).catch(fail);
@@ -546,6 +558,68 @@ describe('NetworkingEngine', /** @suppress {accessControls} */ function() {
           });
     });
 
+    it('applies response filters sequentially', function(done) {
+      var secondFilter = jasmine.createSpy('second response filter');
+      networkingEngine.registerResponseFilter(secondFilter);
+
+      var order = 0;
+      filter.and.callFake(function() {
+        expect(order).toBe(0);
+        order += 1;
+      });
+      secondFilter.and.callFake(function() {
+        expect(order).toBe(1);
+        order += 1;
+      });
+
+      networkingEngine.request(requestType, createRequest('resolve://foo'))
+          .catch(fail)
+          .then(done);
+    });
+
+    it('turns errors into shaka errors', function(done) {
+      var fakeError = 'fake error';
+      filter.and.callFake(function() {
+        throw fakeError;
+      });
+      networkingEngine.request(requestType, createRequest('resolve://foo'))
+          .then(fail)
+          .catch(function(e) {
+            expect(e.code).toBe(shaka.util.Error.Code.RESPONSE_FILTER_ERROR);
+            expect(e.data).toEqual([fakeError]);
+            done();
+          });
+    });
+
+    it('can modify responses asynchronously', function(done) {
+      var p = new shaka.util.PublicPromise();
+      filter.and.callFake(function(type, response) {
+        return p.then(function() {
+          expect(response.headers).toBeTruthy();
+          response.headers['DATE'] = 'CAT';
+          response.data = new ArrayBuffer(5);
+        });
+      });
+
+      var request = createRequest('resolve://foo');
+      var r = networkingEngine.request(requestType, request)
+          .catch(fail)
+          .then(function(response) {
+            expect(response).toBeTruthy();
+            expect(response.headers['DATE']).toBe('CAT');
+            expect(response.data.byteLength).toBe(5);
+            done();
+          });
+      Util.capturePromiseStatus(r);
+
+      Util.delay(0.1).then(function() {
+        expect(filter).toHaveBeenCalled();
+        expect(r.status).toBe('pending');
+
+        p.resolve();
+      });
+    });
+
     it('if throws will stop requests', function(done) {
       filter.and.throwError(new Error());
       networkingEngine.request(requestType, createRequest('resolve://foo'))