From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- .../eme/mediadrm/MediaDrmCDMCallbackProxy.cpp | 140 ++++++ dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.h | 69 +++ dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp | 467 +++++++++++++++++++++ dom/media/eme/mediadrm/MediaDrmCDMProxy.h | 184 ++++++++ dom/media/eme/mediadrm/MediaDrmProxySupport.cpp | 284 +++++++++++++ dom/media/eme/mediadrm/MediaDrmProxySupport.h | 67 +++ dom/media/eme/mediadrm/moz.build | 19 + 7 files changed, 1230 insertions(+) create mode 100644 dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.cpp create mode 100644 dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.h create mode 100644 dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp create mode 100644 dom/media/eme/mediadrm/MediaDrmCDMProxy.h create mode 100644 dom/media/eme/mediadrm/MediaDrmProxySupport.cpp create mode 100644 dom/media/eme/mediadrm/MediaDrmProxySupport.h create mode 100644 dom/media/eme/mediadrm/moz.build (limited to 'dom/media/eme/mediadrm') diff --git a/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.cpp b/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.cpp new file mode 100644 index 000000000..ee57afae9 --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.cpp @@ -0,0 +1,140 @@ +/* -*- 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/. */ + +#include "MediaDrmCDMCallbackProxy.h" +#include "mozilla/CDMProxy.h" +#include "nsString.h" +#include "mozilla/dom/MediaKeys.h" +#include "mozilla/dom/MediaKeySession.h" +#include "mozIGeckoMediaPluginService.h" +#include "nsContentCID.h" +#include "nsServiceManagerUtils.h" +#include "MainThreadUtils.h" +#include "mozilla/EMEUtils.h" + +namespace mozilla { + +MediaDrmCDMCallbackProxy::MediaDrmCDMCallbackProxy(CDMProxy* aProxy) + : mProxy(aProxy) +{ + +} + +void +MediaDrmCDMCallbackProxy::SetSessionId(uint32_t aToken, + const nsCString& aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + mProxy->OnSetSessionId(aToken, NS_ConvertUTF8toUTF16(aSessionId)); +} + +void +MediaDrmCDMCallbackProxy::ResolveLoadSessionPromise(uint32_t aPromiseId, + bool aSuccess) +{ + MOZ_ASSERT(NS_IsMainThread()); + mProxy->OnResolveLoadSessionPromise(aPromiseId, aSuccess); +} + +void +MediaDrmCDMCallbackProxy::ResolvePromise(uint32_t aPromiseId) +{ + // Note: CDMProxy proxies this from non-main threads to main thread. + mProxy->ResolvePromise(aPromiseId); +} + +void +MediaDrmCDMCallbackProxy::RejectPromise(uint32_t aPromiseId, + nsresult aException, + const nsCString& aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + mProxy->OnRejectPromise(aPromiseId, aException, aMessage); +} + +void +MediaDrmCDMCallbackProxy::SessionMessage(const nsCString& aSessionId, + dom::MediaKeyMessageType aMessageType, + const nsTArray& aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + // For removing constness + nsTArray message(aMessage); + mProxy->OnSessionMessage(NS_ConvertUTF8toUTF16(aSessionId), aMessageType, message); +} + +void +MediaDrmCDMCallbackProxy::ExpirationChange(const nsCString& aSessionId, + UnixTime aExpiryTime) +{ + MOZ_ASSERT(NS_IsMainThread()); + mProxy->OnExpirationChange(NS_ConvertUTF8toUTF16(aSessionId), aExpiryTime); +} + +void +MediaDrmCDMCallbackProxy::SessionClosed(const nsCString& aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + bool keyStatusesChange = false; + { + CDMCaps::AutoLock caps(mProxy->Capabilites()); + keyStatusesChange = caps.RemoveKeysForSession(NS_ConvertUTF8toUTF16(aSessionId)); + } + if (keyStatusesChange) { + mProxy->OnKeyStatusesChange(NS_ConvertUTF8toUTF16(aSessionId)); + } + mProxy->OnSessionClosed(NS_ConvertUTF8toUTF16(aSessionId)); +} + +void +MediaDrmCDMCallbackProxy::SessionError(const nsCString& aSessionId, + nsresult aException, + uint32_t aSystemCode, + const nsCString& aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + mProxy->OnSessionError(NS_ConvertUTF8toUTF16(aSessionId), + aException, + aSystemCode, + NS_ConvertUTF8toUTF16(aMessage)); +} + +void +MediaDrmCDMCallbackProxy::BatchedKeyStatusChanged(const nsCString& aSessionId, + const nsTArray& aKeyInfos) +{ + MOZ_ASSERT(NS_IsMainThread()); + BatchedKeyStatusChangedInternal(aSessionId, aKeyInfos); +} + +void +MediaDrmCDMCallbackProxy::BatchedKeyStatusChangedInternal(const nsCString& aSessionId, + const nsTArray& aKeyInfos) +{ + bool keyStatusesChange = false; + { + CDMCaps::AutoLock caps(mProxy->Capabilites()); + for (size_t i = 0; i < aKeyInfos.Length(); i++) { + keyStatusesChange |= + caps.SetKeyStatus(aKeyInfos[i].mKeyId, + NS_ConvertUTF8toUTF16(aSessionId), + aKeyInfos[i].mStatus); + } + } + if (keyStatusesChange) { + mProxy->OnKeyStatusesChange(NS_ConvertUTF8toUTF16(aSessionId)); + } +} + +void +MediaDrmCDMCallbackProxy::Decrypted(uint32_t aId, + DecryptStatus aResult, + const nsTArray& aDecryptedData) +{ + MOZ_ASSERT_UNREACHABLE("Fennec could not handle decrypted event"); +} + +} // namespace mozilla \ No newline at end of file diff --git a/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.h b/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.h new file mode 100644 index 000000000..29f9c8192 --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmCDMCallbackProxy.h @@ -0,0 +1,69 @@ +/* -*- 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 MediaDrmCDMCallbackProxy_h_ +#define MediaDrmCDMCallbackProxy_h_ + +#include "mozilla/CDMProxy.h" +#include "mozilla/DecryptorProxyCallback.h" + +namespace mozilla { +class CDMProxy; +// Proxies call backs from the MediaDrmProxy -> MediaDrmProxySupport back to the MediaKeys +// object on the main thread. +// We used annotation calledFrom = "gecko" to ensure running on main thread. +class MediaDrmCDMCallbackProxy : public DecryptorProxyCallback { +public: + + void SetDecryptorId(uint32_t aId) override {} + + void SetSessionId(uint32_t aCreateSessionToken, + const nsCString& aSessionId) override; + + void ResolveLoadSessionPromise(uint32_t aPromiseId, + bool aSuccess) override; + + void ResolvePromise(uint32_t aPromiseId) override; + + void RejectPromise(uint32_t aPromiseId, + nsresult aException, + const nsCString& aSessionId) override; + + void SessionMessage(const nsCString& aSessionId, + dom::MediaKeyMessageType aMessageType, + const nsTArray& aMessage) override; + + void ExpirationChange(const nsCString& aSessionId, + UnixTime aExpiryTime) override; + + void SessionClosed(const nsCString& aSessionId) override; + + void SessionError(const nsCString& aSessionId, + nsresult aException, + uint32_t aSystemCode, + const nsCString& aMessage) override; + + void Decrypted(uint32_t aId, + DecryptStatus aResult, + const nsTArray& aDecryptedData) override; + + void BatchedKeyStatusChanged(const nsCString& aSessionId, + const nsTArray& aKeyInfos) override; + + ~MediaDrmCDMCallbackProxy() {} + +private: + friend class MediaDrmCDMProxy; + explicit MediaDrmCDMCallbackProxy(CDMProxy* aProxy); + + void BatchedKeyStatusChangedInternal(const nsCString& aSessionId, + const nsTArray& aKeyInfos); + // Warning: Weak ref. + CDMProxy* mProxy; +}; + +} // namespace mozilla +#endif \ No newline at end of file diff --git a/dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp b/dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp new file mode 100644 index 000000000..a57d764e7 --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp @@ -0,0 +1,467 @@ +/* -*- 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/. */ + +#include "mozilla/dom/MediaKeySession.h" +#include "mozilla/MediaDrmCDMProxy.h" +#include "MediaDrmCDMCallbackProxy.h" + +using namespace mozilla::java::sdk; + +namespace mozilla { + +MediaDrmSessionType +ToMediaDrmSessionType(dom::MediaKeySessionType aSessionType) +{ + switch (aSessionType) { + case dom::MediaKeySessionType::Temporary: return kKeyStreaming; + case dom::MediaKeySessionType::Persistent_license: return kKeyOffline; + default: return kKeyStreaming; + }; +} + +MediaDrmCDMProxy::MediaDrmCDMProxy(dom::MediaKeys* aKeys, + const nsAString& aKeySystem, + bool aDistinctiveIdentifierRequired, + bool aPersistentStateRequired) + : CDMProxy(aKeys, + aKeySystem, + aDistinctiveIdentifierRequired, + aPersistentStateRequired) + , mCDM(nullptr) + , mShutdownCalled(false) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_COUNT_CTOR(MediaDrmCDMProxy); +} + +MediaDrmCDMProxy::~MediaDrmCDMProxy() +{ + MOZ_COUNT_DTOR(MediaDrmCDMProxy); +} + +void +MediaDrmCDMProxy::Init(PromiseId aPromiseId, + const nsAString& aOrigin, + const nsAString& aTopLevelOrigin, + const nsAString& aName, + bool aInPrivateBrowsing) +{ + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_TRUE_VOID(!mKeys.IsNull()); + + EME_LOG("MediaDrmCDMProxy::Init (%s, %s) %s", + NS_ConvertUTF16toUTF8(aOrigin).get(), + NS_ConvertUTF16toUTF8(aTopLevelOrigin).get(), + (aInPrivateBrowsing ? "PrivateBrowsing" : "NonPrivateBrowsing")); + + // Create a thread to work with cdm. + if (!mOwnerThread) { + nsresult rv = NS_NewNamedThread("MDCDMThread", getter_AddRefs(mOwnerThread)); + if (NS_FAILED(rv)) { + RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Couldn't create CDM thread MediaDrmCDMProxy::Init")); + return; + } + } + + mCDM = mozilla::MakeUnique(mKeySystem); + nsCOMPtr task(NewRunnableMethod(this, + &MediaDrmCDMProxy::md_Init, + aPromiseId)); + mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL); +} + +void +MediaDrmCDMProxy::CreateSession(uint32_t aCreateSessionToken, + MediaKeySessionType aSessionType, + PromiseId aPromiseId, + const nsAString& aInitDataType, + nsTArray& aInitData) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mOwnerThread); + + nsAutoPtr data(new CreateSessionData()); + data->mSessionType = aSessionType; + data->mCreateSessionToken = aCreateSessionToken; + data->mPromiseId = aPromiseId; + data->mInitDataType = NS_ConvertUTF16toUTF8(aInitDataType); + data->mInitData = Move(aInitData); + + nsCOMPtr task( + NewRunnableMethod>(this, + &MediaDrmCDMProxy::md_CreateSession, + data)); + mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL); +} + +void +MediaDrmCDMProxy::LoadSession(PromiseId aPromiseId, + const nsAString& aSessionId) +{ + // TODO: Implement LoadSession. + RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Currently Fennec did not support LoadSession")); +} + +void +MediaDrmCDMProxy::SetServerCertificate(PromiseId aPromiseId, + nsTArray& aCert) +{ + // TODO: Implement SetServerCertificate. + RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Currently Fennec did not support SetServerCertificate")); +} + +void +MediaDrmCDMProxy::UpdateSession(const nsAString& aSessionId, + PromiseId aPromiseId, + nsTArray& aResponse) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mOwnerThread); + NS_ENSURE_TRUE_VOID(!mKeys.IsNull()); + + nsAutoPtr data(new UpdateSessionData()); + data->mPromiseId = aPromiseId; + data->mSessionId = NS_ConvertUTF16toUTF8(aSessionId); + data->mResponse = Move(aResponse); + + nsCOMPtr task( + NewRunnableMethod>(this, + &MediaDrmCDMProxy::md_UpdateSession, + data)); + mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL); +} + +void +MediaDrmCDMProxy::CloseSession(const nsAString& aSessionId, + PromiseId aPromiseId) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mOwnerThread); + NS_ENSURE_TRUE_VOID(!mKeys.IsNull()); + + nsAutoPtr data(new SessionOpData()); + data->mPromiseId = aPromiseId; + data->mSessionId = NS_ConvertUTF16toUTF8(aSessionId); + + nsCOMPtr task( + NewRunnableMethod>(this, + &MediaDrmCDMProxy::md_CloseSession, + data)); + mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL); +} + +void +MediaDrmCDMProxy::RemoveSession(const nsAString& aSessionId, + PromiseId aPromiseId) +{ + // TODO: Implement RemoveSession. + RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Currently Fennec did not support RemoveSession")); +} + +void +MediaDrmCDMProxy::Shutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mOwnerThread); + nsCOMPtr task( + NewRunnableMethod(this, &MediaDrmCDMProxy::md_Shutdown)); + + mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL); + mOwnerThread->Shutdown(); + mOwnerThread = nullptr; +} + +void +MediaDrmCDMProxy::Terminated() +{ + // TODO: Implement Terminated. + // Should find a way to handle the case when remote side MediaDrm crashed. +} + +const nsCString& +MediaDrmCDMProxy::GetNodeId() const +{ + return mNodeId; +} + +void +MediaDrmCDMProxy::OnSetSessionId(uint32_t aCreateSessionToken, + const nsAString& aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + + RefPtr session(mKeys->GetPendingSession(aCreateSessionToken)); + if (session) { + session->SetSessionId(aSessionId); + } +} + +void +MediaDrmCDMProxy::OnResolveLoadSessionPromise(uint32_t aPromiseId, bool aSuccess) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + mKeys->OnSessionLoaded(aPromiseId, aSuccess); +} + +void +MediaDrmCDMProxy::OnSessionMessage(const nsAString& aSessionId, + dom::MediaKeyMessageType aMessageType, + nsTArray& aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + RefPtr session(mKeys->GetSession(aSessionId)); + if (session) { + session->DispatchKeyMessage(aMessageType, aMessage); + } +} + +void +MediaDrmCDMProxy::OnExpirationChange(const nsAString& aSessionId, + UnixTime aExpiryTime) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + RefPtr session(mKeys->GetSession(aSessionId)); + if (session) { + session->SetExpiration(static_cast(aExpiryTime)); + } +} + +void +MediaDrmCDMProxy::OnSessionClosed(const nsAString& aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + RefPtr session(mKeys->GetSession(aSessionId)); + if (session) { + session->OnClosed(); + } +} + +void +MediaDrmCDMProxy::OnSessionError(const nsAString& aSessionId, + nsresult aException, + uint32_t aSystemCode, + const nsAString& aMsg) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + RefPtr session(mKeys->GetSession(aSessionId)); + if (session) { + session->DispatchKeyError(aSystemCode); + } +} + +void +MediaDrmCDMProxy::OnRejectPromise(uint32_t aPromiseId, + nsresult aDOMException, + const nsCString& aMsg) +{ + MOZ_ASSERT(NS_IsMainThread()); + RejectPromise(aPromiseId, aDOMException, aMsg); +} + +RefPtr +MediaDrmCDMProxy::Decrypt(MediaRawData* aSample) +{ + MOZ_ASSERT_UNREACHABLE("Fennec could not handle decrypting individually"); + return nullptr; +} + +void +MediaDrmCDMProxy::OnDecrypted(uint32_t aId, + DecryptStatus aResult, + const nsTArray& aDecryptedData) +{ + MOZ_ASSERT_UNREACHABLE("Fennec could not handle decrypted event"); +} + +void +MediaDrmCDMProxy::RejectPromise(PromiseId aId, nsresult aCode, + const nsCString& aReason) +{ + if (NS_IsMainThread()) { + if (!mKeys.IsNull()) { + mKeys->RejectPromise(aId, aCode, aReason); + } + } else { + nsCOMPtr task(new RejectPromiseTask(this, aId, aCode, + aReason)); + NS_DispatchToMainThread(task); + } +} + +void +MediaDrmCDMProxy::ResolvePromise(PromiseId aId) +{ + if (NS_IsMainThread()) { + if (!mKeys.IsNull()) { + mKeys->ResolvePromise(aId); + } else { + NS_WARNING("MediaDrmCDMProxy unable to resolve promise!"); + } + } else { + nsCOMPtr task; + task = NewRunnableMethod(this, + &MediaDrmCDMProxy::ResolvePromise, + aId); + NS_DispatchToMainThread(task); + } +} + +const nsString& +MediaDrmCDMProxy::KeySystem() const +{ + return mKeySystem; +} + +CDMCaps& +MediaDrmCDMProxy::Capabilites() +{ + return mCapabilites; +} + +void +MediaDrmCDMProxy::OnKeyStatusesChange(const nsAString& aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + RefPtr session(mKeys->GetSession(aSessionId)); + if (session) { + session->DispatchKeyStatusesChange(); + } +} + +void +MediaDrmCDMProxy::GetSessionIdsForKeyId(const nsTArray& aKeyId, + nsTArray& aSessionIds) +{ + CDMCaps::AutoLock caps(Capabilites()); + caps.GetSessionIdsForKeyId(aKeyId, aSessionIds); +} + +#ifdef DEBUG +bool +MediaDrmCDMProxy::IsOnOwnerThread() +{ + return NS_GetCurrentThread() == mOwnerThread; +} +#endif + +void +MediaDrmCDMProxy::OnCDMCreated(uint32_t aPromiseId) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mKeys.IsNull()) { + return; + } + + if (mCDM) { + mKeys->OnCDMCreated(aPromiseId, GetNodeId(), 0); + return; + } + + // No CDM? Just reject the promise. + mKeys->RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Null CDM in OnCDMCreated()")); +} + +void +MediaDrmCDMProxy::md_Init(uint32_t aPromiseId) +{ + MOZ_ASSERT(IsOnOwnerThread()); + MOZ_ASSERT(mCDM); + + mCallback = new MediaDrmCDMCallbackProxy(this); + mCDM->Init(mCallback); + nsCOMPtr task( + NewRunnableMethod(this, + &MediaDrmCDMProxy::OnCDMCreated, + aPromiseId)); + NS_DispatchToMainThread(task); +} + +void +MediaDrmCDMProxy::md_CreateSession(nsAutoPtr aData) +{ + MOZ_ASSERT(IsOnOwnerThread()); + + if (!mCDM) { + RejectPromise(aData->mPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Null CDM in md_CreateSession")); + return; + } + + mCDM->CreateSession(aData->mCreateSessionToken, + aData->mPromiseId, + aData->mInitDataType, + aData->mInitData, + ToMediaDrmSessionType(aData->mSessionType)); +} + +void +MediaDrmCDMProxy::md_UpdateSession(nsAutoPtr aData) +{ + MOZ_ASSERT(IsOnOwnerThread()); + + if (!mCDM) { + RejectPromise(aData->mPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Null CDM in md_UpdateSession")); + return; + } + mCDM->UpdateSession(aData->mPromiseId, + aData->mSessionId, + aData->mResponse); +} + +void +MediaDrmCDMProxy::md_CloseSession(nsAutoPtr aData) +{ + MOZ_ASSERT(IsOnOwnerThread()); + + if (!mCDM) { + RejectPromise(aData->mPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, + NS_LITERAL_CSTRING("Null CDM in md_CloseSession")); + return; + } + mCDM->CloseSession(aData->mPromiseId, aData->mSessionId); +} + +void +MediaDrmCDMProxy::md_Shutdown() +{ + MOZ_ASSERT(IsOnOwnerThread()); + MOZ_ASSERT(mCDM); + if (mShutdownCalled) { + return; + } + mShutdownCalled = true; + mCDM->Shutdown(); + mCDM = nullptr; +} + +} // namespace mozilla \ No newline at end of file diff --git a/dom/media/eme/mediadrm/MediaDrmCDMProxy.h b/dom/media/eme/mediadrm/MediaDrmCDMProxy.h new file mode 100644 index 000000000..c7cb3000f --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmCDMProxy.h @@ -0,0 +1,184 @@ +/* -*- 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 +#include "mozilla/jni/Types.h" +#include "GeneratedJNINatives.h" + +#include "mozilla/CDMProxy.h" +#include "mozilla/CDMCaps.h" +#include "mozilla/dom/MediaKeys.h" +#include "mozilla/MediaDrmProxySupport.h" +#include "mozilla/UniquePtr.h" + +#include "MediaCodec.h" +#include "nsString.h" +#include "nsAutoPtr.h" + +using namespace mozilla::java; + +namespace mozilla { +class MediaDrmCDMCallbackProxy; +class MediaDrmCDMProxy : public CDMProxy { +public: + + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaDrmCDMProxy) + + MediaDrmCDMProxy(dom::MediaKeys* aKeys, + const nsAString& aKeySystem, + bool aDistinctiveIdentifierRequired, + bool aPersistentStateRequired); + + void Init(PromiseId aPromiseId, + const nsAString& aOrigin, + const nsAString& aTopLevelOrigin, + const nsAString& aGMPName, + bool aInPrivateBrowsing) override; + + void CreateSession(uint32_t aCreateSessionToken, + MediaKeySessionType aSessionType, + PromiseId aPromiseId, + const nsAString& aInitDataType, + nsTArray& aInitData) override; + + void LoadSession(PromiseId aPromiseId, + const nsAString& aSessionId) override; + + void SetServerCertificate(PromiseId aPromiseId, + nsTArray& aCert) override; + + void UpdateSession(const nsAString& aSessionId, + PromiseId aPromiseId, + nsTArray& aResponse) override; + + void CloseSession(const nsAString& aSessionId, + PromiseId aPromiseId) override; + + void RemoveSession(const nsAString& aSessionId, + PromiseId aPromiseId) override; + + void Shutdown() override; + + void Terminated() override; + + const nsCString& GetNodeId() const 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, + nsTArray& 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, + nsresult aCode, + const nsCString& aMsg) override; + + RefPtr Decrypt(MediaRawData* aSample) override; + void OnDecrypted(uint32_t aId, + DecryptStatus aResult, + const nsTArray& aDecryptedData) override; + + void RejectPromise(PromiseId aId, nsresult aCode, + const nsCString& aReason) override; + + // Resolves promise with "undefined". + // Can be called from any thread. + void ResolvePromise(PromiseId aId) override; + + // Threadsafe. + const nsString& KeySystem() const override; + + CDMCaps& Capabilites() override; + + void OnKeyStatusesChange(const nsAString& aSessionId) override; + + void GetSessionIdsForKeyId(const nsTArray& aKeyId, + nsTArray& aSessionIds) override; + +#ifdef DEBUG + bool IsOnOwnerThread() override; +#endif + +private: + virtual ~MediaDrmCDMProxy(); + + void OnCDMCreated(uint32_t aPromiseId); + + struct CreateSessionData { + MediaKeySessionType mSessionType; + uint32_t mCreateSessionToken; + PromiseId mPromiseId; + nsCString mInitDataType; + nsTArray mInitData; + }; + + struct UpdateSessionData { + PromiseId mPromiseId; + nsCString mSessionId; + nsTArray mResponse; + }; + + struct SessionOpData { + PromiseId mPromiseId; + nsCString mSessionId; + }; + + class RejectPromiseTask : public Runnable { + public: + RejectPromiseTask(MediaDrmCDMProxy* aProxy, + PromiseId aId, + nsresult aCode, + const nsCString& aReason) + : mProxy(aProxy) + , mId(aId) + , mCode(aCode) + , mReason(aReason) + { + } + NS_METHOD Run() { + mProxy->RejectPromise(mId, mCode, mReason); + return NS_OK; + } + private: + RefPtr mProxy; + PromiseId mId; + nsresult mCode; + nsCString mReason; + }; + + nsCString mNodeId; + mozilla::UniquePtr mCDM; + nsAutoPtr mCallback; + bool mShutdownCalled; + +// ===================================================================== +// For MediaDrmProxySupport + void md_Init(uint32_t aPromiseId); + void md_CreateSession(nsAutoPtr aData); + void md_UpdateSession(nsAutoPtr aData); + void md_CloseSession(nsAutoPtr aData); + void md_Shutdown(); +// ===================================================================== +}; + +} // namespace mozilla +#endif // MediaDrmCDMProxy_h_ \ No newline at end of file diff --git a/dom/media/eme/mediadrm/MediaDrmProxySupport.cpp b/dom/media/eme/mediadrm/MediaDrmProxySupport.cpp new file mode 100644 index 000000000..192769470 --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmProxySupport.cpp @@ -0,0 +1,284 @@ +/* -*- 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/. */ + +#include "MediaDrmProxySupport.h" +#include "mozilla/EMEUtils.h" +#include "FennecJNINatives.h" +#include "MediaCodec.h" // For MediaDrm::KeyStatus +#include "MediaPrefs.h" + +using namespace mozilla::java; + +namespace mozilla { + +LogModule* GetMDRMNLog() { + static LazyLogModule log("MediaDrmProxySupport"); + return log; +} + +class MediaDrmJavaCallbacksSupport + : public MediaDrmProxy::NativeMediaDrmProxyCallbacks::Natives +{ +public: + typedef MediaDrmProxy::NativeMediaDrmProxyCallbacks::Natives MediaDrmProxyNativeCallbacks; + using MediaDrmProxyNativeCallbacks::DisposeNative; + using MediaDrmProxyNativeCallbacks::AttachNative; + + MediaDrmJavaCallbacksSupport(DecryptorProxyCallback* aDecryptorProxyCallback) + : mDecryptorProxyCallback(aDecryptorProxyCallback) + { + MOZ_ASSERT(aDecryptorProxyCallback); + } + /* + * Native implementation, called by Java. + */ + void OnSessionCreated(int aCreateSessionToken, + int aPromiseId, + jni::ByteArray::Param aSessionId, + jni::ByteArray::Param aRequest); + + void OnSessionUpdated(int aPromiseId, jni::ByteArray::Param aSessionId); + + void OnSessionClosed(int aPromiseId, jni::ByteArray::Param aSessionId); + + void OnSessionMessage(jni::ByteArray::Param aSessionId, + int /*mozilla::dom::MediaKeyMessageType*/ aSessionMessageType, + jni::ByteArray::Param aRequest); + + void OnSessionError(jni::ByteArray::Param aSessionId, + jni::String::Param aMessage); + + void OnSessionBatchedKeyChanged(jni::ByteArray::Param, + jni::ObjectArray::Param); + + void OnRejectPromise(int aPromiseId, jni::String::Param aMessage); + +private: + DecryptorProxyCallback* mDecryptorProxyCallback; +}; // MediaDrmJavaCallbacksSupport + +void +MediaDrmJavaCallbacksSupport::OnSessionCreated(int aCreateSessionToken, + int aPromiseId, + jni::ByteArray::Param aSessionId, + jni::ByteArray::Param aRequest) +{ + MOZ_ASSERT(NS_IsMainThread()); + auto reqDataArray = aRequest->GetElements(); + nsCString sessionId(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()); + MDRMN_LOG("SessionId(%s) closed", sessionId.get()); + + mDecryptorProxyCallback->SetSessionId(aCreateSessionToken, sessionId); + mDecryptorProxyCallback->ResolvePromise(aPromiseId); +} + +void +MediaDrmJavaCallbacksSupport::OnSessionUpdated(int aPromiseId, + jni::ByteArray::Param aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + MDRMN_LOG("SessionId(%s) closed", + nsCString(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()).get()); + mDecryptorProxyCallback->ResolvePromise(aPromiseId); +} + +void +MediaDrmJavaCallbacksSupport::OnSessionClosed(int aPromiseId, + jni::ByteArray::Param aSessionId) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCString sessionId(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()); + MDRMN_LOG("SessionId(%s) closed", sessionId.get()); + mDecryptorProxyCallback->ResolvePromise(aPromiseId); + mDecryptorProxyCallback->SessionClosed(sessionId); +} + +void +MediaDrmJavaCallbacksSupport::OnSessionMessage(jni::ByteArray::Param aSessionId, + int /*mozilla::dom::MediaKeyMessageType*/ aMessageType, + jni::ByteArray::Param aRequest) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCString sessionId(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()); + auto reqDataArray = aRequest->GetElements(); + + nsTArray retRequest; + retRequest.AppendElements(reinterpret_cast(reqDataArray.Elements()), + reqDataArray.Length()); + + mDecryptorProxyCallback->SessionMessage(sessionId, + static_cast(aMessageType), + retRequest); +} + +void +MediaDrmJavaCallbacksSupport::OnSessionError(jni::ByteArray::Param aSessionId, + jni::String::Param aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCString sessionId(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()); + nsCString errorMessage = aMessage->ToCString(); + MDRMN_LOG("SessionId(%s)", sessionId.get()); + // TODO: We cannot get system error code from media drm API. + // Currently use -1 as an error code. + mDecryptorProxyCallback->SessionError(sessionId, + NS_ERROR_DOM_INVALID_STATE_ERR, + -1, + errorMessage); +} + +// TODO: MediaDrm.KeyStatus defined the status code not included +// dom::MediaKeyStatus::Released and dom::MediaKeyStatus::Output_downscaled. +// Should keep tracking for this if it will be changed in the future. +static dom::MediaKeyStatus +MediaDrmKeyStatusToMediaKeyStatus(int aStatusCode) +{ + using mozilla::java::sdk::KeyStatus; + switch (aStatusCode) { + case KeyStatus::STATUS_USABLE: return dom::MediaKeyStatus::Usable; + case KeyStatus::STATUS_EXPIRED: return dom::MediaKeyStatus::Expired; + case KeyStatus::STATUS_OUTPUT_NOT_ALLOWED: return dom::MediaKeyStatus::Output_restricted; + case KeyStatus::STATUS_INTERNAL_ERROR: return dom::MediaKeyStatus::Internal_error; + case KeyStatus::STATUS_PENDING: return dom::MediaKeyStatus::Status_pending; + default: return dom::MediaKeyStatus::Internal_error; + } +} + +void +MediaDrmJavaCallbacksSupport::OnSessionBatchedKeyChanged(jni::ByteArray::Param aSessionId, + jni::ObjectArray::Param aKeyInfos) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCString sessionId(reinterpret_cast(aSessionId->GetElements().Elements()), + aSessionId->Length()); + nsTArray keyInfosObjectArray(aKeyInfos->GetElements()); + + nsTArray keyInfosArray; + + for (auto&& keyInfoObject : keyInfosObjectArray) { + java::SessionKeyInfo::LocalRef keyInfo(mozilla::Move(keyInfoObject)); + mozilla::jni::ByteArray::LocalRef keyIdByteArray = keyInfo->KeyId(); + nsTArray keyIdInt8Array = keyIdByteArray->GetElements(); + // Cast nsTArray to nsTArray + nsTArray* keyId = reinterpret_cast*>(&keyIdInt8Array); + auto keyStatus = keyInfo->Status(); // int32_t + keyInfosArray.AppendElement(CDMKeyInfo(*keyId, + dom::Optional( + MediaDrmKeyStatusToMediaKeyStatus(keyStatus) + ) + ) + ); + } + + mDecryptorProxyCallback->BatchedKeyStatusChanged(sessionId, + keyInfosArray); +} + +void +MediaDrmJavaCallbacksSupport::OnRejectPromise(int aPromiseId, jni::String::Param aMessage) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCString reason = aMessage->ToCString(); + MDRMN_LOG("OnRejectPromise aMessage(%s) ", reason.get()); + // Current implementation assume all the reject from MediaDrm is due to invalid state. + // Other cases should be handled before calling into MediaDrmProxy API. + mDecryptorProxyCallback->RejectPromise(aPromiseId, + NS_ERROR_DOM_INVALID_STATE_ERR, + reason); +} + +MediaDrmProxySupport::MediaDrmProxySupport(const nsAString& aKeySystem) + : mKeySystem(aKeySystem), mDestroyed(false) +{ + mJavaCallbacks = MediaDrmProxy::NativeMediaDrmProxyCallbacks::New(); + + mBridgeProxy = + MediaDrmProxy::Create(mKeySystem, + mJavaCallbacks, + MediaPrefs::PDMAndroidRemoteCodecEnabled()); +} + +MediaDrmProxySupport::~MediaDrmProxySupport() +{ + MOZ_ASSERT(mDestroyed, "Shutdown() should be called before !!"); + MediaDrmJavaCallbacksSupport::DisposeNative(mJavaCallbacks); +} + +nsresult +MediaDrmProxySupport::Init(DecryptorProxyCallback* aCallback) +{ + MOZ_ASSERT(mJavaCallbacks); + + mCallback = aCallback; + MediaDrmJavaCallbacksSupport::AttachNative(mJavaCallbacks, + mozilla::MakeUnique(mCallback)); + return mBridgeProxy != nullptr ? NS_OK : NS_ERROR_FAILURE; +} + +void +MediaDrmProxySupport::CreateSession(uint32_t aCreateSessionToken, + uint32_t aPromiseId, + const nsCString& aInitDataType, + const nsTArray& aInitData, + MediaDrmSessionType aSessionType) +{ + MOZ_ASSERT(mBridgeProxy); + + auto initDataBytes = + mozilla::jni::ByteArray::New(reinterpret_cast(&aInitData[0]), + aInitData.Length()); + // TODO: aSessionType is not used here. + // Refer to + // http://androidxref.com/5.1.1_r6/xref/external/chromium_org/media/base/android/java/src/org/chromium/media/MediaDrmBridge.java#420 + // it is hard code to streaming type. + mBridgeProxy->CreateSession(aCreateSessionToken, + aPromiseId, + NS_ConvertUTF8toUTF16(aInitDataType), + initDataBytes); +} + +void +MediaDrmProxySupport::UpdateSession(uint32_t aPromiseId, + const nsCString& aSessionId, + const nsTArray& aResponse) +{ + MOZ_ASSERT(mBridgeProxy); + + auto response = + mozilla::jni::ByteArray::New(reinterpret_cast(aResponse.Elements()), + aResponse.Length()); + mBridgeProxy->UpdateSession(aPromiseId, + NS_ConvertUTF8toUTF16(aSessionId), + response); +} + +void +MediaDrmProxySupport::CloseSession(uint32_t aPromiseId, + const nsCString& aSessionId) +{ + MOZ_ASSERT(mBridgeProxy); + + mBridgeProxy->CloseSession(aPromiseId, NS_ConvertUTF8toUTF16(aSessionId)); +} + +void +MediaDrmProxySupport::Shutdown() +{ + MOZ_ASSERT(mBridgeProxy); + + if (mDestroyed) { + return; + } + mBridgeProxy->Destroy(); + mDestroyed = true; +} + +} // namespace mozilla \ No newline at end of file diff --git a/dom/media/eme/mediadrm/MediaDrmProxySupport.h b/dom/media/eme/mediadrm/MediaDrmProxySupport.h new file mode 100644 index 000000000..e43b71bc1 --- /dev/null +++ b/dom/media/eme/mediadrm/MediaDrmProxySupport.h @@ -0,0 +1,67 @@ +/* -*- 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 MediaDrmProxySupport_H +#define MediaDrmProxySupport_H + +#include "mozilla/DecryptorProxyCallback.h" +#include "mozilla/Logging.h" +#include "FennecJNIWrappers.h" +#include "nsString.h" + + +namespace mozilla { + +enum MediaDrmSessionType { + kKeyStreaming = 1, + kKeyOffline = 2, + kKeyRelease = 3, +}; + +#ifndef MDRMN_LOG + LogModule* GetMDRMNLog(); + #define MDRMN_LOG(x, ...) MOZ_LOG(GetMDRMNLog(), mozilla::LogLevel::Debug,\ + ("[MediaDrmProxySupport][%s]" x, __FUNCTION__, ##__VA_ARGS__)) +#endif + +class MediaDrmProxySupport final +{ +public: + + MediaDrmProxySupport(const nsAString& aKeySystem); + ~MediaDrmProxySupport(); + + /* + * APIs to act as GMPDecryptorAPI, discarding unnecessary calls. + */ + nsresult Init(DecryptorProxyCallback* aCallback); + + void CreateSession(uint32_t aCreateSessionToken, + uint32_t aPromiseId, + const nsCString& aInitDataType, + const nsTArray& aInitData, + MediaDrmSessionType aSessionType); + + void UpdateSession(uint32_t aPromiseId, + const nsCString& aSessionId, + const nsTArray& aResponse); + + void CloseSession(uint32_t aPromiseId, + const nsCString& aSessionId); + + void Shutdown(); + +private: + const nsString mKeySystem; + java::MediaDrmProxy::GlobalRef mBridgeProxy; + java::MediaDrmProxy::NativeMediaDrmProxyCallbacks::GlobalRef mJavaCallbacks; + DecryptorProxyCallback* mCallback; + bool mDestroyed; + +}; + +} // namespace mozilla +#endif // MediaDrmProxySupport_H \ No newline at end of file diff --git a/dom/media/eme/mediadrm/moz.build b/dom/media/eme/mediadrm/moz.build new file mode 100644 index 000000000..c01f7a52e --- /dev/null +++ b/dom/media/eme/mediadrm/moz.build @@ -0,0 +1,19 @@ +# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXPORTS.mozilla += [ + 'MediaDrmCDMCallbackProxy.h', + 'MediaDrmCDMProxy.h', + 'MediaDrmProxySupport.h', +] + +UNIFIED_SOURCES += [ + 'MediaDrmCDMCallbackProxy.cpp', + 'MediaDrmCDMProxy.cpp', + 'MediaDrmProxySupport.cpp', +] + +FINAL_LIBRARY = 'xul' \ No newline at end of file -- cgit v1.2.3