Source: lib/offline/indexeddb/storage_mechanism.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.indexeddb.StorageMechanism');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.offline.StorageMuxer');
  12. goog.require('shaka.offline.indexeddb.EmeSessionStorageCell');
  13. goog.require('shaka.offline.indexeddb.V1StorageCell');
  14. goog.require('shaka.offline.indexeddb.V2StorageCell');
  15. goog.require('shaka.offline.indexeddb.V5StorageCell');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.PublicPromise');
  18. goog.require('shaka.util.Platform');
  21. /**
  22.  * A storage mechanism to manage storage cells for an indexed db instance.
  23.  * The cells are just for interacting with the stores that are found in the
  24.  * database instance. The mechanism is responsible for creating new stores
  25.  * when opening the database. If the database is too old of a version, a
  26.  * cell will be added for the old stores but the cell won't support add
  27.  * operations. The mechanism will create the new versions of the stores and
  28.  * will allow add operations for those stores.
  29.  *
  30.  * @implements {shaka.extern.StorageMechanism}
  31.  */
  32. shaka.offline.indexeddb.StorageMechanism = class {
  33.   /** */
  34.   constructor() {
  35.     /** @private {IDBDatabase} */
  36.     this.db_ = null;
  38.     /** @private {shaka.extern.StorageCell} */
  39.     this.v1_ = null;
  40.     /** @private {shaka.extern.StorageCell} */
  41.     this.v2_ = null;
  42.     /** @private {shaka.extern.StorageCell} */
  43.     this.v3_ = null;
  44.     /** @private {shaka.extern.StorageCell} */
  45.     this.v5_ = null;
  46.     /** @private {shaka.extern.EmeSessionStorageCell} */
  47.     this.sessions_ = null;
  48.   }
  50.   /**
  51.    * @override
  52.    */
  53.   init() {
  54.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  55.     const version = shaka.offline.indexeddb.StorageMechanism.VERSION;
  57.     const p = new shaka.util.PublicPromise();
  58.     const open = window.indexedDB.open(name, version);
  59.     open.onsuccess = (event) => {
  60.       const db = open.result;
  61.       this.db_ = db;
  62.       this.v1_ = shaka.offline.indexeddb.StorageMechanism.createV1_(db);
  63.       this.v2_ = shaka.offline.indexeddb.StorageMechanism.createV2_(db);
  64.       this.v3_ = shaka.offline.indexeddb.StorageMechanism.createV3_(db);
  65.       // NOTE: V4 of the database was when we introduced a special table to
  66.       // store EME session IDs.  It has no separate storage cell, so we skip to
  67.       // V5.
  68.       this.v5_ = shaka.offline.indexeddb.StorageMechanism.createV5_(db);
  69.       this.sessions_ =
  70.           shaka.offline.indexeddb.StorageMechanism.createEmeSessionCell_(db);
  71.       p.resolve();
  72.     };
  73.     open.onupgradeneeded = (event) => {
  74.       // Add object stores for the latest version only.
  75.       this.createStores_(open.result);
  76.     };
  77.     open.onerror = (event) => {
  78.       p.reject(new shaka.util.Error(
  79.           shaka.util.Error.Severity.CRITICAL,
  80.           shaka.util.Error.Category.STORAGE,
  81.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  82.           open.error));
  84.       // Firefox will raise an error on the main thread unless we stop it here.
  85.       event.preventDefault();
  86.     };
  88.     return p;
  89.   }
  91.   /**
  92.    * @override
  93.    */
  94.   async destroy() {
  95.     if (this.v1_) {
  96.       await this.v1_.destroy();
  97.     }
  98.     if (this.v2_) {
  99.       await this.v2_.destroy();
  100.     }
  101.     if (this.v3_) {
  102.       await this.v3_.destroy();
  103.     }
  104.     if (this.v5_) {
  105.       await this.v5_.destroy();
  106.     }
  107.     if (this.sessions_) {
  108.       await this.sessions_.destroy();
  109.     }
  111.     // If we were never initialized, then |db_| will still be null.
  112.     if (this.db_) {
  113.       this.db_.close();
  114.     }
  115.   }
  117.   /**
  118.    * @override
  119.    */
  120.   getCells() {
  121.     const map = new Map();
  123.     if (this.v1_) {
  124.       map.set('v1', this.v1_);
  125.     }
  126.     if (this.v2_) {
  127.       map.set('v2', this.v2_);
  128.     }
  129.     if (this.v3_) {
  130.       map.set('v3', this.v3_);
  131.     }
  132.     if (this.v5_) {
  133.       map.set('v5', this.v5_);
  134.     }
  136.     return map;
  137.   }
  139.   /**
  140.    * @override
  141.    */
  142.   getEmeSessionCell() {
  143.     goog.asserts.assert(this.sessions_, 'Cannot be destroyed.');
  144.     return this.sessions_;
  145.   }
  147.   /**
  148.    * @override
  149.    */
  150.   async erase() {
  151.     // Not all cells may have been created, so only destroy the ones that
  152.     // were created.
  153.     if (this.v1_) {
  154.       await this.v1_.destroy();
  155.     }
  156.     if (this.v2_) {
  157.       await this.v2_.destroy();
  158.     }
  159.     if (this.v3_) {
  160.       await this.v3_.destroy();
  161.     }
  162.     if (this.v5_) {
  163.       await this.v5_.destroy();
  164.     }
  166.     // |db_| will only be null if the muxer was not initialized. We need to
  167.     // close the connection in order delete the database without it being
  168.     // blocked.
  169.     if (this.db_) {
  170.       this.db_.close();
  171.     }
  173.     await shaka.offline.indexeddb.StorageMechanism.deleteAll_();
  175.     // Reset before initializing.
  176.     this.db_ = null;
  177.     this.v1_ = null;
  178.     this.v2_ = null;
  179.     this.v3_ = null;
  180.     this.v5_ = null;
  182.     await this.init();
  183.   }
  185.   /**
  186.    * @param {!IDBDatabase} db
  187.    * @return {shaka.extern.StorageCell}
  188.    * @private
  189.    */
  190.   static createV1_(db) {
  191.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  192.     const segmentStore = StorageMechanism.V1_SEGMENT_STORE;
  193.     const manifestStore = StorageMechanism.V1_MANIFEST_STORE;
  194.     const stores = db.objectStoreNames;
  195.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  196.       shaka.log.debug('Mounting v1 idb storage cell');
  198.       return new shaka.offline.indexeddb.V1StorageCell(
  199.           db,
  200.           segmentStore,
  201.           manifestStore);
  202.     }
  203.     return null;
  204.   }
  206.   /**
  207.    * @param {!IDBDatabase} db
  208.    * @return {shaka.extern.StorageCell}
  209.    * @private
  210.    */
  211.   static createV2_(db) {
  212.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  213.     const segmentStore = StorageMechanism.V2_SEGMENT_STORE;
  214.     const manifestStore = StorageMechanism.V2_MANIFEST_STORE;
  215.     const stores = db.objectStoreNames;
  216.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  217.       shaka.log.debug('Mounting v2 idb storage cell');
  219.       return new shaka.offline.indexeddb.V2StorageCell(
  220.           db,
  221.           segmentStore,
  222.           manifestStore);
  223.     }
  224.     return null;
  225.   }
  227.   /**
  228.    * @param {!IDBDatabase} db
  229.    * @return {shaka.extern.StorageCell}
  230.    * @private
  231.    */
  232.   static createV3_(db) {
  233.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  234.     const segmentStore = StorageMechanism.V3_SEGMENT_STORE;
  235.     const manifestStore = StorageMechanism.V3_MANIFEST_STORE;
  236.     const stores = db.objectStoreNames;
  237.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  238.       shaka.log.debug('Mounting v3 idb storage cell');
  240.       // Version 3 uses the same structure as version 2, so we can use the same
  241.       // cells but it can support new entries.
  242.       return new shaka.offline.indexeddb.V2StorageCell(
  243.           db,
  244.           segmentStore,
  245.           manifestStore);
  246.     }
  247.     return null;
  248.   }
  250.   /**
  251.    * @param {!IDBDatabase} db
  252.    * @return {shaka.extern.StorageCell}
  253.    * @private
  254.    */
  255.   static createV5_(db) {
  256.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  257.     const segmentStore = StorageMechanism.V5_SEGMENT_STORE;
  258.     const manifestStore = StorageMechanism.V5_MANIFEST_STORE;
  259.     const stores = db.objectStoreNames;
  260.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  261.       shaka.log.debug('Mounting v5 idb storage cell');
  263.       return new shaka.offline.indexeddb.V5StorageCell(
  264.           db,
  265.           segmentStore,
  266.           manifestStore);
  267.     }
  268.     return null;
  269.   }
  271.   /**
  272.    * @param {!IDBDatabase} db
  273.    * @return {shaka.extern.EmeSessionStorageCell}
  274.    * @private
  275.    */
  276.   static createEmeSessionCell_(db) {
  277.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  278.     const store = StorageMechanism.SESSION_ID_STORE;
  279.     if (db.objectStoreNames.contains(store)) {
  280.       shaka.log.debug('Mounting session ID idb storage cell');
  281.       return new shaka.offline.indexeddb.EmeSessionStorageCell(db, store);
  282.     }
  283.     return null;
  284.   }
  286.   /**
  287.    * @param {!IDBDatabase} db
  288.    * @private
  289.    */
  290.   createStores_(db) {
  291.     const storeNames = [
  292.       shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE,
  293.       shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE,
  294.       shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE,
  295.     ];
  297.     for (const name of storeNames) {
  298.       if (!db.objectStoreNames.contains(name)) {
  299.         db.createObjectStore(name, {autoIncrement: true});
  300.       }
  301.     }
  302.   }
  304.   /**
  305.    * Delete the indexed db instance so that all stores are deleted and cleared.
  306.    * This will force the database to a like-new state next time it opens.
  307.    *
  308.    * @return {!Promise}
  309.    * @private
  310.    */
  311.   static deleteAll_() {
  312.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  314.     const p = new shaka.util.PublicPromise();
  316.     const del = window.indexedDB.deleteDatabase(name);
  317.     del.onblocked = (event) => {
  318.       shaka.log.warning('Deleting', name, 'is being blocked', event);
  319.     };
  320.     del.onsuccess = (event) => {
  321.       p.resolve();
  322.     };
  323.     del.onerror = (event) => {
  324.       p.reject(new shaka.util.Error(
  325.           shaka.util.Error.Severity.CRITICAL,
  326.           shaka.util.Error.Category.STORAGE,
  327.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  328.           del.error));
  330.       // Firefox will raise an error on the main thread unless we stop it here.
  331.       event.preventDefault();
  332.     };
  334.     return p;
  335.   }
  336. };
  338. /** @const {string} */
  339. shaka.offline.indexeddb.StorageMechanism.DB_NAME = 'shaka_offline_db';
  340. /** @const {number} */
  341. shaka.offline.indexeddb.StorageMechanism.VERSION = 5;
  342. /** @const {string} */
  343. shaka.offline.indexeddb.StorageMechanism.V1_SEGMENT_STORE = 'segment';
  344. /** @const {string} */
  345. shaka.offline.indexeddb.StorageMechanism.V2_SEGMENT_STORE = 'segment-v2';
  346. /** @const {string} */
  347. shaka.offline.indexeddb.StorageMechanism.V3_SEGMENT_STORE = 'segment-v3';
  348. /** @const {string} */
  349. shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE = 'segment-v5';
  350. /** @const {string} */
  351. shaka.offline.indexeddb.StorageMechanism.V1_MANIFEST_STORE = 'manifest';
  352. /** @const {string} */
  353. shaka.offline.indexeddb.StorageMechanism.V2_MANIFEST_STORE = 'manifest-v2';
  354. /** @const {string} */
  355. shaka.offline.indexeddb.StorageMechanism.V3_MANIFEST_STORE = 'manifest-v3';
  356. /** @const {string} */
  357. shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE = 'manifest-v5';
  358. /** @const {string} */
  359. shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
  362. // Since this may be called before the polyfills remove indexeddb support from
  363. // some platforms (looking at you Chromecast), we need to check for support
  364. // when we create the mechanism.
  365. //
  366. // Thankfully the storage muxer api allows us to return a null mechanism
  367. // to indicate that the mechanism is not supported on this platform.
  368. shaka.offline.StorageMuxer.register(
  369.     'idb',
  370.     () => {
  371.       // Offline storage is not supported on the Chromecast platform.
  372.       if (shaka.util.Platform.isChromecast()) {
  373.         return null;
  374.       }
  375.       // Offline storage requires the IndexedDB API.
  376.       if (!window.indexedDB) {
  377.         return null;
  378.       }
  379.       return new shaka.offline.indexeddb.StorageMechanism();
  380.     });