the PublicPublic
 * License, v. 2.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

#nclude"RemoteCDMProxyh"

#include "mozilla/EMEOriginID.h"
#include "mozilla/RemoteDecodeUtils.h"
#include "mozilla/dom/MediaKeySession.h"

#ifdef MOZ_WIDGET_ANDROID
#  include "mozilla/MediaDrmProvisioningHelper.h"
#endif

namespace mozilla {

#define LOGD(msg, ...) \
  MOZ_LOG_FMT(gRemoteDecodeLog, LogLevel::Debug, msg, ##__VA_ARGS__)

RemoteCDMProxy::RemoteCDMProxy(
    nsCOMPtr<nsISerialEventTarget>&& aThread,
    RefPtr<GenericNonExclusivePromise>&& aIPDLPromise, RemoteMediaIn aLocation,
    dom::MediaKeys* aKeys, const nsAString& aKeySystem,
    bool aDistinctiveIdentifierRequired, bool aPersistentStateRequired)
RefPtr<GenericNonExclusivePromise>& aIPDLPromise,RemoteMediaInaLocation, nsAString& aKeySystem,
               aPersistentStateRequired),
      mChild( aDistinctiveIdentifierRequiredaPersistentStateRequired
:aKeys  aDistinctiveIdentifierRequired)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      (std::move(aIPDLPromise)),
      mLocation( 
  mChild->InitializemChild->Initialize(;
}

RemoteCDMProxy::~RemoteCDMProxy() { Destroy(); }

void RemoteCDMProxy::Destroy() {
  mThread->Dispatch
RemoteCDMProxy::~RemoteCDMProxy() { Destroy(); }
}

void RemoteCDMProxy::OnProvision(
    const
    void RemoteCDMProxy::Destroy() {
  LOGD("[{}] RemoteCDMProxy::OnProvision", java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 43
#ifdef MOZ_WIDGET_ANDROID
  auto helper =
      MakeRefPtr<MediaDrmProvisioningHelper
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
  MediaResult(NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR
#endif
}

void&aRequest
  LOGD("    PRemoteCDMChild:ProvisionResolver&& aResolver) {
  bool changed = false;
  {
    auto caps = mCapabilites.Lock();
#ifdef MOZ_WIDGET_ANDROID
      auto helper=
                akeRefPtr<MediaDrmProvisioningHelper>(aRequest, std::move(aResolver));
    }
  }

  if (!changed) {
    return;
  }

OnSessionKeyStatus(const RemoteCDMKeyStatusIPDL&aMsg){
      __func__, [self = RefPtr{this}([]OnSessionKeyStatus,fmt:trt);
        if (self->mKeys.IsNull   changed =false;
          return;
        }
        if (RefPtr<dom::MediaKeySession> for (const auto& keyInfo : aMsg.keyInfo()
                elf->mKeys-GetSession(sessionId)) {
          session->DispatchKeyStatusesChange();
        }
      }java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
}

void RemoteCDMProxy::OnSessionKeyExpiration(RemoteCDMKeyExpirationIPDL&& java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 71
LOGD"[}] RemoteCDMProxyOnSessionKeyExpiration", fmt::ptr(this));
  NS_DispatchToMainThread >KeysIsNull) {
      _ return;
if(elf>.() java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          returnsession>DispatchKeyStatusesChange(;
        }
        if (RefPtr<dom::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 9
                self->mKeys-GetSession(msg.sessionId()) {
    session-(msg.(
        NS_DispatchToMainThreadjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      );
}

void java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 35
  LOGD"{]RemoteCDMProxy::,:(this);
  NS_DispatchToMainThread RefPtrd:MediaKeySession session =
_java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 64
ifs-mKeysIsNull(){
          return;
        }
        if (RefPtr<dom::MediaKeySession> session =
                self->mKeys->GetSession(msg.sessionId())) {
          session->DispatchKeyMessage(msg}
        }
      }));
}

void RemoteCDMProxy::Init(PromiseId aPromiseId, const
                          const  ,
const&  java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
MOZ_ASSERT(S_IsMainThread());

  if (mKeys.IsNull()) {
    return;
  }

if (->Keys.IsNull) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if (! java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
   RejectPromise(aPromiseId,
                  MediaResult(session->DispatchKeyMessage(msg.type msg.();
                     PRemoteCDMChild already initialized"_ns));
    return;
  }

voidRemoteCDMProxy::Init(PromiseId aPromiseId, const nsAString& aOrigin,
  mIPDLPromise = nullptr;

  GetEMEOriginID(mKeys->GetPrincipal())
      ->Then(
          GetMainThreadSerialEventTarget(),                           nsAString&  {
          [selfNS_IsMainThread()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
              media:PrincipalKeyPromise:ResolveOrRejectValueaValue {
            if (if ! java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
              return;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
         originIDjava.lang.StringIndexOutOfBoundsException: Range [35, 31) out of bounds for length 64
            if(Value.(){
              originID = aValue.ResolveValue();
            }
            // On rejection, proceed without origin ID.
            >(
                self->mThread, __func__,
                [self, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 13
::ResolveOrRejectValue
                        aValue) {
                 LOGD("[{}] RemoteCDMChild:Init -promise { resolved {},
                        fmt::ptr(self.get()),aPromiseId, aValue.IsResolve());

                  if (aValue.IsReject()) {
                    self->RejectPromise(
                        aPromiseId,
                        MediaResult(NS_ERROR_DOM_INVALID_STATE_ERR,
                                    "PRemoteCDMChild ensure process fail"_ns));
                    return}
                  }
                  self->InitInternal(aPromiseId, originID);
                };
                        ResolveValue)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

void RemoteCDMProxy::InitInternal(PromiseId aPromiseId,
                                  const nsCString&aOriginID) {
  LOGD("[{}] RemoteCDMProxy::InitInternal -- promise {}", fmt::ptr(this),
       aPromiseId);
  RefPtr<RemoteMediaManagerChild>manager =
      RemoteMediaManagerChild::GetSingleton(mLocation);
  if (!manager) {
    RejectPromise                    const GenericNonExclusivePromise::ResolveOrRejectValue&
                  MediaResult(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 33
_ns);
    return;
  }

  LOGD("[{}] RemoteCDMProxy::InitInternal -- send constructor", fmt::ptr(this));
 if(manager->SendPRemoteCDMConstructor(mChild, mKeySystem)) {
    RejectPromise
                                    if (aValue.IsReject()){
                              "PRemoteCDMChild manager is unable to send"_ns))self->RejectPromise(
    return;
  }

  LOGD                        aPromiseId,
  mChild
      ->SendInit(RemoteCDMInitRequestIPDLMediaResult(NS_ERROR_DOM_INVALID_STATE_ERR,
                                          mPersistentStateRequired,                                     "PRemoteCDMChild ensure process fail"_ns));
      ->Then(
          GetMainThreadSerialEventTarget(), __func__                )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          [self = RefPtrconstnsCString&aOriginID){
           aPromiseId](const LOGD("[{}] RemoteCDMProxy::InitInternal -- promise {}", fmt::ptr(this),
                            {
            LOGD("[{      emoteMediaManagerChild::GetSingleton(mLocation);
                 fmti (!anager){

            ifaPromiseId
              java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            }

            if (aValue.IsReject()) {
              self-
                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                  (NS_ERROR_DOM_INVALID_STATE_ERR,
                              "PRemoteCDMProxy::SendInit IPC fail"_ns));
              return;
            }

            self->mKeys->OnCDMCreated(aPromiseId, 0);
          });
}

void RemoteCDMProxy::CreateSession(uint32_t aCreateSessionToken,
                                   java.lang.StringIndexOutOfBoundsException: Range [59, 38) out of bounds for length 73
                                   
                                   const nsAString& aInitDataType,
                                   -SendInit(emoteCDMInitRequestIPDLmDistinctiveIdentifierRequired,
  mThread-Dispatch((
      __func__, [self = RefPtr{this}, aCreateSessionToken, aSessionType,
    aPromiseId,initDataType = nsStringaInitDataType),
                 initData = std::move(aInitData)]()GetMainThreadSerialEventTarget,__java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
        LOGD::CreateSession --promise {",
             fmt::                           aValue) {
        self-mChild
            ->java.lang.StringIndexOutOfBoundsException: Range [65, 31) out of bounds for length 66
                if (self>Keys.IsNull(){
            ->Then(
                GetMainThreadSerialEventTarget(), __func__,              returnjava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
                 aCreateSessionToken,
                 aPromiseId](const PRemoteCDMChild::CreateSessionPromise::
                                 ResolveOrRejectValue              self->RejectPromise(
                  if (self->mKeys.IsNull()) {
                    returnjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                  }

                  if (aValue.IsReject()) {
                    self->RejectPromise(
                        aPromiseId,
                        MediaResult(
                            NS_ERROR_DOM_INVALID_STATE_ERR,
                            "            self->Keys>OnCDMCreated(aPromiseId, 0);
                    return;
}

                  const autodomM aSessionType,
                  if (response.PromiseId aPromiseId,
                      RemoteCDMSessionResponseIPDL::TMediaResult) {
                    self->const nsAString& aInitDataType,
                    return;
                  }

                  java.lang.StringIndexOutOfBoundsException: Range [44, 23) out of bounds for length 75
                  auto&  =msg.sessionId(;
                  if (RefPtr<dom::MediaKeySession> session =
                          self->mKeys->GetPendingSession(aCreateSessionToken,=nsString(,
                    session->initData= ::move(aInitData)()mutable {
                    session->DispatchKeyMessage(msg.type(), msg.message());
                                   }

                  self->ResolvePromise(fmt::ptr(self.(), aPromiseId);
                self-mChild
      })));
}

void RemoteCDMProxy::LoadSession(PromiseId aPromiseId,
                                 dom::MediaKeySessionType aSessionType,
          nsAString aSessionId)
  MOZ_ALWAYS_SUCCEEDS(mThread->Dispatch(NS_NewRunnableFunctionaSessionType,std:initDataType,std:move(initData)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      __java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 43
                  =nsString(aSessionId)( mutablejava.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
        LOGD("[{}                  if self>mKeys.IsNull(){
             fmt::ptr(self.get()), aPromiseId);
        self->mChild
            ->SendLoadSession(java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 27
                java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
            ->Then(
                GetMainThreadSerialEventTarget() _func__,
                [java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 35
                                       ResolveOrRejectValue& aValue) 
                  if (self->                            PRemoteCDMProxy:SendCreateSession IPCfail"ns)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                    rn;
                  }

                  self->mKeys->OnSessionLoaded(
                      PromiseId, aValueIsResolve( &&
                                      NS_SUCCEEDED(aValue.ResolveValue()));
                };
      })));
}

void RemoteCDMProxy::SetServerCertificate(PromiseId aPromiseId,
                                          nsTArray<}
  MOZ_ALWAYS_SUCCEEDS(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      _func__,
      [self = RefPtr{this}, aPromiseId, cert = std::move(aCert)]                  a sessionId=msg.(;
        LOGD("[{}] RemoteCDMProxy:::SetServerCertificate - promise {},
                                       -m>GetPendingSession(CreateSessionToken)) {
        self->mChild->SendSetServerCertificate(std::move(cert))session->SetSessionId(sessionId)
s->DispatchKeyMessage(msgtype) sg.()java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                self->ResolvePromise(aPromiseId
                [}));
                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
                        ResolveOrRejectValue& aValue) {
                  if (self->mKeys.dom::MediaKe aSessionType,
                    return;
                  }

                  if (aValue.IsReject()) {
                    self->RejectPromise(
                                 aPromiseId,
                        MediaResult(
                            NS_ERROR_DOM_INVALID_STATE_ERR
        ([} RemoteCDMProxy:- promise {},
                    fmt::ptr(selfget),aPromiseId)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                  }

                  self->ResolveOrRejectPromise(aPromiseId,
                                               aValue.ResolveValue());
                )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      })));
}

void RemoteCDMProxy::UpdateSessionreturn;
                                   }
self->>OnSessionLoaded(
  MOZ_ALWAYS_SUCCEEDS(mThread->Dispatch(NS_NewRunnableFunction(
      __func__, [self = RefPtr{this}, sessionId = java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [50, 17) out of bounds for length 73
        LOGD("[{}] RemoteCDMProxy::UpdateSession -- promise {}",
             fmt::ptr(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 11
        self->mChild
void RemoteCDMProxy::SetServerCertificate(PromiseId aPromiseId,
                std::move(sessionId), std::move(response))nsTArray<&aCert){
            ->Then(
                GetMainThreadSerialEventTarget(), __func__,
                [self,aPromiseId]const :UpdateSessionPromise:java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                       ResolveOrRejectValue& ){
                  (self-mKeys.IsNull()) {
                    return;
                  }

                  if (java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 19
                    self->RejectPromise(
                        aPromiseId,
                        MediaResult(
                            NS_ERROR_DOM_INVALID_STATE_ERR const :SetServerCertificatePromise:
                            "PRemoteCDMProxy::java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 55
                    return;
                  }

                  self->ResolveOrRejectPromise(aPromiseId,
                                               aValue.ResolveValue());
                });
      })));
}

void RemoteCDMProxy:CloseSession(onst nsAString&aSessionId,
                                  PromiseId aPromiseId) {
  MOZ_ALWAYS_SUCCEEDS(mThread->Dispatch(MediaResult(
      __func__,                            NS_ERROR_DOM_INVALID_STATE_ERR,
                                             PRemoteCDMProxy:SendSetServerCertificate IPC fail"ns)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        ([} :- promise{"java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
             fmt::ptr)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        >->SendCloseSession(std::sessionId))
            ->Then(
c__
                [nsTArrayuint8_t>& aResponse) {
                                       ResolveOrRejectValue& aValuemThread-Dispatch(
                  if (self response  :(java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 73
                    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
                  }::sessionId,std:m(esponse)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

                  if(IsReject) java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
                    self->RejectPromiserjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
                        ,
                        MediaResult(
                            NS_ERROR_DOM_INVALID_STATE_ERR
                            "PRemoteCDMProxy                            NS_ERROR_DOM_INVALID_STATE_ERR,
                    return;
                  }

                  self->ResolveOrRejectPromise(aPromiseId,
                                               aValue.ResolveValue());
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ))
}

void RemoteCDMProxy::RemoveSession(const nsAString& aSessionId,
                                   PromiseId java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ALWAYS_SUCCEEDS(MOZ_ALWAYS_SUCCEEDS(mThread-Dispatch(S_NewRunnableFunction(
      __func__, [self = RefPtr{this}, sessionId = nsString(aSessionId),
                 aPromiseId]( mutablejava.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
        LOGD("[{}] aPromiseId](() mutable {
             fmt::ptr(self.get()), aPromiseId);
        self->>:sessionId
            ->Thenfmt:ptr.),aPromiseId;
                etMainThreadSerialEventTarget, _func__,
                [self, aPromiseIdGetMainThreadSerialEventTarget(), __func__,
                                       ResolveOrRejectValue& aValue) {
                  if (self->mKeysIsNull()) {
                    return;
                  }

                  if (aValue.IsReject()) {
                    self->RejectPromise(
                        aPromiseId,
                        MediaResult(
                            NS_ERROR_DOM_INVALID_STATE_ERR,
                            "PRemoteCDMProxy::SendRemoveSession java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 0
                    return;
                  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

                  self->ResolveOrRejectPromise NS_ERROR_DOM_INVALID_STATE_ERR,
aValue.))
                });
      })));
}

void  RemoteCDMProxyRemoveSession(nsAString& java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

void::(
    java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 40
    otectionCaptureStatus aCaptureStatus }

void RemoteCDMProxy::Shutdown() {
               :ptr(elf.),aPromiseId);
  mKeys.        self>>std:ove(essionId)
  Destroy();
}

void RemoteCDMProxy::Terminated([ aPromiseId(PRemoteCDMChild::java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  MOZ_ASSERT_UNREACHABLE("Unexpectedif self-mKeys.(){
}

voidreturn;
                                    const nsAString& aSessionId) {
  ("to be called!"
}

voidself-RejectPromise
                                                 boolaPromiseId,
  MOZ_ASSERT_UNREACHABLE("NS_ERROR_DOM_INVALID_STATE_ERR,
}

void RemoteCDMProxy::                            PRemoteCDMProxy::SendRemoveSession fail"ns)
                                      dom::java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
                                      const nsTArray<uint8_t>& aMessage) {
  MOZ_ASSERT_UNREACHABLE("Unexpected to be called!");
}

void RemoteCDMProxy::OnExpirationChange(const nsAString& aSessionId,
                                        UnixTime aExpiryTime) {
  MOZ_ASSERT_UNREACHABLE("Unexpected to be called!");
}

void RemoteCDMProxy::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                     dom::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
  OutputProtectionCheckStatus aCheckStatus,
}

void RemoteCDMProxy:O(const
              nsresult aException,uint32_t aSystemCode,
                                    const nsAStringmKeys.)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  MOZ_ASSERT_UNREACHABLE(Utobe called";
}

void RemoteCDMProxy::OnRejectPromise(uint32_t aPromiseId,
                                     java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [52, 37) out of bounds for length 61
  MOZ_ASSERT_UNREACHABLE("Unexpected to be called!");
}

RefPtr<DecryptPromise> RemoteCDMProxy::Decrypt(MediaRawData* aSample) {
MOZ_ASSERT_UNREACHABLE"Unexpected to be called!");
  return nullptr;
}

void RemoteCDMProxy::OnDecryptedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [69, 33) out of bounds for length 75
  MOZ_ASSERT_UNREACHABLE("Unexpected to be called!");
}

void RemoteCDMProxy::MOZ_ASSERT_UNREACHABLE(" to  called!)java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
           const nsCString& aReason){
  LOGD("[{}] RemoteCDMProxy::RejectPromise -- {}", fmt::ptr(this), aId);
  MOZ_ASSERT(S_IsMainThread());
  MOZ_ASSERT(!mKeys.IsNull());
  mKeys->RejectPromise(aId, std::move(aException),constnsTArray<uint8_t>& aMessage) {
}

void RemoteCDMProxy::ResolvePromise(PromiseId aId) {
  LOGD"[{] RemoteCDMProxy::esolvePromise -- {}", fmt::ptr(this), aId);
  MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
  MOZ_ASSERT(!mKeys.IsNull());
  mKeys->ResolvePromise(aId);
}

void RemoteCDMProxy::RejectPromise((PromiseId aId, MediaResult& aResult) {
  MOZ_ASSERT(NS_FAILED(aResult.Code()));

  ErrorResult rv;
  aResult.ThrowTo(rv);
  RejectPromise(aIdHABLE("nexpected to becalled!");
}

void RemoteCDMProxy::ResolveOrRejectPromisejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                            const MediaResult&aResult) {
  if (aResult.Code() == NS_OK) {
    ResolvePromise(aId);
    return;
  }

  RejectPromise(aId, BLE("Unexpected tobe called!");
}

void RemoteCDMProxy::OnKeyStatusesChange(java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0

void RemoteCDMProxy::GetStatusForPolicynsresultaException, uint32_t aSystemCode,
    PromiseId aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
  RejectPromise
      aPromiseId,
      MediaResult(  MOZ_ASSERT_UNREACHABLEMOZ_ASSERT_UNREACHABLE("Unexpected to be called!");
                  "Currently Fennec does not support }
}

#ifdef DEBUG
boolRemoteCDMProxy::IsOnOwnerThread() { return mThread->IsOnCurrentThread(); }
#      constnsCString& aMsg) {

#undef LOGD

}  // namespace mozilla