summaryrefslogtreecommitdiffstats
path: root/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/media/gmp/ChromiumCDMCallbackProxy.cpp159
1 files changed, 159 insertions, 0 deletions
diff --git a/dom/media/gmp/ChromiumCDMCallbackProxy.cpp b/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
new file mode 100644
index 0000000000..481534c0e4
--- /dev/null
+++ b/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ChromiumCDMCallbackProxy.h"
+
+#include <type_traits>
+
+#include "ChromiumCDMProxy.h"
+#include "content_decryption_module.h"
+
+namespace mozilla {
+
+template <class Func, class... Args>
+void ChromiumCDMCallbackProxy::DispatchToMainThread(const char* const aLabel,
+ Func aFunc,
+ Args&&... aArgs) {
+ mMainThread->Dispatch(
+ // Use decay to ensure all the types are passed by value not by reference.
+ NewRunnableMethod<std::decay_t<Args>...>(aLabel, mProxy, aFunc,
+ std::forward<Args>(aArgs)...),
+ NS_DISPATCH_NORMAL);
+}
+
+void ChromiumCDMCallbackProxy::SetSessionId(uint32_t aPromiseId,
+ const nsCString& aSessionId) {
+ DispatchToMainThread("ChromiumCDMProxy::OnSetSessionId",
+ &ChromiumCDMProxy::OnSetSessionId, aPromiseId,
+ NS_ConvertUTF8toUTF16(aSessionId));
+}
+
+void ChromiumCDMCallbackProxy::ResolveLoadSessionPromise(uint32_t aPromiseId,
+ bool aSuccessful) {
+ DispatchToMainThread("ChromiumCDMProxy::OnResolveLoadSessionPromise",
+ &ChromiumCDMProxy::OnResolveLoadSessionPromise,
+ aPromiseId, aSuccessful);
+}
+
+void ChromiumCDMCallbackProxy::ResolvePromise(uint32_t aPromiseId) {
+ DispatchToMainThread("ChromiumCDMProxy::ResolvePromise",
+ &ChromiumCDMProxy::ResolvePromise, aPromiseId);
+}
+
+void ChromiumCDMCallbackProxy::RejectPromise(uint32_t aPromiseId,
+ ErrorResult&& aException,
+ const nsCString& aErrorMessage) {
+ // Use CopyableErrorResult to store our exception in the runnable,
+ // because ErrorResult is not OK to move across threads.
+ DispatchToMainThread<decltype(&ChromiumCDMProxy::RejectPromiseOnMainThread),
+ int32_t, StoreCopyPassByRRef<CopyableErrorResult>,
+ const nsCString&>(
+ "ChromiumCDMProxy::RejectPromise",
+ &ChromiumCDMProxy::RejectPromiseOnMainThread, aPromiseId,
+ std::move(aException), aErrorMessage);
+}
+
+static dom::MediaKeyMessageType ToDOMMessageType(uint32_t aMessageType) {
+ switch (static_cast<cdm::MessageType>(aMessageType)) {
+ case cdm::kLicenseRequest:
+ return dom::MediaKeyMessageType::License_request;
+ case cdm::kLicenseRenewal:
+ return dom::MediaKeyMessageType::License_renewal;
+ case cdm::kLicenseRelease:
+ return dom::MediaKeyMessageType::License_release;
+ case cdm::kIndividualizationRequest:
+ return dom::MediaKeyMessageType::Individualization_request;
+ }
+ MOZ_ASSERT_UNREACHABLE("Invalid cdm::MessageType enum value.");
+ return dom::MediaKeyMessageType::License_request;
+}
+
+void ChromiumCDMCallbackProxy::SessionMessage(const nsACString& aSessionId,
+ uint32_t aMessageType,
+ nsTArray<uint8_t>&& aMessage) {
+ DispatchToMainThread("ChromiumCDMProxy::OnSessionMessage",
+ &ChromiumCDMProxy::OnSessionMessage,
+ NS_ConvertUTF8toUTF16(aSessionId),
+ ToDOMMessageType(aMessageType), std::move(aMessage));
+}
+
+static dom::MediaKeyStatus ToDOMMediaKeyStatus(uint32_t aStatus) {
+ switch (static_cast<cdm::KeyStatus>(aStatus)) {
+ case cdm::kUsable:
+ return dom::MediaKeyStatus::Usable;
+ case cdm::kInternalError:
+ return dom::MediaKeyStatus::Internal_error;
+ case cdm::kExpired:
+ return dom::MediaKeyStatus::Expired;
+ case cdm::kOutputRestricted:
+ return dom::MediaKeyStatus::Output_restricted;
+ case cdm::kOutputDownscaled:
+ return dom::MediaKeyStatus::Output_downscaled;
+ case cdm::kStatusPending:
+ return dom::MediaKeyStatus::Status_pending;
+ case cdm::kReleased:
+ return dom::MediaKeyStatus::Released;
+ }
+ MOZ_ASSERT_UNREACHABLE("Invalid cdm::KeyStatus enum value.");
+ return dom::MediaKeyStatus::Internal_error;
+}
+
+void ChromiumCDMCallbackProxy::ResolvePromiseWithKeyStatus(
+ uint32_t aPromiseId, uint32_t aKeyStatus) {
+ DispatchToMainThread("ChromiumCDMProxy::OnResolvePromiseWithKeyStatus",
+ &ChromiumCDMProxy::OnResolvePromiseWithKeyStatus,
+ aPromiseId, ToDOMMediaKeyStatus(aKeyStatus));
+}
+
+void ChromiumCDMCallbackProxy::SessionKeysChange(
+ const nsCString& aSessionId,
+ nsTArray<mozilla::gmp::CDMKeyInformation>&& aKeysInfo) {
+ bool keyStatusesChange = false;
+ {
+ auto caps = mProxy->Capabilites().Lock();
+ for (const auto& keyInfo : aKeysInfo) {
+ keyStatusesChange |= caps->SetKeyStatus(
+ keyInfo.mKeyId(), NS_ConvertUTF8toUTF16(aSessionId),
+ dom::Optional<dom::MediaKeyStatus>(
+ ToDOMMediaKeyStatus(keyInfo.mStatus())));
+ }
+ }
+ if (keyStatusesChange) {
+ DispatchToMainThread("ChromiumCDMProxy::OnKeyStatusesChange",
+ &ChromiumCDMProxy::OnKeyStatusesChange,
+ NS_ConvertUTF8toUTF16(aSessionId));
+ }
+}
+
+void ChromiumCDMCallbackProxy::ExpirationChange(const nsCString& aSessionId,
+ double aSecondsSinceEpoch) {
+ DispatchToMainThread("ChromiumCDMProxy::OnExpirationChange",
+ &ChromiumCDMProxy::OnExpirationChange,
+ NS_ConvertUTF8toUTF16(aSessionId),
+ UnixTime(aSecondsSinceEpoch * 1000));
+}
+
+void ChromiumCDMCallbackProxy::SessionClosed(const nsCString& aSessionId) {
+ DispatchToMainThread("ChromiumCDMProxy::OnSessionClosed",
+ &ChromiumCDMProxy::OnSessionClosed,
+ NS_ConvertUTF8toUTF16(aSessionId));
+}
+
+void ChromiumCDMCallbackProxy::QueryOutputProtectionStatus() {
+ DispatchToMainThread("ChromiumCDMProxy::QueryOutputProtectionStatus",
+ &ChromiumCDMProxy::QueryOutputProtectionStatus);
+}
+
+void ChromiumCDMCallbackProxy::Terminated() {
+ DispatchToMainThread("ChromiumCDMProxy::Terminated",
+ &ChromiumCDMProxy::Terminated);
+}
+
+void ChromiumCDMCallbackProxy::Shutdown() {
+ DispatchToMainThread("ChromiumCDMProxy::Shutdown",
+ &ChromiumCDMProxy::Shutdown);
+}
+
+} // namespace mozilla