shaka-player 3.2.1 → 3.3.1

package/lib/net/http_xhr_plugin.js

@@ -24,10 +24,12 @@ shaka.net.HttpXHRPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    * @export
    */
-  static parse(uri, request, requestType, progressUpdated) {
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {
     const xhr = new shaka.net.HttpXHRPlugin.Xhr_();
 
     // Last time stamp when we got a progress event.
@@ -48,23 +50,25 @@ shaka.net.HttpXHRPlugin = class {
             shaka.util.Error.Code.OPERATION_ABORTED,
             uri, requestType));
       };
-      xhr.onload = (event) => {
-        const target = event.target;
-        goog.asserts.assert(target, 'XHR onload has no target!');
-        // Since Edge incorrectly return the header with a leading new
-        // line character ('\n'), we trim the header here.
-        const headerLines = target.getAllResponseHeaders().trim().split('\r\n');
-        const headers = {};
-        for (const header of headerLines) {
-          /** @type {!Array.<string>} */
-          const parts = header.split(': ');
-          headers[parts[0].toLowerCase()] = parts.slice(1).join(': ');
+      let calledHeadersReceived = false;
+      xhr.onreadystatechange = (event) => {
+        // See if the readyState is 2 ("HEADERS_RECEIVED").
+        if (xhr.readyState == 2 && !calledHeadersReceived) {
+          const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
+          headersReceived(headers);
+          // Don't send out this event twice.
+          calledHeadersReceived = true;
         }
+      };
+      xhr.onload = (event) => {
+        const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
+        goog.asserts.assert(xhr.response instanceof ArrayBuffer,
+            'XHR should have a response by now!');
+        const xhrResponse = xhr.response;
 
         try {
           const response = shaka.net.HttpPluginUtils.makeResponse(headers,
-              target.response, target.status, uri, target.responseURL,
-              requestType);
+              xhrResponse, xhr.status, uri, xhr.responseURL, requestType);
           resolve(response);
         } catch (error) {
           goog.asserts.assert(error instanceof shaka.util.Error,
@@ -116,6 +120,24 @@ shaka.net.HttpXHRPlugin = class {
           return Promise.resolve();
         });
   }
+
+  /**
+   * @param {!XMLHttpRequest} xhr
+   * @return {!Object.<string, string>}
+   * @private
+   */
+  static headersToGenericObject_(xhr) {
+    // Since Edge incorrectly return the header with a leading new
+    // line character ('\n'), we trim the header here.
+    const headerLines = xhr.getAllResponseHeaders().trim().split('\r\n');
+    const headers = {};
+    for (const header of headerLines) {
+      /** @type {!Array.<string>} */
+      const parts = header.split(': ');
+      headers[parts[0].toLowerCase()] = parts.slice(1).join(': ');
+    }
+    return headers;
+  }
 };
 
 
@@ -136,4 +158,8 @@ shaka.net.NetworkingEngine.registerScheme(
     'https', shaka.net.HttpXHRPlugin.parse,
     shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
     /* progressSupport= */ true);
+shaka.net.NetworkingEngine.registerScheme(
+    'blob', shaka.net.HttpXHRPlugin.parse,
+    shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
+    /* progressSupport= */ true);
 

package/lib/net/networking_engine.js

@@ -48,8 +48,12 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    * @param {function(number, number)=} onProgressUpdated Called when a progress
    *   event is triggered. Passed the duration, in milliseconds, that the
    *   request took, and the number of bytes transferred.
+   * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
+   *   Called when the headers are received for a download.
+   * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
+   *   Called when a download fails, for any reason.
    */
-  constructor(onProgressUpdated) {
+  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed) {
     super();
 
     /** @private {boolean} */
@@ -67,6 +71,12 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     /** @private {?function(number, number)} */
     this.onProgressUpdated_ = onProgressUpdated || null;
 
+    /** @private {?shaka.net.NetworkingEngine.OnHeadersReceived} */
+    this.onHeadersReceived_ = onHeadersReceived || null;
+
+    /** @private {?shaka.net.NetworkingEngine.OnDownloadFailed} */
+    this.onDownloadFailed_ = onDownloadFailed || null;
+
     /** @private {boolean} */
     this.forceHTTPS_ = false;
   }
@@ -447,6 +457,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
 
     let aborted = false;
 
+    let headersReceivedCalled = false;
+
     let startTimeMs;
     const sendOperation = backoffOperation.chain(() => {
       if (this.destroyed_) {
@@ -456,23 +468,27 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
       startTimeMs = Date.now();
       const segment = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
-      const requestPlugin = plugin(request.uris[index],
-          request,
-          type,
-          // The following function is passed to plugin.
-          (time, bytes, numBytesRemaining) => {
-            if (connectionTimer) {
-              connectionTimer.stop();
-            }
-            if (stallTimer) {
-              stallTimer.tickAfter(stallTimeoutMs / 1000);
-            }
-            if (this.onProgressUpdated_ && type == segment) {
-              this.onProgressUpdated_(time, bytes);
-              gotProgress = true;
-              numBytesRemainingObj.setBytes(numBytesRemaining);
-            }
-          });
+      const progressUpdated = (time, bytes, numBytesRemaining) => {
+        if (connectionTimer) {
+          connectionTimer.stop();
+        }
+        if (stallTimer) {
+          stallTimer.tickAfter(stallTimeoutMs / 1000);
+        }
+        if (this.onProgressUpdated_ && type == segment) {
+          this.onProgressUpdated_(time, bytes);
+          gotProgress = true;
+          numBytesRemainingObj.setBytes(numBytesRemaining);
+        }
+      };
+      const headersReceived = (headers) => {
+        if (this.onHeadersReceived_) {
+          this.onHeadersReceived_(headers, request, type);
+        }
+        headersReceivedCalled = true;
+      };
+      const requestPlugin = plugin(
+          request.uris[index], request, type, progressUpdated, headersReceived);
 
       if (!progressSupport) {
         return requestPlugin;
@@ -511,6 +527,13 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         response: response,
         gotProgress: gotProgress,
       };
+      if (!headersReceivedCalled) {
+        // The plugin did not call headersReceived, perhaps because it is not
+        // able to track that information. So, fire the event manually.
+        if (this.onHeadersReceived_) {
+          this.onHeadersReceived_(response.headers, request, type);
+        }
+      }
 
       return responseAndGotProgress;
     }, (error) => {
@@ -520,6 +543,17 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
       if (stallTimer) {
         stallTimer.stop();
       }
+      if (this.onDownloadFailed_) {
+        let shakaError = null;
+        let httpResponseCode = 0;
+        if (error instanceof shaka.util.Error) {
+          shakaError = error;
+          if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
+            httpResponseCode = /** @type {number} */ (error.data[1]);
+          }
+        }
+        this.onDownloadFailed_(request, shakaError, httpResponseCode, aborted);
+      }
       if (this.destroyed_) {
         return shaka.util.AbortableOperation.aborted();
       }
@@ -544,7 +578,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         }
 
         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
-          const event = new shaka.util.FakeEvent('retry', {'error': error});
+          const data = (new Map()).set('error', error);
+          const event = new shaka.util.FakeEvent('retry', data);
           this.dispatchEvent(event);
 
           // Move to the next URI.
@@ -763,3 +798,32 @@ shaka.net.NetworkingEngine.schemes_ = {};
  * @private
  */
 shaka.net.NetworkingEngine.ResponseAndGotProgress;
+
+
+/**
+ * @typedef {function(
+ *    !Object.<string, string>,
+ *    !shaka.extern.Request,
+ *    !shaka.net.NetworkingEngine.RequestType)}
+ *
+ * @description
+ * A callback function that passes the shaka.extern.HeadersReceived along to
+ * the player, plus some extra data.
+ * @export
+ */
+shaka.net.NetworkingEngine.OnHeadersReceived;
+
+
+/**
+ * @typedef {function(
+ *    !shaka.extern.Request,
+ *    ?shaka.util.Error,
+ *    number,
+ *    boolean)}
+ *
+ * @description
+ * A callback function that notifies the player when a download fails, for any
+ * reason (e.g. even if the download was aborted).
+ * @export
+ */
+shaka.net.NetworkingEngine.OnDownloadFailed;

package/lib/offline/download_info.js

@@ -0,0 +1,68 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.offline.DownloadInfo');
+
+goog.require('shaka.util.Networking');
+goog.requireType('shaka.media.InitSegmentReference');
+goog.requireType('shaka.media.SegmentReference');
+
+
+/**
+ * An object that represents a single segment, that the storage system will soon
+ * download, but has not yet started downloading.
+ */
+shaka.offline.DownloadInfo = class {
+  /**
+   * @param {shaka.media.SegmentReference|shaka.media.InitSegmentReference} ref
+   * @param {number} estimateId
+   * @param {number} groupId
+   * @param {boolean} isInitSegment
+   */
+  constructor(ref, estimateId, groupId, isInitSegment) {
+    /** @type {shaka.media.SegmentReference|shaka.media.InitSegmentReference} */
+    this.ref = ref;
+
+    /** @type {number} */
+    this.estimateId = estimateId;
+
+    /** @type {number} */
+    this.groupId = groupId;
+
+    /** @type {boolean} */
+    this.isInitSegment = isInitSegment;
+  }
+
+  /**
+   * Creates an ID that encapsulates all important information in the ref, which
+   * can then be used to check for equality.
+   * @param {shaka.media.SegmentReference|shaka.media.InitSegmentReference} ref
+   * @return {string}
+   */
+  static idForSegmentRef(ref) {
+    // Escape the URIs using encodeURI, to make sure that a weirdly formed URI
+    // cannot cause two unrelated refs to be considered equivalent.
+    return ref.getUris().map((uri) => '{' + encodeURI(uri) + '}').join('') +
+        ':' + ref.startByte + ':' + ref.endByte;
+  }
+
+  /** @return {string} */
+  getRefId() {
+    return shaka.offline.DownloadInfo.idForSegmentRef(this.ref);
+  }
+
+  /**
+   * @param {shaka.extern.PlayerConfiguration} config
+   * @return {!shaka.extern.Request}
+   */
+  makeSegmentRequest(config) {
+    return shaka.util.Networking.createSegmentRequest(
+        this.ref.getUris(),
+        this.ref.startByte,
+        this.ref.endByte,
+        config.streaming.retryParameters);
+  }
+};

package/lib/offline/download_manager.js

@@ -102,6 +102,16 @@ shaka.offline.DownloadManager = class {
     return Promise.all(promises);
   }
 
+  /**
+   * Adds a byte length to the download estimate.
+   *
+   * @param {number} estimatedByteLength
+   * @return {number} estimateId
+   */
+  addDownloadEstimate(estimatedByteLength) {
+    return this.estimator_.open(estimatedByteLength);
+  }
+
   /**
    * Add a request to be downloaded as part of a group.
    *
@@ -109,18 +119,16 @@ shaka.offline.DownloadManager = class {
    *    The group to add this segment to. If the group does not exist, a new
    *    group will be created.
    * @param {shaka.extern.Request} request
-   * @param {number} estimatedByteLength
+   * @param {number} estimateId
    * @param {boolean} isInitSegment
    * @param {function(BufferSource):!Promise} onDownloaded
    *   The callback for when this request has been downloaded. Downloading for
    *   |group| will pause until the promise returned by |onDownloaded| resolves.
    * @return {!Promise} Resolved when this request is complete.
    */
-  queue(groupId, request, estimatedByteLength, isInitSegment, onDownloaded) {
+  queue(groupId, request, estimateId, isInitSegment, onDownloaded) {
     this.destroyer_.ensureNotDestroyed();
 
-    const id = this.estimator_.open(estimatedByteLength);
-
     const group = this.groups_.get(groupId) || Promise.resolve();
 
     // Add another download to the group.
@@ -148,7 +156,7 @@ shaka.offline.DownloadManager = class {
       }
 
       // Update all our internal stats.
-      this.estimator_.close(id, response.byteLength);
+      this.estimator_.close(estimateId, response.byteLength);
       this.onProgress_(
           this.estimator_.getEstimatedProgress(),
           this.estimator_.getTotalDownloaded());

package/lib/offline/indexeddb/base_storage_cell.js

@@ -68,6 +68,28 @@ shaka.offline.indexeddb.BaseStorageCell = class {
     return this.rejectAdd(this.manifestStore_);
   }
 
+  /** @override */
+  updateManifest(key, manifest) {
+    // By default, reject all updates.
+    return this.rejectUpdate(this.manifestStore_);
+  }
+
+  /**
+   * @param {number} key
+   * @param {!shaka.extern.ManifestDB} manifest
+   * @return {!Promise}
+   * @protected
+   */
+  updateManifestImplementation(key, manifest) {
+    const op = this.connection_.startReadWriteOperation(this.manifestStore_);
+    const store = op.store();
+    store.get(key).onsuccess = (e) => {
+      store.put(manifest, key);
+    };
+
+    return op.promise();
+  }
+
   /** @override */
   updateManifestExpiration(key, newExpiration) {
     const op = this.connection_.startReadWriteOperation(this.manifestStore_);
@@ -145,6 +167,19 @@ shaka.offline.indexeddb.BaseStorageCell = class {
         'Cannot add new value to ' + storeName));
   }
 
+  /**
+   * @param {string} storeName
+   * @return {!Promise}
+   * @protected
+   */
+  rejectUpdate(storeName) {
+    return Promise.reject(new shaka.util.Error(
+        shaka.util.Error.Severity.CRITICAL,
+        shaka.util.Error.Category.STORAGE,
+        shaka.util.Error.Code.MODIFY_OPERATION_NOT_SUPPORTED,
+        'Cannot modify values in ' + storeName));
+  }
+
   /**
    * @param {string} storeName
    * @param {!Array.<T>} values

package/lib/offline/indexeddb/storage_mechanism.js

@@ -315,7 +315,7 @@ shaka.offline.indexeddb.StorageMechanism = class {
 
     const del = window.indexedDB.deleteDatabase(name);
     del.onblocked = (event) => {
-      shaka.log.warning('Deleting', name, 'is being blocked');
+      shaka.log.warning('Deleting', name, 'is being blocked', event);
     };
     del.onsuccess = (event) => {
       p.resolve();

package/lib/offline/indexeddb/v5_storage_cell.js

@@ -33,6 +33,11 @@ shaka.offline.indexeddb.V5StorageCell = class
     return this.add(this.manifestStore_, manifests);
   }
 
+  /** @override */
+  updateManifest(key, manifest) {
+    return this.updateManifestImplementation(key, manifest);
+  }
+
   /** @override */
   convertManifest(old) {
     // JSON serialization turns Infinity into null, so turn it back now.