/src/mozilla-central/dom/media/gmp/ChromiumCDMCallbackProxy.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "ChromiumCDMCallbackProxy.h"

#include "ChromiumCDMProxy.h"
#include "content_decryption_module.h"

namespace mozilla {

template<class Func, class... Args>
void ChromiumCDMCallbackProxy::DispatchToMainThread(const char* const aLabel,
                                                    Func aFunc,
                                                    Args&&... aArgs)
{
  mMainThread->Dispatch(
    // Use Decay to ensure all the types are passed by value not by reference.
    NewRunnableMethod<typename Decay<Args>::Type...>(
      aLabel,
      mProxy,
      aFunc,
      std::forward<Args>(aArgs)...),
    NS_DISPATCH_NORMAL);
}

void
ChromiumCDMCallbackProxy::SetSessionId(uint32_t aPromiseId,
                                       const nsCString& aSessionId)
{
  DispatchToMainThread("ChromiumCDMProxy::OnSetSessionId",
                       &ChromiumCDMProxy::OnSetSessionId,
                       aPromiseId,
                       NS_ConvertUTF8toUTF16(aSessionId));
}

void
ChromiumCDMCallbackProxy::ResolveLoadSessionPromise(uint32_t aPromiseId,
                                                    bool aSuccessful)
{
  DispatchToMainThread("ChromiumCDMProxy::OnResolveLoadSessionPromise",
                       &ChromiumCDMProxy::OnResolveLoadSessionPromise,
                       aPromiseId,
                       aSuccessful);
}

void
ChromiumCDMCallbackProxy::ResolvePromise(uint32_t aPromiseId)
{
  DispatchToMainThread("ChromiumCDMProxy::ResolvePromise",
                       &ChromiumCDMProxy::ResolvePromise,
                       aPromiseId);
}

void
ChromiumCDMCallbackProxy::RejectPromise(uint32_t aPromiseId,
                                        nsresult aException,
                                        const nsCString& aErrorMessage)
{
  DispatchToMainThread("ChromiumCDMProxy::RejectPromise",
                       &ChromiumCDMProxy::RejectPromise,
                       aPromiseId,
                       aException,
                       aErrorMessage);
}


static dom::MediaKeyMessageType
ToDOMMessageType(uint32_t aMessageType)
{
  switch (static_cast<cdm::MessageType>(aMessageType)) {
    case cdm::kLicenseRequest:
      return dom::MediaKeyMessageType::License_request;
    case cdm::kLicenseRenewal:
      return dom::MediaKeyMessageType::License_renewal;
    case cdm::kLicenseRelease:
      return dom::MediaKeyMessageType::License_release;
    case cdm::kIndividualizationRequest:
      return dom::MediaKeyMessageType::Individualization_request;
  }
  MOZ_ASSERT_UNREACHABLE("Invalid cdm::MessageType enum value.");
  return dom::MediaKeyMessageType::License_request;
}

void
ChromiumCDMCallbackProxy::SessionMessage(const nsACString& aSessionId,
                                         uint32_t aMessageType,
                                         nsTArray<uint8_t>&& aMessage)
{
  DispatchToMainThread("ChromiumCDMProxy::OnSessionMessage",
                       &ChromiumCDMProxy::OnSessionMessage,
                       NS_ConvertUTF8toUTF16(aSessionId),
                       ToDOMMessageType(aMessageType),
                       std::move(aMessage));
}

static dom::MediaKeyStatus
ToDOMMediaKeyStatus(uint32_t aStatus)
{
  switch (static_cast<cdm::KeyStatus>(aStatus)) {
    case cdm::kUsable:
      return dom::MediaKeyStatus::Usable;
    case cdm::kInternalError:
      return dom::MediaKeyStatus::Internal_error;
    case cdm::kExpired:
      return dom::MediaKeyStatus::Expired;
    case cdm::kOutputRestricted:
      return dom::MediaKeyStatus::Output_restricted;
    case cdm::kOutputDownscaled:
      return dom::MediaKeyStatus::Output_downscaled;
    case cdm::kStatusPending:
      return dom::MediaKeyStatus::Status_pending;
    case cdm::kReleased:
      return dom::MediaKeyStatus::Released;
  }
  MOZ_ASSERT_UNREACHABLE("Invalid cdm::KeyStatus enum value.");
  return dom::MediaKeyStatus::Internal_error;
}

void
ChromiumCDMCallbackProxy::ResolvePromiseWithKeyStatus(uint32_t aPromiseId,
                                                      uint32_t aKeyStatus)
{
  DispatchToMainThread("ChromiumCDMProxy::OnResolvePromiseWithKeyStatus",
                       &ChromiumCDMProxy::OnResolvePromiseWithKeyStatus,
                       aPromiseId,
                       ToDOMMediaKeyStatus(aKeyStatus));
}

void
ChromiumCDMCallbackProxy::SessionKeysChange(const nsCString& aSessionId,
                                            nsTArray<mozilla::gmp::CDMKeyInformation> && aKeysInfo)
{
  bool keyStatusesChange = false;
  {
    auto caps = mProxy->Capabilites().Lock();
    for (const auto& keyInfo : aKeysInfo) {
      keyStatusesChange |=
        caps->SetKeyStatus(keyInfo.mKeyId(),
                           NS_ConvertUTF8toUTF16(aSessionId),
                           dom::Optional<dom::MediaKeyStatus>(
                             ToDOMMediaKeyStatus(keyInfo.mStatus())));
    }
  }
  if (keyStatusesChange) {
    DispatchToMainThread("ChromiumCDMProxy::OnKeyStatusesChange",
                         &ChromiumCDMProxy::OnKeyStatusesChange,
                         NS_ConvertUTF8toUTF16(aSessionId));
  }
}

void
ChromiumCDMCallbackProxy::ExpirationChange(const nsCString& aSessionId,
                                           double aSecondsSinceEpoch)
{
  DispatchToMainThread("ChromiumCDMProxy::OnExpirationChange",
                       &ChromiumCDMProxy::OnExpirationChange,
                       NS_ConvertUTF8toUTF16(aSessionId),
                       UnixTime(aSecondsSinceEpoch * 1000));

}

void
ChromiumCDMCallbackProxy::SessionClosed(const nsCString& aSessionId)
{
  DispatchToMainThread("ChromiumCDMProxy::OnSessionClosed",
                       &ChromiumCDMProxy::OnSessionClosed ,
                       NS_ConvertUTF8toUTF16(aSessionId));
}

void
ChromiumCDMCallbackProxy::Terminated()
{
  DispatchToMainThread("ChromiumCDMProxy::Terminated",
                       &ChromiumCDMProxy::Terminated);
}

void
ChromiumCDMCallbackProxy::Shutdown()
{
  DispatchToMainThread("ChromiumCDMProxy::Shutdown",
                       &ChromiumCDMProxy::Shutdown);
}

} //namespace mozilla

Line	Count	Source (jump to first uncovered line)
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 "ChromiumCDMProxy.h"
9		#include "content_decryption_module.h"
10
11		namespace mozilla {
12
13		template<class Func, class... Args>
14		void ChromiumCDMCallbackProxy::DispatchToMainThread(const char* const aLabel,
15		Func aFunc,
16		Args&&... aArgs)
17	0	{
18	0	mMainThread->Dispatch(
19	0	// Use Decay to ensure all the types are passed by value not by reference.
20	0	NewRunnableMethod<typename Decay<Args>::Type...>(
21	0	aLabel,
22	0	mProxy,
23	0	aFunc,
24	0	std::forward<Args>(aArgs)...),
25	0	NS_DISPATCH_NORMAL);
26	0	} Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(unsigned int, nsTSubstring<char16_t> const&), unsigned int&, NS_ConvertUTF8toUTF16>(char const, void (mozilla::ChromiumCDMProxy::)(unsigned int, nsTSubstring<char16_t> const&), unsigned int&, NS_ConvertUTF8toUTF16&&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(unsigned int, bool), unsigned int&, bool&>(char const, void (mozilla::ChromiumCDMProxy::)(unsigned int, bool), unsigned int&, bool&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(unsigned int), unsigned int&>(char const, void (mozilla::ChromiumCDMProxy::)(unsigned int), unsigned int&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(unsigned int, nsresult, nsTString<char> const&), unsigned int&, nsresult&, nsTString<char> const&>(char const, void (mozilla::ChromiumCDMProxy::)(unsigned int, nsresult, nsTString<char> const&), unsigned int&, nsresult&, nsTString<char> const&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&, mozilla::dom::MediaKeyMessageType, nsTArray<unsigned char> const&), NS_ConvertUTF8toUTF16, mozilla::dom::MediaKeyMessageType, nsTArray<unsigned char> >(char const, void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&, mozilla::dom::MediaKeyMessageType, nsTArray<unsigned char> const&), NS_ConvertUTF8toUTF16&&, mozilla::dom::MediaKeyMessageType&&, nsTArray<unsigned char>&&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(unsigned int, mozilla::dom::MediaKeyStatus), unsigned int&, mozilla::dom::MediaKeyStatus>(char const, void (mozilla::ChromiumCDMProxy::)(unsigned int, mozilla::dom::MediaKeyStatus), unsigned int&, mozilla::dom::MediaKeyStatus&&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&), NS_ConvertUTF8toUTF16>(char const, void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&), NS_ConvertUTF8toUTF16&&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&, long), NS_ConvertUTF8toUTF16, long>(char const, void (mozilla::ChromiumCDMProxy::)(nsTSubstring<char16_t> const&, long), NS_ConvertUTF8toUTF16&&, long&&) Unexecuted instantiation: void mozilla::ChromiumCDMCallbackProxy::DispatchToMainThread<void (mozilla::ChromiumCDMProxy::)()>(char const, void (mozilla::ChromiumCDMProxy::*)())
27
28		void
29		ChromiumCDMCallbackProxy::SetSessionId(uint32_t aPromiseId,
30		const nsCString& aSessionId)
31	0	{
32	0	DispatchToMainThread("ChromiumCDMProxy::OnSetSessionId",
33	0	&ChromiumCDMProxy::OnSetSessionId,
34	0	aPromiseId,
35	0	NS_ConvertUTF8toUTF16(aSessionId));
36	0	}
37
38		void
39		ChromiumCDMCallbackProxy::ResolveLoadSessionPromise(uint32_t aPromiseId,
40		bool aSuccessful)
41	0	{
42	0	DispatchToMainThread("ChromiumCDMProxy::OnResolveLoadSessionPromise",
43	0	&ChromiumCDMProxy::OnResolveLoadSessionPromise,
44	0	aPromiseId,
45	0	aSuccessful);
46	0	}
47
48		void
49		ChromiumCDMCallbackProxy::ResolvePromise(uint32_t aPromiseId)
50	0	{
51	0	DispatchToMainThread("ChromiumCDMProxy::ResolvePromise",
52	0	&ChromiumCDMProxy::ResolvePromise,
53	0	aPromiseId);
54	0	}
55
56		void
57		ChromiumCDMCallbackProxy::RejectPromise(uint32_t aPromiseId,
58		nsresult aException,
59		const nsCString& aErrorMessage)
60	0	{
61	0	DispatchToMainThread("ChromiumCDMProxy::RejectPromise",
62	0	&ChromiumCDMProxy::RejectPromise,
63	0	aPromiseId,
64	0	aException,
65	0	aErrorMessage);
66	0	}
67
68
69		static dom::MediaKeyMessageType
70		ToDOMMessageType(uint32_t aMessageType)
71	0	{
72	0	switch (static_cast<cdm::MessageType>(aMessageType)) {
73	0	case cdm::kLicenseRequest:
74	0	return dom::MediaKeyMessageType::License_request;
75	0	case cdm::kLicenseRenewal:
76	0	return dom::MediaKeyMessageType::License_renewal;
77	0	case cdm::kLicenseRelease:
78	0	return dom::MediaKeyMessageType::License_release;
79	0	case cdm::kIndividualizationRequest:
80	0	return dom::MediaKeyMessageType::Individualization_request;
81	0	}
82	0	MOZ_ASSERT_UNREACHABLE("Invalid cdm::MessageType enum value.");
83	0	return dom::MediaKeyMessageType::License_request;
84	0	}
85
86		void
87		ChromiumCDMCallbackProxy::SessionMessage(const nsACString& aSessionId,
88		uint32_t aMessageType,
89		nsTArray<uint8_t>&& aMessage)
90	0	{
91	0	DispatchToMainThread("ChromiumCDMProxy::OnSessionMessage",
92	0	&ChromiumCDMProxy::OnSessionMessage,
93	0	NS_ConvertUTF8toUTF16(aSessionId),
94	0	ToDOMMessageType(aMessageType),
95	0	std::move(aMessage));
96	0	}
97
98		static dom::MediaKeyStatus
99		ToDOMMediaKeyStatus(uint32_t aStatus)
100	0	{
101	0	switch (static_cast<cdm::KeyStatus>(aStatus)) {
102	0	case cdm::kUsable:
103	0	return dom::MediaKeyStatus::Usable;
104	0	case cdm::kInternalError:
105	0	return dom::MediaKeyStatus::Internal_error;
106	0	case cdm::kExpired:
107	0	return dom::MediaKeyStatus::Expired;
108	0	case cdm::kOutputRestricted:
109	0	return dom::MediaKeyStatus::Output_restricted;
110	0	case cdm::kOutputDownscaled:
111	0	return dom::MediaKeyStatus::Output_downscaled;
112	0	case cdm::kStatusPending:
113	0	return dom::MediaKeyStatus::Status_pending;
114	0	case cdm::kReleased:
115	0	return dom::MediaKeyStatus::Released;
116	0	}
117	0	MOZ_ASSERT_UNREACHABLE("Invalid cdm::KeyStatus enum value.");
118	0	return dom::MediaKeyStatus::Internal_error;
119	0	}
120
121		void
122		ChromiumCDMCallbackProxy::ResolvePromiseWithKeyStatus(uint32_t aPromiseId,
123		uint32_t aKeyStatus)
124	0	{
125	0	DispatchToMainThread("ChromiumCDMProxy::OnResolvePromiseWithKeyStatus",
126	0	&ChromiumCDMProxy::OnResolvePromiseWithKeyStatus,
127	0	aPromiseId,
128	0	ToDOMMediaKeyStatus(aKeyStatus));
129	0	}
130
131		void
132		ChromiumCDMCallbackProxy::SessionKeysChange(const nsCString& aSessionId,
133		nsTArray<mozilla::gmp::CDMKeyInformation> && aKeysInfo)
134	0	{
135	0	bool keyStatusesChange = false;
136	0	{
137	0	auto caps = mProxy->Capabilites().Lock();
138	0	for (const auto& keyInfo : aKeysInfo) {
139	0	keyStatusesChange \|=
140	0	caps->SetKeyStatus(keyInfo.mKeyId(),
141	0	NS_ConvertUTF8toUTF16(aSessionId),
142	0	dom::Optional<dom::MediaKeyStatus>(
143	0	ToDOMMediaKeyStatus(keyInfo.mStatus())));
144	0	}
145	0	}
146	0	if (keyStatusesChange) {
147	0	DispatchToMainThread("ChromiumCDMProxy::OnKeyStatusesChange",
148	0	&ChromiumCDMProxy::OnKeyStatusesChange,
149	0	NS_ConvertUTF8toUTF16(aSessionId));
150	0	}
151	0	}
152
153		void
154		ChromiumCDMCallbackProxy::ExpirationChange(const nsCString& aSessionId,
155		double aSecondsSinceEpoch)
156	0	{
157	0	DispatchToMainThread("ChromiumCDMProxy::OnExpirationChange",
158	0	&ChromiumCDMProxy::OnExpirationChange,
159	0	NS_ConvertUTF8toUTF16(aSessionId),
160	0	UnixTime(aSecondsSinceEpoch * 1000));
161	0
162	0	}
163
164		void
165		ChromiumCDMCallbackProxy::SessionClosed(const nsCString& aSessionId)
166	0	{
167	0	DispatchToMainThread("ChromiumCDMProxy::OnSessionClosed",
168	0	&ChromiumCDMProxy::OnSessionClosed ,
169	0	NS_ConvertUTF8toUTF16(aSessionId));
170	0	}
171
172		void
173		ChromiumCDMCallbackProxy::Terminated()
174	0	{
175	0	DispatchToMainThread("ChromiumCDMProxy::Terminated",
176	0	&ChromiumCDMProxy::Terminated);
177	0	}
178
179		void
180		ChromiumCDMCallbackProxy::Shutdown()
181	0	{
182	0	DispatchToMainThread("ChromiumCDMProxy::Shutdown",
183	0	&ChromiumCDMProxy::Shutdown);
184	0	}
185
186		} //namespace mozilla

Coverage Report

Created: 2018-09-25 14:53