Improve use of NeverDestroyed
[WebKit-https.git] / Source / WebCore / Modules / encryptedmedia / MediaKeySession.cpp
1 /*
2  * Copyright (C) 2016 Metrological Group B.V.
3  * Copyright (C) 2016 Igalia S.L.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials provided
14  *    with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "MediaKeySession.h"
31
32 #if ENABLE(ENCRYPTED_MEDIA)
33
34 #include "CDM.h"
35 #include "CDMInstance.h"
36 #include "Document.h"
37 #include "EventNames.h"
38 #include "MediaKeyMessageEvent.h"
39 #include "MediaKeyMessageType.h"
40 #include "MediaKeyStatusMap.h"
41 #include "NotImplemented.h"
42 #include "SecurityOrigin.h"
43 #include "SharedBuffer.h"
44
45 namespace WebCore {
46
47 Ref<MediaKeySession> MediaKeySession::create(ScriptExecutionContext& context, MediaKeySessionType sessionType, bool useDistinctiveIdentifier, Ref<CDM>&& implementation, Ref<CDMInstance>&& instance)
48 {
49     auto session = adoptRef(*new MediaKeySession(context, sessionType, useDistinctiveIdentifier, WTFMove(implementation), WTFMove(instance)));
50     session->suspendIfNeeded();
51     return session;
52 }
53
54 MediaKeySession::MediaKeySession(ScriptExecutionContext& context, MediaKeySessionType sessionType, bool useDistinctiveIdentifier, Ref<CDM>&& implementation, Ref<CDMInstance>&& instance)
55     : ActiveDOMObject(&context)
56     , m_expiration(std::numeric_limits<double>::quiet_NaN())
57     , m_keyStatuses(MediaKeyStatusMap::create(*this))
58     , m_useDistinctiveIdentifier(useDistinctiveIdentifier)
59     , m_sessionType(sessionType)
60     , m_implementation(WTFMove(implementation))
61     , m_instance(WTFMove(instance))
62     , m_eventQueue(*this)
63     , m_weakPtrFactory(this)
64 {
65     // https://w3c.github.io/encrypted-media/#dom-mediakeys-setservercertificate
66     // W3C Editor's Draft 09 November 2016
67     // createSession(), ctd.
68
69     // 3.1. Let the sessionId attribute be the empty string.
70     // 3.2. Let the expiration attribute be NaN.
71     // 3.3. Let the closed attribute be a new promise.
72     // 3.4. Let key status be a new empty MediaKeyStatusMap object, and initialize it as follows:
73     // 3.4.1. Let the size attribute be 0.
74     // 3.5. Let the session type value be sessionType.
75     // 3.6. Let the uninitialized value be true.
76     // 3.7. Let the callable value be false.
77     // 3.8. Let the use distinctive identifier value be this object's use distinctive identifier value.
78     // 3.9. Let the cdm implementation value be this object's cdm implementation.
79     // 3.10. Let the cdm instance value be this object's cdm instance.
80
81     UNUSED_PARAM(m_callable);
82     UNUSED_PARAM(m_sessionType);
83     UNUSED_PARAM(m_useDistinctiveIdentifier);
84     UNUSED_PARAM(m_closed);
85     UNUSED_PARAM(m_uninitialized);
86 }
87
88 MediaKeySession::~MediaKeySession()
89 {
90     m_keyStatuses->detachSession();
91 }
92
93 const String& MediaKeySession::sessionId() const
94 {
95     return m_sessionId;
96 }
97
98 double MediaKeySession::expiration() const
99 {
100     return m_expiration;
101 }
102
103 Ref<MediaKeyStatusMap> MediaKeySession::keyStatuses() const
104 {
105     return m_keyStatuses.copyRef();
106 }
107
108 void MediaKeySession::generateRequest(const AtomicString& initDataType, const BufferSource& initData, Ref<DeferredPromise>&& promise)
109 {
110     // https://w3c.github.io/encrypted-media/#dom-mediakeysession-generaterequest
111     // W3C Editor's Draft 09 November 2016
112
113     // When this method is invoked, the user agent must run the following steps:
114     // 1. If this object is closed, return a promise rejected with an InvalidStateError.
115     // 2. If this object's uninitialized value is false, return a promise rejected with an InvalidStateError.
116     if (m_closed || !m_uninitialized) {
117         promise->reject(INVALID_STATE_ERR);
118         return;
119     }
120
121     // 3. Let this object's uninitialized value be false.
122     m_uninitialized = false;
123
124     // 4. If initDataType is the empty string, return a promise rejected with a newly created TypeError.
125     // 5. If initData is an empty array, return a promise rejected with a newly created TypeError.
126     if (initDataType.isEmpty() || !initData.length()) {
127         promise->reject(TypeError);
128         return;
129     }
130
131     // 6. If the Key System implementation represented by this object's cdm implementation value does not support
132     //    initDataType as an Initialization Data Type, return a promise rejected with a NotSupportedError. String
133     //    comparison is case-sensitive.
134     if (!m_implementation->supportsInitDataType(initDataType)) {
135         promise->reject(NOT_SUPPORTED_ERR);
136         return;
137     }
138
139     // 7. Let init data be a copy of the contents of the initData parameter.
140     // 8. Let session type be this object's session type.
141     // 9. Let promise be a new promise.
142     // 10. Run the following steps in parallel:
143     m_taskQueue.enqueueTask([this, initData = SharedBuffer::create(initData.data(), initData.length()), initDataType, promise = WTFMove(promise)] () mutable {
144         // 10.1. If the init data is not valid for initDataType, reject promise with a newly created TypeError.
145         // 10.2. Let sanitized init data be a validated and sanitized version of init data.
146         RefPtr<SharedBuffer> sanitizedInitData = m_implementation->sanitizeInitData(initDataType, initData);
147
148         // 10.3. If the preceding step failed, reject promise with a newly created TypeError.
149         if (!sanitizedInitData) {
150             promise->reject(TypeError);
151             return;
152         }
153
154         // 10.4. If sanitized init data is empty, reject promise with a NotSupportedError.
155         if (sanitizedInitData->isEmpty()) {
156             promise->reject(NOT_SUPPORTED_ERR);
157             return;
158         }
159
160         // 10.5. Let session id be the empty string.
161         // 10.6. Let message be null.
162         // 10.7. Let message type be null.
163         // 10.8. Let cdm be the CDM instance represented by this object's cdm instance value.
164         // 10.9. Use the cdm to execute the following steps:
165         // 10.9.1. If the sanitized init data is not supported by the cdm, reject promise with a NotSupportedError.
166         if (!m_implementation->supportsInitData(initDataType, *sanitizedInitData)) {
167             promise->reject(NOT_SUPPORTED_ERR);
168             return;
169         }
170
171         // 10.9.2 Follow the steps for the value of session type from the following list:
172         //   ↳ "temporary"
173         //     Let requested license type be a temporary non-persistable license.
174         //   ↳ "persistent-license"
175         //     Let requested license type be a persistable license.
176         //   ↳ "persistent-usage-record"
177         //     1. Initialize this object's record of key usage as follows.
178         //        Set the list of key IDs known to the session to an empty list.
179         //        Set the first decrypt time to null.
180         //        Set the latest decrypt time to null.
181         //     2. Let requested license type be a non-persistable license that will
182         //        persist a record of key usage.
183
184         if (m_sessionType == MediaKeySessionType::PersistentUsageRecord) {
185             m_recordOfKeyUsage.clear();
186             m_firstDecryptTime = 0;
187             m_latestDecryptTime = 0;
188         }
189
190         m_instance->requestLicense(m_sessionType, initDataType, WTFMove(initData), [this, weakThis = m_weakPtrFactory.createWeakPtr(), promise = WTFMove(promise)] (Ref<SharedBuffer>&& message, const String& sessionId, bool needsIndividualization, CDMInstance::SuccessValue succeeded) mutable {
191             if (!weakThis)
192                 return;
193
194             // 10.9.3. Let session id be a unique Session ID string.
195
196             MediaKeyMessageType messageType;
197             if (!needsIndividualization) {
198                 // 10.9.4. If a license request for the requested license type can be generated based on the sanitized init data:
199                 // 10.9.4.1. Let message be a license request for the requested license type generated based on the sanitized init data interpreted per initDataType.
200                 // 10.9.4.2. Let message type be "license-request".
201                 messageType = MediaKeyMessageType::LicenseRequest;
202             } else {
203                 // 10.9.5. Otherwise:
204                 // 10.9.5.1. Let message be the request that needs to be processed before a license request request for the requested license
205                 //           type can be generated based on the sanitized init data.
206                 // 10.9.5.2. Let message type reflect the type of message, either "license-request" or "individualization-request".
207                 messageType = MediaKeyMessageType::IndividualizationRequest;
208             }
209
210             // 10.10. Queue a task to run the following steps:
211             m_taskQueue.enqueueTask([this, promise = WTFMove(promise), message = WTFMove(message), messageType, sessionId, succeeded] () mutable {
212                 // 10.10.1. If any of the preceding steps failed, reject promise with a new DOMException whose name is the appropriate error name.
213                 if (succeeded == CDMInstance::SuccessValue::Failed) {
214                     promise->reject(NOT_SUPPORTED_ERR);
215                     return;
216                 }
217                 // 10.10.2. Set the sessionId attribute to session id.
218                 m_sessionId = sessionId;
219
220                 // 10.9.3. Let this object's callable value be true.
221                 m_callable = true;
222
223                 // 10.9.3. Run the Queue a "message" Event algorithm on the session, providing message type and message.
224                 enqueueMessage(messageType, message);
225
226                 // 10.9.3. Resolve promise.
227                 promise->resolve();
228             });
229         });
230     });
231
232     // 11. Return promise.
233 }
234
235 void MediaKeySession::load(const String& sessionId, Ref<DeferredPromise>&& promise)
236 {
237     // https://w3c.github.io/encrypted-media/#dom-mediakeysession-load
238     // W3C Editor's Draft 09 November 2016
239
240     // 1. If this object is closed, return a promise rejected with an InvalidStateError.
241     // 2. If this object's uninitialized value is false, return a promise rejected with an InvalidStateError.
242     if (m_closed || !m_uninitialized) {
243         promise->reject(INVALID_STATE_ERR);
244         return;
245     }
246
247     // 3. Let this object's uninitialized value be false.
248     m_uninitialized = false;
249
250     // 4. If sessionId is the empty string, return a promise rejected with a newly created TypeError.
251     // 5. If the result of running the Is persistent session type? algorithm on this object's session type is false, return a promise rejected with a newly created TypeError.
252     if (sessionId.isEmpty() || m_sessionType == MediaKeySessionType::Temporary) {
253         promise->reject(TypeError);
254         return;
255     }
256
257     // 6. Let origin be the origin of this object's Document.
258     // This is retrieved in the following task.
259
260     // 7. Let promise be a new promise.
261     // 8. Run the following steps in parallel:
262     m_taskQueue.enqueueTask([this, sessionId, promise = WTFMove(promise)] () mutable {
263         // 8.1. Let sanitized session ID be a validated and/or sanitized version of sessionId.
264         // 8.2. If the preceding step failed, or if sanitized session ID is empty, reject promise with a newly created TypeError.
265         std::optional<String> sanitizedSessionId = m_implementation->sanitizeSessionId(sessionId);
266         if (!sanitizedSessionId || sanitizedSessionId->isEmpty()) {
267             promise->reject(TypeError);
268             return;
269         }
270
271         // 8.3. If there is a MediaKeySession object that is not closed in this object's Document whose sessionId attribute is sanitized session ID, reject promise with a QuotaExceededError.
272         // FIXME: This needs a global MediaKeySession tracker.
273
274         String origin;
275         if (auto* document = downcast<Document>(scriptExecutionContext()))
276             origin = document->securityOrigin().toString();
277
278         // 8.4. Let expiration time be NaN.
279         // 8.5. Let message be null.
280         // 8.6. Let message type be null.
281         // 8.7. Let cdm be the CDM instance represented by this object's cdm instance value.
282         // 8.8. Use the cdm to execute the following steps:
283         m_instance->loadSession(m_sessionType, *sanitizedSessionId, origin, [this, weakThis = m_weakPtrFactory.createWeakPtr(), promise = WTFMove(promise), sanitizedSessionId = *sanitizedSessionId] (std::optional<CDMInstance::KeyStatusVector>&& knownKeys, std::optional<double>&& expiration, std::optional<CDMInstance::Message>&& message, CDMInstance::SuccessValue succeeded, CDMInstance::SessionLoadFailure failure) mutable {
284             // 8.8.1. If there is no data stored for the sanitized session ID in the origin, resolve promise with false and abort these steps.
285             // 8.8.2. If the stored session's session type is not the same as the current MediaKeySession session type, reject promise with a newly created TypeError.
286             // 8.8.3. Let session data be the data stored for the sanitized session ID in the origin. This must not include data from other origin(s) or that is not associated with an origin.
287             // 8.8.4. If there is a MediaKeySession object that is not closed in any Document and that represents the session data, reject promise with a QuotaExceededError.
288             // 8.8.5. Load the session data.
289             // 8.8.6. If the session data indicates an expiration time for the session, let expiration time be the expiration time in milliseconds since 01 January 1970 UTC.
290             // 8.8.7. If the CDM needs to send a message:
291             //   8.8.7.1. Let message be a message generated by the CDM based on the session data.
292             //   8.8.7.2. Let message type be the appropriate MediaKeyMessageType for the message.
293             // NOTE: Steps 8.8.1. through 8.8.7. should be implemented in CDMInstance.
294
295             if (succeeded == CDMInstance::SuccessValue::Failed) {
296                 switch (failure) {
297                 case CDMInstance::SessionLoadFailure::NoSessionData:
298                     promise->resolve<IDLBoolean>(false);
299                     return;
300                 case CDMInstance::SessionLoadFailure::MismatchedSessionType:
301                     promise->reject(TypeError);
302                     return;
303                 case CDMInstance::SessionLoadFailure::QuotaExceeded:
304                     promise->reject(QUOTA_EXCEEDED_ERR);
305                     return;
306                 case CDMInstance::SessionLoadFailure::None:
307                 case CDMInstance::SessionLoadFailure::Other:
308                     // In any other case, the session load failure will cause a rejection in the following task.
309                     break;
310                 }
311             }
312
313             // 8.9. Queue a task to run the following steps:
314             m_taskQueue.enqueueTask([this, knownKeys = WTFMove(knownKeys), expiration = WTFMove(expiration), message = WTFMove(message), sanitizedSessionId, succeeded, promise = WTFMove(promise)] () mutable {
315                 // 8.9.1. If any of the preceding steps failed, reject promise with a the appropriate error name.
316                 if (succeeded == CDMInstance::SuccessValue::Failed) {
317                     promise->reject(NOT_SUPPORTED_ERR);
318                     return;
319                 }
320
321                 // 8.9.2. Set the sessionId attribute to sanitized session ID.
322                 // 8.9.3. Let this object's callable value be true.
323                 m_sessionId = sanitizedSessionId;
324                 m_callable = true;
325
326                 // 8.9.4. If the loaded session contains information about any keys (there are known keys), run the Update Key Statuses algorithm on the session, providing each key's key ID along with the appropriate MediaKeyStatus.
327                 if (knownKeys)
328                     updateKeyStatuses(WTFMove(*knownKeys));
329
330                 // 8.9.5. Run the Update Expiration algorithm on the session, providing expiration time.
331                 // This must be run, and NaN is the default value if the CDM instance doesn't provide one.
332                 updateExpiration(expiration.value_or(std::numeric_limits<double>::quiet_NaN()));
333
334                 // 8.9.6. If message is not null, run the Queue a "message" Event algorithm on the session, providing message type and message.
335                 if (message)
336                     enqueueMessage(message->first, WTFMove(message->second));
337
338                 // 8.9.7. Resolve promise with true.
339                 promise->resolve<IDLBoolean>(true);
340             });
341         });
342     });
343
344     // 9. Return promise.
345 }
346
347 void MediaKeySession::update(const BufferSource& response, Ref<DeferredPromise>&& promise)
348 {
349     // https://w3c.github.io/encrypted-media/#dom-mediakeysession-update
350     // W3C Editor's Draft 09 November 2016
351
352     // When this method is invoked, the user agent must run the following steps:
353     // 1. If this object is closed, return a promise rejected with an InvalidStateError.
354     // 2. If this object's callable value is false, return a promise rejected with an InvalidStateError.
355     if (m_closed || !m_callable) {
356         promise->reject(INVALID_STATE_ERR);
357         return;
358     }
359
360     // 3. If response is an empty array, return a promise rejected with a newly created TypeError.
361     if (!response.length()) {
362         promise->reject(TypeError);
363         return;
364     }
365
366     // 4. Let response copy be a copy of the contents of the response parameter.
367     // 5. Let promise be a new promise.
368     // 6. Run the following steps in parallel:
369     m_taskQueue.enqueueTask([this, response = SharedBuffer::create(response.data(), response.length()), promise = WTFMove(promise)] () mutable {
370         // 6.1. Let sanitized response be a validated and/or sanitized version of response copy.
371         RefPtr<SharedBuffer> sanitizedResponse = m_implementation->sanitizeResponse(response);
372
373         // 6.2. If the preceding step failed, or if sanitized response is empty, reject promise with a newly created TypeError.
374         if (!sanitizedResponse || sanitizedResponse->isEmpty()) {
375             promise->reject(TypeError);
376             return;
377         }
378
379         // 6.3. Let message be null.
380         // 6.4. Let message type be null.
381         // 6.5. Let session closed be false.
382         // 6.6. Let cdm be the CDM instance represented by this object's cdm instance value.
383         // 6.7. Use the cdm to execute the following steps:
384         m_instance->updateLicense(m_sessionId, m_sessionType, *sanitizedResponse, [this, weakThis = m_weakPtrFactory.createWeakPtr(), promise = WTFMove(promise)] (bool sessionWasClosed, std::optional<CDMInstance::KeyStatusVector>&& changedKeys, std::optional<double>&& changedExpiration, std::optional<CDMInstance::Message>&& message, CDMInstance::SuccessValue succeeded) mutable {
385             if (!weakThis)
386                 return;
387
388             // 6.7.1. If the format of sanitized response is invalid in any way, reject promise with a newly created TypeError.
389             // 6.7.2. Process sanitized response, following the stipulation for the first matching condition from the following list:
390             //   ↳ If sanitized response contains a license or key(s)
391             //     Process sanitized response, following the stipulation for the first matching condition from the following list:
392             //     ↳ If sessionType is "temporary" and sanitized response does not specify that session data, including any license, key(s), or similar session data it contains, should be stored
393             //       Process sanitized response, not storing any session data.
394             //     ↳ If sessionType is "persistent-license" and sanitized response contains a persistable license
395             //       Process sanitized response, storing the license/key(s) and related session data contained in sanitized response. Such data must be stored such that only the origin of this object's Document can access it.
396             //     ↳ If sessionType is "persistent-usage-record" and sanitized response contains a non-persistable license
397             //       Run the following steps:
398             //         6.7.2.3.1. Process sanitized response, not storing any session data.
399             //         6.7.2.3.2. If processing sanitized response results in the addition of keys to the set of known keys, add the key IDs of these keys to this object's record of key usage.
400             //     ↳ Otherwise
401             //       Reject promise with a newly created TypeError.
402             //   ↳ If sanitized response contains a record of license destruction acknowledgement and sessionType is "persistent-license"
403             //     Run the following steps:
404             //       6.7.2.1. Close the key session and clear all stored session data associated with this object, including the sessionId and record of license destruction.
405             //       6.7.2.2. Set session closed to true.
406             //   ↳ Otherwise
407             //     Process sanitized response, not storing any session data.
408             // NOTE: Steps 6.7.1. and 6.7.2. should be implemented in CDMInstance.
409
410             if (succeeded == CDMInstance::SuccessValue::Failed) {
411                 promise->reject(TypeError);
412                 return;
413             }
414
415             // 6.7.3. If a message needs to be sent to the server, execute the following steps:
416             //   6.7.3.1. Let message be that message.
417             //   6.7.3.2. Let message type be the appropriate MediaKeyMessageType for the message.
418             // 6.8. Queue a task to run the following steps:
419             m_taskQueue.enqueueTask([this, sessionWasClosed, changedKeys = WTFMove(changedKeys), changedExpiration = WTFMove(changedExpiration), message = WTFMove(message), promise = WTFMove(promise)] () mutable {
420                 // 6.8.1.
421                 if (sessionWasClosed) {
422                     // ↳ If session closed is true:
423                     //   Run the Session Closed algorithm on this object.
424                     sessionClosed();
425                 } else {
426                     // ↳ Otherwise:
427                     //   Run the following steps:
428                     //     6.8.1.1. If the set of keys known to the CDM for this object changed or the status of any key(s) changed, run the Update Key Statuses
429                     //              algorithm on the session, providing each known key's key ID along with the appropriate MediaKeyStatus. Should additional
430                     //              processing be necessary to determine with certainty the status of a key, use "status-pending". Once the additional processing
431                     //              for one or more keys has completed, run the Update Key Statuses algorithm again with the actual status(es).
432                     if (changedKeys)
433                         updateKeyStatuses(WTFMove(*changedKeys));
434
435                     //     6.8.1.2. If the expiration time for the session changed, run the Update Expiration algorithm on the session, providing the new expiration time.
436                     if (changedExpiration)
437                         updateExpiration(*changedExpiration);
438
439                     //     6.8.1.3. If any of the preceding steps failed, reject promise with a new DOMException whose name is the appropriate error name.
440                     // FIXME: At this point the implementations of preceding steps can't fail.
441
442                     //     6.8.1.4. If message is not null, run the Queue a "message" Event algorithm on the session, providing message type and message.
443                     if (message) {
444                         MediaKeyMessageType messageType;
445                         switch (message->first) {
446                         case CDMInstance::MessageType::LicenseRequest:
447                             messageType = MediaKeyMessageType::LicenseRequest;
448                             break;
449                         case CDMInstance::MessageType::LicenseRenewal:
450                             messageType = MediaKeyMessageType::LicenseRenewal;
451                             break;
452                         case CDMInstance::MessageType::LicenseRelease:
453                             messageType = MediaKeyMessageType::LicenseRelease;
454                             break;
455                         case CDMInstance::MessageType::IndividualizationRequest:
456                             messageType = MediaKeyMessageType::IndividualizationRequest;
457                             break;
458                         }
459
460                         enqueueMessage(messageType, WTFMove(message->second));
461                     }
462                 }
463
464                 // 6.8.2. Resolve promise.
465                 promise->resolve();
466             });
467         });
468     });
469
470     // 7. Return promise.
471 }
472
473 void MediaKeySession::close(Ref<DeferredPromise>&& promise)
474 {
475     // https://w3c.github.io/encrypted-media/#dom-mediakeysession-close
476     // W3C Editor's Draft 09 November 2016
477
478     // 1. Let session be the associated MediaKeySession object.
479     // 2. If session is closed, return a resolved promise.
480     if (m_closed) {
481         promise->resolve();
482         return;
483     }
484
485     // 3. If session's callable value is false, return a promise rejected with an InvalidStateError.
486     if (!m_callable) {
487         promise->reject(INVALID_STATE_ERR);
488         return;
489     }
490
491     // 4. Let promise be a new promise.
492     // 5. Run the following steps in parallel:
493     m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
494         // 5.1. Let cdm be the CDM instance represented by session's cdm instance value.
495         // 5.2. Use cdm to close the key session associated with session.
496         m_instance->closeSession(m_sessionId, [this, weakThis = m_weakPtrFactory.createWeakPtr(), promise = WTFMove(promise)] () mutable {
497             if (!weakThis)
498                 return;
499
500             // 5.3. Queue a task to run the following steps:
501             m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
502                 // 5.3.1. Run the Session Closed algorithm on the session.
503                 sessionClosed();
504
505                 // 5.3.2. Resolve promise.
506                 promise->resolve();
507             });
508         });
509     });
510
511     // 6. Return promise.
512 }
513
514 void MediaKeySession::remove(Ref<DeferredPromise>&& promise)
515 {
516     // https://w3c.github.io/encrypted-media/#dom-mediakeysession-remove
517     // W3C Editor's Draft 09 November 2016
518
519     // 1. If this object is closed, return a promise rejected with an InvalidStateError.
520     // 2. If this object's callable value is false, return a promise rejected with an InvalidStateError.
521     if (m_closed || !m_callable) {
522         promise->reject(INVALID_STATE_ERR);
523         return;
524     }
525
526     // 3. Let promise be a new promise.
527     // 4. Run the following steps in parallel:
528     m_taskQueue.enqueueTask([this, promise = WTFMove(promise)] () mutable {
529         // 4.1. Let cdm be the CDM instance represented by this object's cdm instance value.
530         // 4.2. Let message be null.
531         // 4.3. Let message type be null.
532
533         // 4.4. Use the cdm to execute the following steps:
534         m_instance->removeSessionData(m_sessionId, m_sessionType, [this, weakThis = m_weakPtrFactory.createWeakPtr(), promise = WTFMove(promise)] (CDMInstance::KeyStatusVector&& keys, std::optional<Ref<SharedBuffer>>&& message, CDMInstance::SuccessValue succeeded) mutable {
535             if (!weakThis)
536                 return;
537
538             // 4.4.1. If any license(s) and/or key(s) are associated with the session:
539             //   4.4.1.1. Destroy the license(s) and/or key(s) associated with the session.
540             //   4.4.1.2. Follow the steps for the value of this object's session type from the following list:
541             //     ↳ "temporary"
542             //       4.4.1.2.1.1 Continue with the following steps.
543             //     ↳ "persistent-license"
544             //       4.4.1.2.2.1. Let record of license destruction be a record of license destruction for the license represented by this object.
545             //       4.4.1.2.2.2. Store the record of license destruction.
546             //       4.4.1.2.2.3. Let message be a message containing or reflecting the record of license destruction.
547             //     ↳ "persistent-usage-record"
548             //       4.4.1.2.3.1. Store this object's record of key usage.
549             //       4.4.1.2.3.2. Let message be a message containing or reflecting this object's record of key usage.
550             // NOTE: Step 4.4.1. should be implemented in CDMInstance.
551
552             // 4.5. Queue a task to run the following steps:
553             m_taskQueue.enqueueTask([this, keys = WTFMove(keys), message = WTFMove(message), succeeded, promise = WTFMove(promise)] () mutable {
554                 // 4.5.1. Run the Update Key Statuses algorithm on the session, providing all key ID(s) in the session along with the "released" MediaKeyStatus value for each.
555                 updateKeyStatuses(WTFMove(keys));
556
557                 // 4.5.2. Run the Update Expiration algorithm on the session, providing NaN.
558                 updateExpiration(std::numeric_limits<double>::quiet_NaN());
559
560                 // 4.5.3. If any of the preceding steps failed, reject promise with a new DOMException whose name is the appropriate error name.
561                 if (succeeded == CDMInstance::SuccessValue::Failed) {
562                     promise->reject(NOT_SUPPORTED_ERR);
563                     return;
564                 }
565
566                 // 4.5.4. Let message type be "license-release".
567                 // 4.5.5. If message is not null, run the Queue a "message" Event algorithm on the session, providing message type and message.
568                 if (message)
569                     enqueueMessage(MediaKeyMessageType::LicenseRelease, *message);
570
571                 // 4.5.6. Resolve promise.
572                 promise->resolve();
573             });
574         });
575     });
576
577     // 5. Return promise.
578 }
579
580 void MediaKeySession::registerClosedPromise(ClosedPromise&& promise)
581 {
582     ASSERT(!m_closedPromise);
583     if (m_closed) {
584         promise.resolve();
585         return;
586     }
587     m_closedPromise = WTFMove(promise);
588 }
589
590 void MediaKeySession::enqueueMessage(MediaKeyMessageType messageType, const SharedBuffer& message)
591 {
592     // 6.4.1 Queue a "message" Event
593     // https://w3c.github.io/encrypted-media/#queue-message
594     // W3C Editor's Draft 09 November 2016
595
596     // The following steps are run:
597     // 1. Let the session be the specified MediaKeySession object.
598     // 2. Queue a task to create an event named message that does not bubble and is not cancellable using the MediaKeyMessageEvent
599     //    interface with its type attribute set to message and its isTrusted attribute initialized to true, and dispatch it at the
600     //    session.
601     auto messageEvent = MediaKeyMessageEvent::create(eventNames().messageEvent, {messageType, message.tryCreateArrayBuffer()}, Event::IsTrusted::Yes);
602     m_eventQueue.enqueueEvent(WTFMove(messageEvent));
603 }
604
605 void MediaKeySession::updateKeyStatuses(CDMInstance::KeyStatusVector&& inputStatuses)
606 {
607     // https://w3c.github.io/encrypted-media/#update-key-statuses
608     // W3C Editor's Draft 09 November 2016
609
610     // 1. Let the session be the associated MediaKeySession object.
611     // 2. Let the input statuses be the sequence of pairs key ID and associated MediaKeyStatus pairs.
612     // 3. Let the statuses be session's keyStatuses attribute.
613     // 4. Run the following steps to replace the contents of statuses:
614     //   4.1. Empty statuses.
615     //   4.2. For each pair in input statuses.
616     //     4.2.1. Let pair be the pair.
617     //     4.2.2. Insert an entry for pair's key ID into statuses with the value of pair's MediaKeyStatus value.
618
619     static auto toMediaKeyStatus = [] (CDMInstance::KeyStatus status) -> MediaKeyStatus {
620         switch (status) {
621         case CDMInstance::KeyStatus::Usable:
622             return MediaKeyStatus::Usable;
623         case CDMInstance::KeyStatus::Expired:
624             return MediaKeyStatus::Expired;
625         case CDMInstance::KeyStatus::Released:
626             return MediaKeyStatus::Released;
627         case CDMInstance::KeyStatus::OutputRestricted:
628             return MediaKeyStatus::OutputRestricted;
629         case CDMInstance::KeyStatus::OutputDownscaled:
630             return MediaKeyStatus::OutputDownscaled;
631         case CDMInstance::KeyStatus::StatusPending:
632             return MediaKeyStatus::StatusPending;
633         case CDMInstance::KeyStatus::InternalError:
634             return MediaKeyStatus::InternalError;
635         };
636
637         ASSERT_NOT_REACHED();
638         return MediaKeyStatus::InternalError;
639     };
640
641     m_statuses.clear();
642     m_statuses.reserveCapacity(inputStatuses.size());
643     for (auto& status : inputStatuses)
644         m_statuses.uncheckedAppend({ WTFMove(status.first), toMediaKeyStatus(status.second) });
645
646     // 5. Queue a task to fire a simple event named keystatuseschange at the session.
647     m_eventQueue.enqueueEvent(Event::create(eventNames().keystatuseschangeEvent, false, false));
648
649     // 6. Queue a task to run the Attempt to Resume Playback If Necessary algorithm on each of the media element(s) whose mediaKeys attribute is the MediaKeys object that created the session.
650     // FIXME: Implement.
651 }
652
653 void MediaKeySession::updateExpiration(double)
654 {
655     notImplemented();
656 }
657
658 void MediaKeySession::sessionClosed()
659 {
660     // https://w3c.github.io/encrypted-media/#session-closed
661     // W3C Editor's Draft 09 November 2016
662
663     // 1. Let session be the associated MediaKeySession object.
664     // 2. If session's session type is "persistent-usage-record", execute the following steps in parallel:
665     if (m_sessionType == MediaKeySessionType::PersistentUsageRecord) {
666         // 2.1. Let cdm be the CDM instance represented by session's cdm instance value.
667         // 2.2. Use cdm to store session's record of key usage, if it exists.
668         m_instance->storeRecordOfKeyUsage(m_sessionId);
669     }
670
671     // 3. Run the Update Key Statuses algorithm on the session, providing an empty sequence.
672     updateKeyStatuses({ });
673
674     // 4. Run the Update Expiration algorithm on the session, providing NaN.
675     updateExpiration(std::numeric_limits<double>::quiet_NaN());
676
677     // Let's consider the session closed before any promise on the 'closed' attribute is resolved.
678     m_closed = true;
679
680     // 5. Let promise be the closed attribute of the session.
681     // 6. Resolve promise.
682     if (m_closedPromise)
683         m_closedPromise->resolve();
684 }
685
686 bool MediaKeySession::hasPendingActivity() const
687 {
688     notImplemented();
689     return false;
690 }
691
692 const char* MediaKeySession::activeDOMObjectName() const
693 {
694     notImplemented();
695     return "MediaKeySession";
696 }
697
698 bool MediaKeySession::canSuspendForDocumentSuspension() const
699 {
700     notImplemented();
701     return false;
702 }
703
704 void MediaKeySession::stop()
705 {
706     notImplemented();
707 }
708
709 } // namespace WebCore
710
711 #endif