Source: lib/util/cancelable_chain.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.CancelableChain');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.util.Error');
  25. /**
  26.  * A Promise-based abstraction that creates cancelable Promise chains.
  27.  * When canceled, subsequent stages of the internal Promise chain will stop.
  28.  * A canceled chain is rejected with a user-specified value.
  29.  *
  30.  * A CancelableChain only supports linear Promise chains.  Chains which branch
  31.  * (more than one then() handler chained to a particular stage) are not
  32.  * supported.  You will not be prevented from treating this as if branching
  33.  * were supported, but everything will be serialized into a linear chain.
  34.  * Be careful!
  35.  *
  36.  * @constructor
  37.  * @struct
  38.  */
  39. shaka.util.CancelableChain = function() {
  40.   /** @private {!Promise} */
  41.   this.promise_ = Promise.resolve();
  43.   /** @private {boolean} */
  44.   this.final_ = false;
  46.   /** @private {boolean} */
  47.   this.complete_ = false;
  49.   /** @private {boolean} */
  50.   this.canceled_ = false;
  52.   /** @private {shaka.util.Error} */
  53.   this.rejectionValue_;
  55.   /** @private {function()} */
  56.   this.onCancelComplete_;
  58.   /** @private {!Promise} */
  59.   this.cancelPromise_ = new Promise(function(resolve) {
  60.     this.onCancelComplete_ = resolve;
  61.   }.bind(this));
  62. };
  65. /**
  66.  * @param {function(*)} callback
  67.  * @return {!shaka.util.CancelableChain} the chain itself.
  68.  */
  69. shaka.util.CancelableChain.prototype.then = function(callback) {
  70.   goog.asserts.assert(!this.final_, 'Chain should not be final!');
  72.   this.promise_ = this.promise_.then(callback).then(function(data) {
  73.     if (this.canceled_) {
  74.       this.onCancelComplete_();
  75.       return Promise.reject(this.rejectionValue_);
  76.     }
  77.     return Promise.resolve(data);
  78.   }.bind(this));
  79.   return this;
  80. };
  83. /**
  84.  * Finalize the chain.
  85.  * Converts the chain into a simple Promise and stops accepting new stages.
  86.  *
  87.  * @return {!Promise}
  88.  */
  89. shaka.util.CancelableChain.prototype.finalize = function() {
  90.   if (!this.final_) {
  91.     this.promise_ = this.promise_.then(function(data) {
  92.       this.complete_ = true;
  93.       return Promise.resolve(data);
  94.     }.bind(this), function(error) {
  95.       this.complete_ = true;
  96.       if (this.canceled_) {
  97.         this.onCancelComplete_();
  98.         return Promise.reject(this.rejectionValue_);
  99.       }
  101.       return Promise.reject(error);
  102.     }.bind(this));
  103.   }
  104.   this.final_ = true;
  105.   return this.promise_;
  106. };
  109. /**
  110.  * Cancel the Promise chain and reject with the given value.
  111.  *
  112.  * @param {!shaka.util.Error} reason
  113.  * @return {!Promise} resolved when the cancelation has been processed by the
  114.  *   the chain and no more stages will execute.  Note that this may be before
  115.  *   the owner of the finalized chain has seen the rejection.
  116.  */
  117. shaka.util.CancelableChain.prototype.cancel = function(reason) {
  118.   if (this.complete_) return Promise.resolve();
  120.   this.canceled_ = true;
  121.   this.rejectionValue_ = reason;
  122.   return this.cancelPromise_;
  123. };