tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

encrypted-media.idl (4427B)

      1 // GENERATED CONTENT - DO NOT EDIT
      2 // Content was automatically extracted by Reffy into webref
      3 // (https://github.com/w3c/webref)
      4 // Source: Encrypted Media Extensions (https://w3c.github.io/encrypted-media/)
      5 
      6 [Exposed=Window]
      7 partial interface Navigator {
      8  [SecureContext] Promise<MediaKeySystemAccess> requestMediaKeySystemAccess (
      9      DOMString keySystem,
     10      sequence<MediaKeySystemConfiguration> supportedConfigurations);
     11 };
     12 
     13 enum MediaKeysRequirement {
     14  "required",
     15  "optional",
     16  "not-allowed"
     17 };
     18 
     19 dictionary MediaKeySystemConfiguration {
     20  DOMString                               label = "";
     21  sequence<DOMString>                     initDataTypes = [];
     22  sequence<MediaKeySystemMediaCapability> audioCapabilities = [];
     23  sequence<MediaKeySystemMediaCapability> videoCapabilities = [];
     24  MediaKeysRequirement                    distinctiveIdentifier = "optional";
     25  MediaKeysRequirement                    persistentState = "optional";
     26  sequence<DOMString>                     sessionTypes;
     27 };
     28 
     29 dictionary MediaKeySystemMediaCapability {
     30  DOMString contentType = "";
     31  DOMString? encryptionScheme = null;
     32  DOMString robustness = "";
     33 };
     34 
     35 [Exposed=Window, SecureContext] interface MediaKeySystemAccess {
     36  readonly attribute DOMString keySystem;
     37  MediaKeySystemConfiguration  getConfiguration ();
     38  Promise<MediaKeys>           createMediaKeys ();
     39 };
     40 
     41 enum MediaKeySessionType {
     42  "temporary",
     43  "persistent-license"
     44 };
     45 
     46 [Exposed=Window, SecureContext] interface MediaKeys {
     47    MediaKeySession createSession (optional MediaKeySessionType sessionType = "temporary");
     48    Promise<MediaKeyStatus> getStatusForPolicy (optional MediaKeysPolicy policy = {});
     49    Promise<boolean> setServerCertificate (BufferSource serverCertificate);
     50 };
     51 
     52 dictionary MediaKeysPolicy {
     53    DOMString minHdcpVersion;
     54 };
     55 
     56 enum MediaKeySessionClosedReason {
     57  "internal-error",
     58  "closed-by-application",
     59  "release-acknowledged",
     60  "hardware-context-reset",
     61  "resource-evicted"
     62 };
     63 
     64 [Exposed=Window, SecureContext] interface MediaKeySession : EventTarget {
     65  readonly        attribute DOMString                            sessionId;
     66  readonly        attribute unrestricted double                  expiration;
     67  readonly        attribute Promise<MediaKeySessionClosedReason> closed;
     68  readonly        attribute MediaKeyStatusMap                    keyStatuses;
     69                  attribute EventHandler                         onkeystatuseschange;
     70                  attribute EventHandler                         onmessage;
     71  Promise<undefined>    generateRequest (DOMString initDataType, BufferSource initData);
     72  Promise<boolean> load (DOMString sessionId);
     73  Promise<undefined>    update (BufferSource response);
     74  Promise<undefined>    close ();
     75  Promise<undefined>    remove ();
     76 };
     77 
     78 [Exposed=Window, SecureContext] interface MediaKeyStatusMap {
     79  iterable<BufferSource,MediaKeyStatus>;
     80  readonly attribute unsigned long size;
     81  boolean has (BufferSource keyId);
     82  (MediaKeyStatus or undefined) get (BufferSource keyId);
     83 };
     84 
     85 enum MediaKeyStatus {
     86  "usable",
     87  "expired",
     88  "released",
     89  "output-restricted",
     90  "output-downscaled",
     91  "usable-in-future",
     92  "status-pending",
     93  "internal-error"
     94 };
     95 
     96 enum MediaKeyMessageType {
     97  "license-request",
     98  "license-renewal",
     99  "license-release",
    100  "individualization-request"
    101 };
    102 
    103 [Exposed=Window, SecureContext]
    104 interface MediaKeyMessageEvent : Event {
    105  constructor(DOMString type, MediaKeyMessageEventInit eventInitDict);
    106  readonly attribute MediaKeyMessageType messageType;
    107  readonly attribute ArrayBuffer         message;
    108 };
    109 
    110 dictionary MediaKeyMessageEventInit : EventInit {
    111  required MediaKeyMessageType messageType;
    112  required ArrayBuffer         message;
    113 };
    114 
    115 [Exposed=Window] partial interface HTMLMediaElement {
    116  [SecureContext] readonly        attribute MediaKeys?   mediaKeys;
    117                                  attribute EventHandler onencrypted;
    118                                  attribute EventHandler onwaitingforkey;
    119  [SecureContext] Promise<undefined> setMediaKeys (MediaKeys? mediaKeys);
    120 };
    121 
    122 [Exposed=Window]
    123 interface MediaEncryptedEvent : Event {
    124    constructor(DOMString type, optional MediaEncryptedEventInit eventInitDict = {});
    125    readonly        attribute DOMString    initDataType;
    126    readonly        attribute ArrayBuffer? initData;
    127 };
    128 
    129 dictionary MediaEncryptedEventInit : EventInit {
    130  DOMString    initDataType = "";
    131  ArrayBuffer? initData = null;
    132 };