shaka-player 3.2.2 → 3.3.0

package/lib/media/segment_reference.js

@@ -23,11 +23,13 @@ shaka.media.InitSegmentReference = class {
    *   of the resource containing the segment.
    * @param {number} startByte The offset from the start of the resource to the
    *   start of the segment.
-   * @param {?number} endByte The offset from the start of the resource to the
-   *   end of the segment, inclusive.  A value of null indicates that the
+   * @param {?number} endByte The offset from the start of the resource
+   *   to the end of the segment, inclusive.  A value of null indicates that the
    *   segment extends to the end of the resource.
+   * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
+   *   the quality of the media associated with this init segment.
    */
-  constructor(uris, startByte, endByte) {
+  constructor(uris, startByte, endByte, mediaQuality = null) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -36,6 +38,9 @@ shaka.media.InitSegmentReference = class {
 
     /** @const {?number} */
     this.endByte = endByte;
+
+    /** @const {shaka.extern.MediaQualityInfo|null} */
+    this.mediaQuality = mediaQuality;
   }
 
   /**
@@ -73,6 +78,16 @@ shaka.media.InitSegmentReference = class {
     }
   }
 
+  /**
+   * Returns media quality information for the segments associated with
+   * this init segment.
+   *
+   * @return {?shaka.extern.MediaQualityInfo}
+   */
+  getMediaQuality() {
+    return this.mediaQuality;
+  }
+
   /**
    * Check if two initSegmentReference have all the same values.
    * @param {?shaka.media.InitSegmentReference} reference1

package/lib/media/streaming_engine.js

@@ -431,6 +431,11 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.reinitText(fullMimeType);
     }
 
+    // Releases the segmentIndex of the old stream.
+    if (mediaState.stream.closeSegmentIndex) {
+      mediaState.stream.closeSegmentIndex();
+    }
+
     mediaState.stream = stream;
     mediaState.segmentIterator = null;
 
@@ -863,7 +868,7 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
-    // Make sure the segment index exists.
+    // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
 
@@ -873,6 +878,12 @@ shaka.media.StreamingEngine = class {
         // We switched streams while in the middle of this async call to
         // createSegmentIndex.  Abandon this update and schedule a new one if
         // there's not already one pending.
+        // Releases the segmentIndex of the old stream.
+        if (thisStream.closeSegmentIndex) {
+          goog.asserts.assert(!mediaState.stream.segmentIndex,
+              'mediastate.stream should not have segmentIndex yet.');
+          thisStream.closeSegmentIndex();
+        }
         if (mediaState.updateTimer == null) {
           this.scheduleUpdate_(mediaState, 0);
         }
@@ -1530,6 +1541,8 @@ shaka.media.StreamingEngine = class {
             throw error;
           }
         };
+        this.playerInterface_.onInitSegmentAppended(
+            reference.startTime, reference.initSegmentReference);
         operations.push(append());
       }
     }
@@ -1555,7 +1568,9 @@ shaka.media.StreamingEngine = class {
 
     const hasClosedCaptions = stream.closedCaptions &&
         stream.closedCaptions.size > 0;
-    if (stream.emsgSchemeIdUris != null && stream.emsgSchemeIdUris.length > 0) {
+    if ((stream.emsgSchemeIdUris != null &&
+        stream.emsgSchemeIdUris.length > 0) ||
+        this.config_.dispatchAllEmsgBoxes) {
       new shaka.util.Mp4Parser()
           .fullBox(
               'emsg',
@@ -1641,7 +1656,8 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if (emsgSchemeIdUris.includes(schemeId) ||
+        this.config_.dispatchAllEmsgBoxes) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
@@ -1764,6 +1780,19 @@ shaka.media.StreamingEngine = class {
 
     shaka.log.v2('fetching: reference=', reference);
 
+    const stream = mediaState.stream;
+    this.playerInterface_.modifySegmentRequest(
+        request,
+        {
+          type: stream.type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: stream.mimeType,
+          codecs: stream.codecs,
+          bandwidth: stream.bandwidth,
+        },
+    );
+
     const op = this.playerInterface_.netEngine.request(requestType, request);
     mediaState.operation = op;
     const response = await op.promise;
@@ -1927,12 +1956,15 @@ shaka.media.StreamingEngine = class {
  * @typedef {{
  *   getPresentationTime: function():number,
  *   getBandwidthEstimate: function():number,
+ *   modifySegmentRequest: function(shaka.extern.Request,
+ *     shaka.util.CmcdManager.SegmentInfo),
  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  *   netEngine: shaka.net.NetworkingEngine,
  *   onError: function(!shaka.util.Error),
  *   onEvent: function(!Event),
  *   onManifestUpdate: function(),
- *   onSegmentAppended: function()
+ *   onSegmentAppended: function(),
+ *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference)
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -1940,6 +1972,9 @@ shaka.media.StreamingEngine = class {
  *   viewer is seeing on screen right now.
  * @property {function():number} getBandwidthEstimate
  *   Get the estimated bandwidth in bits per second.
+ * @property {function(shaka.extern.Request,
+ *   shaka.extern.Cmcd.SegmentInfo)} modifySegmentRequest
+ *   The request modifier
  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  *   The MediaSourceEngine. The caller retains ownership.
  * @property {shaka.net.NetworkingEngine} netEngine
@@ -1954,6 +1989,9 @@ shaka.media.StreamingEngine = class {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  * @property {function()} onSegmentAppended
  *   Called after a segment is successfully appended to a MediaSource.
+ * @property
+ *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
+ *   Called when an init segment is appended to a MediaSource.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 

package/lib/net/http_fetch_plugin.js

@@ -27,10 +27,12 @@ shaka.net.HttpFetchPlugin = 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 headers = new shaka.net.HttpFetchPlugin.Headers_();
     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
       headers.append(key, value);
@@ -55,7 +57,7 @@ shaka.net.HttpFetchPlugin = class {
     };
 
     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
-        uri, requestType, init, abortStatus, progressUpdated,
+        uri, requestType, init, abortStatus, progressUpdated, headersReceived,
         request.streamDataCallback);
 
     /** @type {!shaka.util.AbortableOperation} */
@@ -92,12 +94,13 @@ shaka.net.HttpFetchPlugin = class {
    * @param {!RequestInit} init
    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
    * @param {shaka.extern.ProgressUpdated} progressUpdated
+   * @param {shaka.extern.HeadersReceived} headersReceived
    * @param {?function(BufferSource):!Promise} streamDataCallback
    * @return {!Promise<!shaka.extern.Response>}
    * @private
    */
   static async request_(uri, requestType, init, abortStatus, progressUpdated,
-      streamDataCallback) {
+      headersReceived, streamDataCallback) {
     const fetch = shaka.net.HttpFetchPlugin.fetch_;
     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
     let response;
@@ -113,6 +116,10 @@ shaka.net.HttpFetchPlugin = class {
       // headers are available. The download itself isn't done until the promise
       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
       response = await fetch(uri, init);
+      // At this point in the process, we have the headers of the response, but
+      // not the body yet.
+      headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
+          response.headers));
       // Getting the reader in this way allows us to observe the process of
       // downloading the body, instead of just waiting for an opaque promise to
       // resolve.
@@ -194,19 +201,28 @@ shaka.net.HttpFetchPlugin = class {
       }
     }
 
-    const headers = {};
-    /** @type {Headers} */
-    const responseHeaders = response.headers;
-    responseHeaders.forEach((value, key) => {
-      // Since Edge incorrectly return the header with a leading new line
-      // character ('\n'), we trim the header here.
-      headers[key.trim()] = value;
-    });
+    const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
+        response.headers);
 
     return shaka.net.HttpPluginUtils.makeResponse(
         headers, arrayBuffer, response.status, uri, response.url, requestType);
   }
 
+  /**
+   * @param {!Headers} headers
+   * @return {!Object.<string, string>}
+   * @private
+   */
+  static headersToGenericObject_(headers) {
+    const headersObj = {};
+    headers.forEach((value, key) => {
+      // Since Edge incorrectly return the header with a leading new line
+      // character ('\n'), we trim the header here.
+      headersObj[key.trim()] = value;
+    });
+    return headersObj;
+  }
+
   /**
    * Determine if the Fetch API is supported in the browser. Note: this is
    * deliberately exposed as a method to allow the client app to use the same
@@ -290,4 +306,8 @@ if (shaka.net.HttpFetchPlugin.isSupported()) {
       'https', shaka.net.HttpFetchPlugin.parse,
       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
       /* progressSupport= */ true);
+  shaka.net.NetworkingEngine.registerScheme(
+      'blob', shaka.net.HttpFetchPlugin.parse,
+      shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
+      /* progressSupport= */ true);
 }

package/lib/net/http_plugin_utils.js

@@ -34,6 +34,7 @@ shaka.net.HttpPluginUtils = class {
         uri: responseURL || uri,
         originalUri: uri,
         data: data,
+        status: status,
         headers: headers,
         fromCache: !!headers['x-shaka-from-cache'],
       };

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();
       }
@@ -764,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.