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');
  19. goog.require('shaka.util.Timer');
  22. /**
  23.  * A storage mechanism to manage storage cells for an indexed db instance.
  24.  * The cells are just for interacting with the stores that are found in the
  25.  * database instance. The mechanism is responsible for creating new stores
  26.  * when opening the database. If the database is too old of a version, a
  27.  * cell will be added for the old stores but the cell won't support add
  28.  * operations. The mechanism will create the new versions of the stores and
  29.  * will allow add operations for those stores.
  30.  *
  31.  * @implements {shaka.extern.StorageMechanism}
  32.  */
  33. shaka.offline.indexeddb.StorageMechanism = class {
  34.   /** */
  35.   constructor() {
  36.     /** @private {IDBDatabase} */
  37.     this.db_ = null;
  39.     /** @private {shaka.extern.StorageCell} */
  40.     this.v1_ = null;
  41.     /** @private {shaka.extern.StorageCell} */
  42.     this.v2_ = null;
  43.     /** @private {shaka.extern.StorageCell} */
  44.     this.v3_ = null;
  45.     /** @private {shaka.extern.StorageCell} */
  46.     this.v5_ = null;
  47.     /** @private {shaka.extern.EmeSessionStorageCell} */
  48.     this.sessions_ = null;
  49.   }
  51.   /**
  52.    * @override
  53.    */
  54.   init() {
  55.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  56.     const version = shaka.offline.indexeddb.StorageMechanism.VERSION;
  58.     const p = new shaka.util.PublicPromise();
  60.     // Add a timeout mechanism, for the (rare?) case where no callbacks are
  61.     // called at all, so that this method doesn't hang forever.
  62.     let timedOut = false;
  63.     const timeOutTimer = new shaka.util.Timer(() => {
  64.       timedOut = true;
  65.       p.reject(new shaka.util.Error(
  66.           shaka.util.Error.Severity.CRITICAL,
  67.           shaka.util.Error.Category.STORAGE,
  68.           shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
  69.     });
  70.     timeOutTimer.tickAfter(5);
  72.     const open = window.indexedDB.open(name, version);
  73.     open.onsuccess = (event) => {
  74.       if (timedOut) {
  75.         // Too late, we have already given up on opening the storage mechanism.
  76.         return;
  77.       }
  78.       const db = open.result;
  79.       this.db_ = db;
  80.       this.v1_ = shaka.offline.indexeddb.StorageMechanism.createV1_(db);
  81.       this.v2_ = shaka.offline.indexeddb.StorageMechanism.createV2_(db);
  82.       this.v3_ = shaka.offline.indexeddb.StorageMechanism.createV3_(db);
  83.       // NOTE: V4 of the database was when we introduced a special table to
  84.       // store EME session IDs.  It has no separate storage cell, so we skip to
  85.       // V5.
  86.       this.v5_ = shaka.offline.indexeddb.StorageMechanism.createV5_(db);
  87.       this.sessions_ =
  88.           shaka.offline.indexeddb.StorageMechanism.createEmeSessionCell_(db);
  89.       timeOutTimer.stop();
  90.       p.resolve();
  91.     };
  92.     open.onupgradeneeded = (event) => {
  93.       // Add object stores for the latest version only.
  94.       this.createStores_(open.result);
  95.     };
  96.     open.onerror = (event) => {
  97.       if (timedOut) {
  98.         // Too late, we have already given up on opening the storage mechanism.
  99.         return;
  100.       }
  101.       p.reject(new shaka.util.Error(
  102.           shaka.util.Error.Severity.CRITICAL,
  103.           shaka.util.Error.Category.STORAGE,
  104.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  105.           open.error));
  106.       timeOutTimer.stop();
  108.       // Firefox will raise an error on the main thread unless we stop it here.
  109.       event.preventDefault();
  110.     };
  112.     return p;
  113.   }
  115.   /**
  116.    * @override
  117.    */
  118.   async destroy() {
  119.     if (this.v1_) {
  120.       await this.v1_.destroy();
  121.     }
  122.     if (this.v2_) {
  123.       await this.v2_.destroy();
  124.     }
  125.     if (this.v3_) {
  126.       await this.v3_.destroy();
  127.     }
  128.     if (this.v5_) {
  129.       await this.v5_.destroy();
  130.     }
  131.     if (this.sessions_) {
  132.       await this.sessions_.destroy();
  133.     }
  135.     // If we were never initialized, then |db_| will still be null.
  136.     if (this.db_) {
  137.       this.db_.close();
  138.     }
  139.   }
  141.   /**
  142.    * @override
  143.    */
  144.   getCells() {
  145.     const map = new Map();
  147.     if (this.v1_) {
  148.       map.set('v1', this.v1_);
  149.     }
  150.     if (this.v2_) {
  151.       map.set('v2', this.v2_);
  152.     }
  153.     if (this.v3_) {
  154.       map.set('v3', this.v3_);
  155.     }
  156.     if (this.v5_) {
  157.       map.set('v5', this.v5_);
  158.     }
  160.     return map;
  161.   }
  163.   /**
  164.    * @override
  165.    */
  166.   getEmeSessionCell() {
  167.     goog.asserts.assert(this.sessions_, 'Cannot be destroyed.');
  168.     return this.sessions_;
  169.   }
  171.   /**
  172.    * @override
  173.    */
  174.   async erase() {
  175.     // Not all cells may have been created, so only destroy the ones that
  176.     // were created.
  177.     if (this.v1_) {
  178.       await this.v1_.destroy();
  179.     }
  180.     if (this.v2_) {
  181.       await this.v2_.destroy();
  182.     }
  183.     if (this.v3_) {
  184.       await this.v3_.destroy();
  185.     }
  186.     if (this.v5_) {
  187.       await this.v5_.destroy();
  188.     }
  190.     // |db_| will only be null if the muxer was not initialized. We need to
  191.     // close the connection in order delete the database without it being
  192.     // blocked.
  193.     if (this.db_) {
  194.       this.db_.close();
  195.     }
  197.     await shaka.offline.indexeddb.StorageMechanism.deleteAll_();
  199.     // Reset before initializing.
  200.     this.db_ = null;
  201.     this.v1_ = null;
  202.     this.v2_ = null;
  203.     this.v3_ = null;
  204.     this.v5_ = null;
  206.     await this.init();
  207.   }
  209.   /**
  210.    * @param {!IDBDatabase} db
  211.    * @return {shaka.extern.StorageCell}
  212.    * @private
  213.    */
  214.   static createV1_(db) {
  215.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  216.     const segmentStore = StorageMechanism.V1_SEGMENT_STORE;
  217.     const manifestStore = StorageMechanism.V1_MANIFEST_STORE;
  218.     const stores = db.objectStoreNames;
  219.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  220.       shaka.log.debug('Mounting v1 idb storage cell');
  222.       return new shaka.offline.indexeddb.V1StorageCell(
  223.           db,
  224.           segmentStore,
  225.           manifestStore);
  226.     }
  227.     return null;
  228.   }
  230.   /**
  231.    * @param {!IDBDatabase} db
  232.    * @return {shaka.extern.StorageCell}
  233.    * @private
  234.    */
  235.   static createV2_(db) {
  236.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  237.     const segmentStore = StorageMechanism.V2_SEGMENT_STORE;
  238.     const manifestStore = StorageMechanism.V2_MANIFEST_STORE;
  239.     const stores = db.objectStoreNames;
  240.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  241.       shaka.log.debug('Mounting v2 idb storage cell');
  243.       return new shaka.offline.indexeddb.V2StorageCell(
  244.           db,
  245.           segmentStore,
  246.           manifestStore);
  247.     }
  248.     return null;
  249.   }
  251.   /**
  252.    * @param {!IDBDatabase} db
  253.    * @return {shaka.extern.StorageCell}
  254.    * @private
  255.    */
  256.   static createV3_(db) {
  257.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  258.     const segmentStore = StorageMechanism.V3_SEGMENT_STORE;
  259.     const manifestStore = StorageMechanism.V3_MANIFEST_STORE;
  260.     const stores = db.objectStoreNames;
  261.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  262.       shaka.log.debug('Mounting v3 idb storage cell');
  264.       // Version 3 uses the same structure as version 2, so we can use the same
  265.       // cells but it can support new entries.
  266.       return new shaka.offline.indexeddb.V2StorageCell(
  267.           db,
  268.           segmentStore,
  269.           manifestStore);
  270.     }
  271.     return null;
  272.   }
  274.   /**
  275.    * @param {!IDBDatabase} db
  276.    * @return {shaka.extern.StorageCell}
  277.    * @private
  278.    */
  279.   static createV5_(db) {
  280.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  281.     const segmentStore = StorageMechanism.V5_SEGMENT_STORE;
  282.     const manifestStore = StorageMechanism.V5_MANIFEST_STORE;
  283.     const stores = db.objectStoreNames;
  284.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  285.       shaka.log.debug('Mounting v5 idb storage cell');
  287.       return new shaka.offline.indexeddb.V5StorageCell(
  288.           db,
  289.           segmentStore,
  290.           manifestStore);
  291.     }
  292.     return null;
  293.   }
  295.   /**
  296.    * @param {!IDBDatabase} db
  297.    * @return {shaka.extern.EmeSessionStorageCell}
  298.    * @private
  299.    */
  300.   static createEmeSessionCell_(db) {
  301.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  302.     const store = StorageMechanism.SESSION_ID_STORE;
  303.     if (db.objectStoreNames.contains(store)) {
  304.       shaka.log.debug('Mounting session ID idb storage cell');
  305.       return new shaka.offline.indexeddb.EmeSessionStorageCell(db, store);
  306.     }
  307.     return null;
  308.   }
  310.   /**
  311.    * @param {!IDBDatabase} db
  312.    * @private
  313.    */
  314.   createStores_(db) {
  315.     const storeNames = [
  316.       shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE,
  317.       shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE,
  318.       shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE,
  319.     ];
  321.     for (const name of storeNames) {
  322.       if (!db.objectStoreNames.contains(name)) {
  323.         db.createObjectStore(name, {autoIncrement: true});
  324.       }
  325.     }
  326.   }
  328.   /**
  329.    * Delete the indexed db instance so that all stores are deleted and cleared.
  330.    * This will force the database to a like-new state next time it opens.
  331.    *
  332.    * @return {!Promise}
  333.    * @private
  334.    */
  335.   static deleteAll_() {
  336.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  338.     const p = new shaka.util.PublicPromise();
  340.     const del = window.indexedDB.deleteDatabase(name);
  341.     del.onblocked = (event) => {
  342.       shaka.log.warning('Deleting', name, 'is being blocked', event);
  343.     };
  344.     del.onsuccess = (event) => {
  345.       p.resolve();
  346.     };
  347.     del.onerror = (event) => {
  348.       p.reject(new shaka.util.Error(
  349.           shaka.util.Error.Severity.CRITICAL,
  350.           shaka.util.Error.Category.STORAGE,
  351.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  352.           del.error));
  354.       // Firefox will raise an error on the main thread unless we stop it here.
  355.       event.preventDefault();
  356.     };
  358.     return p;
  359.   }
  360. };
  362. /** @const {string} */
  363. shaka.offline.indexeddb.StorageMechanism.DB_NAME = 'shaka_offline_db';
  364. /** @const {number} */
  365. shaka.offline.indexeddb.StorageMechanism.VERSION = 5;
  366. /** @const {string} */
  367. shaka.offline.indexeddb.StorageMechanism.V1_SEGMENT_STORE = 'segment';
  368. /** @const {string} */
  369. shaka.offline.indexeddb.StorageMechanism.V2_SEGMENT_STORE = 'segment-v2';
  370. /** @const {string} */
  371. shaka.offline.indexeddb.StorageMechanism.V3_SEGMENT_STORE = 'segment-v3';
  372. /** @const {string} */
  373. shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE = 'segment-v5';
  374. /** @const {string} */
  375. shaka.offline.indexeddb.StorageMechanism.V1_MANIFEST_STORE = 'manifest';
  376. /** @const {string} */
  377. shaka.offline.indexeddb.StorageMechanism.V2_MANIFEST_STORE = 'manifest-v2';
  378. /** @const {string} */
  379. shaka.offline.indexeddb.StorageMechanism.V3_MANIFEST_STORE = 'manifest-v3';
  380. /** @const {string} */
  381. shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE = 'manifest-v5';
  382. /** @const {string} */
  383. shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
  386. // Since this may be called before the polyfills remove indexeddb support from
  387. // some platforms (looking at you Chromecast), we need to check for support
  388. // when we create the mechanism.
  389. //
  390. // Thankfully the storage muxer api allows us to return a null mechanism
  391. // to indicate that the mechanism is not supported on this platform.
  392. shaka.offline.StorageMuxer.register(
  393.     'idb',
  394.     () => {
  395.       // Offline storage is not supported on the Chromecast Linux/Fuchsia or
  396.       // Xbox One platforms.
  397.       if ((shaka.util.Platform.isChromecast() &&
  398.           !shaka.util.Platform.isAndroidCastDevice()) ||
  399.           shaka.util.Platform.isXboxOne()) {
  400.         return null;
  401.       }
  402.       // Offline storage requires the IndexedDB API.
  403.       if (!window.indexedDB) {
  404.         return null;
  405.       }
  406.       return new shaka.offline.indexeddb.StorageMechanism();
  407.     });