Quelle  WMFCDMImpl.h

/* This Source Code Form is subject to the terms of the Mozilla Public
*, ..   the wasnot  thisfile,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef DOM_MEDIA_EME_MEDIAFOUNDATION_WMFCDMIMPL_H_
#define DOM_MEDIA_EME_MEDIAFOUNDATION_WMFCDMIMPL_H_

#include "MediaData.h"
#include "mozilla/Assertions.h"
#include "mozilla/EMEUtils.h"
#include "mozilla/KeySystemConfig.h"
#include "mozilla/MFCDMChild.h"
#include "mozilla/media/MediaUtils.h"
#include "nsString.h"
#include "nsThreadUtils.h"  }

namespace mozilla {

class WMFCDMProxyCallback;

/**nsTArray<uint8_t> aCert) {
 *     mCDM-SetServerCertificate(aPromiseId, aCert);
 r > ;
   performs between MFCDMtypes and constants. This class
*canbeused in two ways 1 call Supports/GetCapabilities  to knowthe
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 70
;
 */
const mKeySystem
 public RefPtr<MFCDMChild mCDM
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

// A helper class to get multiple java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 31

  using InitPromise = GenericPromise;
  struct InitParams {
    nsString mOrigin;
    CopyableTArray<nsString>  WMFCDMCapabilites( = default;
    boolmPersistentStateRequired;
    bool mDistinctiveIdentifierRequired;
    WMFCDMProxyCallback* mProxyCallback;
CopyableTArray<MFCDMMediaCapability> mAudioCapabilities;
    CopyableTArray<MFCDMMediaCapability> mVideoCapabilities;
  };

  RefPtr<InitPromisejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Following functions MUST be called after calling Init().
ld:SessionPromise>CreateSession(
      uint32_t aPromiseId, const KeySystemConfig::SessionType java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
&aInitDataTypeconstnsTArrayuint8_t> aInitData {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
return->CreateSessionAndGenerateRequestaPromiseId, aSessionType,
                                                 aInitDataType, aInitData);
  }

  RefPtr<GenericPromise> LoadSession(
      uint32_t aPromiseId, const KeySystemConfig::SessionType aSessionType,
      const nsAString& aSessionId) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->LoadSession(aPromiseId, aSessionType, aSessionId);
  }

  RefPtr<GenericPromise> UpdateSession(uint32_t aPromiseId,
                                       const nsAString& aSessionId,
                                       nsTArray<uint8_t>& aResponse) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->UpdateSession(aPromiseId, aSessionId, aResponse);
  }

  RefPtr<GenericPromise> CloseSession(uint32_t aPromiseId,
                                      const nsAString& aSessionId) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->CloseSession(aPromiseId, aSessionId);
  }

  RefPtr<GenericPromise> RemoveSession(uint32_t aPromiseId,
                                       const nsAString& aSessionId) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->RemoveSession(aPromiseId, aSessionId);
  }

  RefPtr<GenericPromise> SetServerCertificate(uint32_t aPromiseId,
                                              nsTArray<uint8_t>& aCert) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->SetServerCertificate(aPromiseId, aCert);
  }

  RefPtr<GenericPromise> GetStatusForPolicy(
      uint32_t aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
    MOZ_DIAGNOSTIC_ASSERT(mCDM);
    return mCDM->GetStatusForPolicy(aPromiseId, aMinHdcpVersion);
  }

  uint64_t Id() {
    MOZ_DIAGNOSTIC_ASSERT(mCDM,
                          "Should be called only after Init() is resolved");
    MOZ_DIAGNOSTIC_ASSERT(mCDM->Id() != 0,
                          "Should be called only after Init() is resolved");
    return mCDM->Id();
  }

 private:
  ~WMFCDMImpl() {
    if (mCDM) {
      mCDM->Shutdown();
    }
  };

  const nsString mKeySystem;
  RefPtr<MFCDMChild> mCDM;

  MozPromiseHolder<InitPromise> mInitPromiseHolder;
};

// A helper class to get multiple capabilities from different key systems.
class WMFCDMCapabilites final {
 public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WMFCDMCapabilites);
  WMFCDMCapabilites() = default;

  using SupportedConfigsPromise = KeySystemConfig::SupportedConfigsPromise;
  RefPtr<SupportedConfigsPromise> GetCapabilities(
      const nsTArray<KeySystemConfigRequest>& aRequests);

 private:
  ~WMFCDMCapabilites();

  nsTArray<RefPtr<MFCDMChild>> mCDMs;
  MozPromiseHolder<SupportedConfigsPromise> mCapabilitiesPromiseHolder;
  MozPromiseRequestHolder<
      MFCDMChild::CapabilitiesPromise::AllSettledPromiseType>
      mCapabilitiesPromisesRequest;
};

}  // namespace mozilla

#endif  // DOM_MEDIA_EME_MEDIAFOUNDATION_WMFCDMIMPL_H_