dom/media/gmp/ChromiumCDMCallbackProxy.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "ChromiumCDMCallbackProxy.h"
   7
   8 #include <type_traits>
   9
  10 #include "ChromiumCDMProxy.h"
  11 #include "content_decryption_module.h"
  12
  13 namespace mozilla {
  14
  15 template <class Func, class... Args>
  16 void ChromiumCDMCallbackProxy::DispatchToMainThread(const char* const aLabel,
  17                                                     Func aFunc,
  18                                                     Args&&... aArgs) {
  19   mMainThread->Dispatch(
  20       // Use decay to ensure all the types are passed by value not by reference.
  21       NewRunnableMethod<std::decay_t<Args>...>(aLabel, mProxy, aFunc,
  22                                                std::forward<Args>(aArgs)...),
  23       NS_DISPATCH_NORMAL);
  24 }
  25
  26 void ChromiumCDMCallbackProxy::SetSessionId(uint32_t aPromiseId,
  27                                             const nsCString& aSessionId) {
  28   DispatchToMainThread("ChromiumCDMProxy::OnSetSessionId",
  29                        &ChromiumCDMProxy::OnSetSessionId, aPromiseId,
  30                        NS_ConvertUTF8toUTF16(aSessionId));
  31 }
  32
  33 void ChromiumCDMCallbackProxy::ResolveLoadSessionPromise(uint32_t aPromiseId,
  34                                                          bool aSuccessful) {
  35   DispatchToMainThread("ChromiumCDMProxy::OnResolveLoadSessionPromise",
  36                        &ChromiumCDMProxy::OnResolveLoadSessionPromise,
  37                        aPromiseId, aSuccessful);
  38 }
  39
  40 void ChromiumCDMCallbackProxy::ResolvePromise(uint32_t aPromiseId) {
  41   DispatchToMainThread("ChromiumCDMProxy::ResolvePromise",
  42                        &ChromiumCDMProxy::ResolvePromise, aPromiseId);
  43 }
  44
  45 void ChromiumCDMCallbackProxy::RejectPromise(uint32_t aPromiseId,
  46                                              ErrorResult&& aException,
  47                                              const nsCString& aErrorMessage) {
  48   // Use CopyableErrorResult to store our exception in the runnable,
  49   // because ErrorResult is not OK to move across threads.
  50   DispatchToMainThread<decltype(&ChromiumCDMProxy::RejectPromiseOnMainThread),
  51                        int32_t, StoreCopyPassByRRef<CopyableErrorResult>,
  52                        const nsCString&>(
  53       "ChromiumCDMProxy::RejectPromise",
  54       &ChromiumCDMProxy::RejectPromiseOnMainThread, aPromiseId,
  55       std::move(aException), aErrorMessage);
  56 }
  57
  58 static dom::MediaKeyMessageType ToDOMMessageType(uint32_t aMessageType) {
  59   switch (static_cast<cdm::MessageType>(aMessageType)) {
  60     case cdm::kLicenseRequest:
  61       return dom::MediaKeyMessageType::License_request;
  62     case cdm::kLicenseRenewal:
  63       return dom::MediaKeyMessageType::License_renewal;
  64     case cdm::kLicenseRelease:
  65       return dom::MediaKeyMessageType::License_release;
  66     case cdm::kIndividualizationRequest:
  67       return dom::MediaKeyMessageType::Individualization_request;
  68   }
  69   MOZ_ASSERT_UNREACHABLE("Invalid cdm::MessageType enum value.");
  70   return dom::MediaKeyMessageType::License_request;
  71 }
  72
  73 void ChromiumCDMCallbackProxy::SessionMessage(const nsACString& aSessionId,
  74                                               uint32_t aMessageType,
  75                                               nsTArray<uint8_t>&& aMessage) {
  76   DispatchToMainThread("ChromiumCDMProxy::OnSessionMessage",
  77                        &ChromiumCDMProxy::OnSessionMessage,
  78                        NS_ConvertUTF8toUTF16(aSessionId),
  79                        ToDOMMessageType(aMessageType), std::move(aMessage));
  80 }
  81
  82 static dom::MediaKeyStatus ToDOMMediaKeyStatus(uint32_t aStatus) {
  83   switch (static_cast<cdm::KeyStatus>(aStatus)) {
  84     case cdm::kUsable:
  85       return dom::MediaKeyStatus::Usable;
  86     case cdm::kInternalError:
  87       return dom::MediaKeyStatus::Internal_error;
  88     case cdm::kExpired:
  89       return dom::MediaKeyStatus::Expired;
  90     case cdm::kOutputRestricted:
  91       return dom::MediaKeyStatus::Output_restricted;
  92     case cdm::kOutputDownscaled:
  93       return dom::MediaKeyStatus::Output_downscaled;
  94     case cdm::kStatusPending:
  95       return dom::MediaKeyStatus::Status_pending;
  96     case cdm::kReleased:
  97       return dom::MediaKeyStatus::Released;
  98   }
  99   MOZ_ASSERT_UNREACHABLE("Invalid cdm::KeyStatus enum value.");
 100   return dom::MediaKeyStatus::Internal_error;
 101 }
 102
 103 void ChromiumCDMCallbackProxy::ResolvePromiseWithKeyStatus(
 104     uint32_t aPromiseId, uint32_t aKeyStatus) {
 105   DispatchToMainThread("ChromiumCDMProxy::OnResolvePromiseWithKeyStatus",
 106                        &ChromiumCDMProxy::OnResolvePromiseWithKeyStatus,
 107                        aPromiseId, ToDOMMediaKeyStatus(aKeyStatus));
 108 }
 109
 110 void ChromiumCDMCallbackProxy::SessionKeysChange(
 111     const nsCString& aSessionId,
 112     nsTArray<mozilla::gmp::CDMKeyInformation>&& aKeysInfo) {
 113   bool keyStatusesChange = false;
 114   {
 115     auto caps = mProxy->Capabilites().Lock();
 116     for (const auto& keyInfo : aKeysInfo) {
 117       keyStatusesChange |= caps->SetKeyStatus(
 118           keyInfo.mKeyId(), NS_ConvertUTF8toUTF16(aSessionId),
 119           dom::Optional<dom::MediaKeyStatus>(
 120               ToDOMMediaKeyStatus(keyInfo.mStatus())));
 121     }
 122   }
 123   if (keyStatusesChange) {
 124     DispatchToMainThread("ChromiumCDMProxy::OnKeyStatusesChange",
 125                          &ChromiumCDMProxy::OnKeyStatusesChange,
 126                          NS_ConvertUTF8toUTF16(aSessionId));
 127   }
 128 }
 129
 130 void ChromiumCDMCallbackProxy::ExpirationChange(const nsCString& aSessionId,
 131                                                 double aSecondsSinceEpoch) {
 132   DispatchToMainThread("ChromiumCDMProxy::OnExpirationChange",
 133                        &ChromiumCDMProxy::OnExpirationChange,
 134                        NS_ConvertUTF8toUTF16(aSessionId),
 135                        UnixTime(aSecondsSinceEpoch * 1000));
 136 }
 137
 138 void ChromiumCDMCallbackProxy::SessionClosed(const nsCString& aSessionId) {
 139   DispatchToMainThread("ChromiumCDMProxy::OnSessionClosed",
 140                        &ChromiumCDMProxy::OnSessionClosed,
 141                        NS_ConvertUTF8toUTF16(aSessionId));
 142 }
 143
 144 void ChromiumCDMCallbackProxy::QueryOutputProtectionStatus() {
 145   DispatchToMainThread("ChromiumCDMProxy::QueryOutputProtectionStatus",
 146                        &ChromiumCDMProxy::QueryOutputProtectionStatus);
 147 }
 148
 149 void ChromiumCDMCallbackProxy::Terminated() {
 150   DispatchToMainThread("ChromiumCDMProxy::Terminated",
 151                        &ChromiumCDMProxy::Terminated);
 152 }
 153
 154 void ChromiumCDMCallbackProxy::Shutdown() {
 155   DispatchToMainThread("ChromiumCDMProxy::Shutdown",
 156                        &ChromiumCDMProxy::Shutdown);
 157 }
 158
 159 }  // namespace mozilla