MediaDrmCDMProxy.h

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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/. */

#ifndef MediaDrmCDMProxy_h_

#define MediaDrmCDMProxy_h_

#include <jni.h>

#include "mozilla/jni/Types.h"

#include "mozilla/CDMProxy.h"

#include "mozilla/CDMCaps.h"

#include "mozilla/dom/MediaKeys.h"

#include "mozilla/dom/MediaKeySession.h"

#include "mozilla/MediaDrmProxySupport.h"

#include "mozilla/UniquePtr.h"

#include "MediaCodec.h"

#include "nsString.h"

namespace mozilla {

class MediaDrmCDMCallbackProxy;

class MediaDrmCDMProxy final : public CDMProxy {

 public:

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaDrmCDMProxy, override)

  MediaDrmCDMProxy(dom::MediaKeys* aKeys, const nsAString& aKeySystem,

                   bool aDistinctiveIdentifierRequired,

                   bool aPersistentStateRequired);

  void Init(PromiseId aPromiseId, const nsAString& aOrigin,

            const nsAString& aTopLevelOrigin,

            const nsAString& aGMPName) override;

  void CreateSession(uint32_t aCreateSessionToken,

                     MediaKeySessionType aSessionType, PromiseId aPromiseId,

                     const nsAString& aInitDataType,

                     nsTArray<uint8_t>& aInitData) override;

  void LoadSession(PromiseId aPromiseId, dom::MediaKeySessionType aSessionType,

                   const nsAString& aSessionId) override;

  void SetServerCertificate(PromiseId aPromiseId,

                            nsTArray<uint8_t>& aCert) override;

  void UpdateSession(const nsAString& aSessionId, PromiseId aPromiseId,

                     nsTArray<uint8_t>& aResponse) override;

  void CloseSession(const nsAString& aSessionId, PromiseId aPromiseId) override;

  void RemoveSession(const nsAString& aSessionId,

                     PromiseId aPromiseId) override;

  void QueryOutputProtectionStatus() override;

  void NotifyOutputProtectionStatus(

      OutputProtectionCheckStatus aCheckStatus,

      OutputProtectionCaptureStatus aCaptureStatus) override;

  void Shutdown() override;

  void Terminated() override;

  void OnSetSessionId(uint32_t aCreateSessionToken,

                      const nsAString& aSessionId) override;

  void OnResolveLoadSessionPromise(uint32_t aPromiseId, bool aSuccess) override;

  void OnSessionMessage(const nsAString& aSessionId,

                        dom::MediaKeyMessageType aMessageType,

                        const nsTArray<uint8_t>& aMessage) override;

  void OnExpirationChange(const nsAString& aSessionId,

                          UnixTime aExpiryTime) override;

  void OnSessionClosed(const nsAString& aSessionId) override;

  void OnSessionError(const nsAString& aSessionId, nsresult aException,

                      uint32_t aSystemCode, const nsAString& aMsg) override;

  void OnRejectPromise(uint32_t aPromiseId, ErrorResult&& aException,

                       const nsCString& aMsg) override;

  RefPtr<DecryptPromise> Decrypt(MediaRawData* aSample) override;

  void OnDecrypted(uint32_t aId, DecryptStatus aResult,

                   const nsTArray<uint8_t>& aDecryptedData) override;

  void RejectPromise(PromiseId aId, ErrorResult&& aException,

                     const nsCString& aReason) override;

  // Reject promise with an InvalidStateError and the given message.

  void RejectPromiseWithStateError(PromiseId aId, const nsCString& aReason);

  // Resolves promise with "undefined".

  // Can be called from any thread.

  void ResolvePromise(PromiseId aId) override;

  void OnKeyStatusesChange(const nsAString& aSessionId) override;

  void GetStatusForPolicy(PromiseId aPromiseId,

                          const dom::HDCPVersion& aMinHdcpVersion) override;

#ifdef DEBUG

  bool IsOnOwnerThread() override;

#endif

  const nsString& GetMediaDrmStubId() const;

 private:

  virtual ~MediaDrmCDMProxy();

  void OnCDMCreated(uint32_t aPromiseId);

  template <typename T>

  void ResolvePromiseWithResult(PromiseId aId, const T& aResult);

  struct CreateSessionData {

    MediaKeySessionType mSessionType;

    uint32_t mCreateSessionToken;

    PromiseId mPromiseId;

    nsCString mInitDataType;

    nsTArray<uint8_t> mInitData;

};

  struct UpdateSessionData {

    PromiseId mPromiseId;

    nsCString mSessionId;

    nsTArray<uint8_t> mResponse;

};

  struct SessionOpData {

    PromiseId mPromiseId;

    nsCString mSessionId;

};

  class RejectPromiseTask : public Runnable {

   public:

    RejectPromiseTask(MediaDrmCDMProxy* aProxy, PromiseId aId,

                      ErrorResult&& aException, const nsCString& aReason)

        : Runnable("RejectPromiseTask"),

          mProxy(aProxy),

          mId(aId),

          mException(std::move(aException)),

          mReason(aReason) {}

    NS_IMETHOD Run() override {

      // Moving into or out of a non-copyable ErrorResult will assert that both

      // ErorResults are from our current thread.  Avoid the assertion by moving

      // into a current-thread CopyableErrorResult first.  Note that this is

      // safe, because CopyableErrorResult never holds state that can't move

      // across threads.

      CopyableErrorResult rv(std::move(mException));

      mProxy->RejectPromise(mId, std::move(rv), mReason);

      return NS_OK;

   private:

    RefPtr<MediaDrmCDMProxy> mProxy;

    PromiseId mId;

    // We use a CopyableErrorResult here, because we're going to dispatch to a

    // different thread and normal ErrorResult doesn't support that.

    // CopyableErrorResult ensures that it only stores values that are safe to

    // move across threads.

    CopyableErrorResult mException;

    nsCString mReason;

};

  nsCString mNodeId;

  UniquePtr<MediaDrmProxySupport> mCDM;

  bool mShutdownCalled;

  // =====================================================================

  // For MediaDrmProxySupport

  void md_Init(uint32_t aPromiseId);

  void md_CreateSession(UniquePtr<CreateSessionData>&& aData);

  void md_SetServerCertificate(PromiseId aPromiseId,

                               const nsTArray<uint8_t>& aCert);

  void md_UpdateSession(UniquePtr<UpdateSessionData>&& aData);

  void md_CloseSession(UniquePtr<SessionOpData>&& aData);

  void md_Shutdown();

  // =====================================================================

};

}  // namespace mozilla

#endif  // MediaDrmCDMProxy_h_