OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h" | 6 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h" |
7 | 7 |
8 #include "bindings/core/v8/ExceptionState.h" | 8 #include "bindings/core/v8/ExceptionState.h" |
9 #include "core/dom/ExceptionCode.h" | 9 #include "core/dom/ExceptionCode.h" |
10 #include "core/html/HTMLMediaElement.h" | 10 #include "core/html/HTMLMediaElement.h" |
11 #include "core/html/MediaKeyError.h" | 11 #include "core/html/MediaKeyError.h" |
12 #include "core/html/MediaKeyEvent.h" | 12 #include "core/html/MediaKeyEvent.h" |
13 #include "modules/encryptedmedia/MediaKeyNeededEvent.h" | 13 #include "modules/encryptedmedia/MediaKeyNeededEvent.h" |
14 #include "modules/encryptedmedia/MediaKeys.h" | 14 #include "modules/encryptedmedia/MediaKeys.h" |
15 #include "platform/Logging.h" | 15 #include "platform/Logging.h" |
16 #include "platform/RuntimeEnabledFeatures.h" | 16 #include "platform/RuntimeEnabledFeatures.h" |
17 #include "wtf/Uint8Array.h" | 17 #include "wtf/Uint8Array.h" |
18 | 18 |
19 namespace blink { | 19 namespace blink { |
20 | 20 |
21 static void throwExceptionIfMediaKeyExceptionOccurred(const String& keySystem, c
onst String& sessionId, blink::WebMediaPlayer::MediaKeyException exception, Exce
ptionState& exceptionState) | 21 static void throwExceptionIfMediaKeyExceptionOccurred(const String& keySystem, c
onst String& sessionId, WebMediaPlayer::MediaKeyException exception, ExceptionSt
ate& exceptionState) |
22 { | 22 { |
23 switch (exception) { | 23 switch (exception) { |
24 case blink::WebMediaPlayer::MediaKeyExceptionNoError: | 24 case WebMediaPlayer::MediaKeyExceptionNoError: |
25 return; | 25 return; |
26 case blink::WebMediaPlayer::MediaKeyExceptionInvalidPlayerState: | 26 case WebMediaPlayer::MediaKeyExceptionInvalidPlayerState: |
27 exceptionState.throwDOMException(InvalidStateError, "The player is in an
invalid state."); | 27 exceptionState.throwDOMException(InvalidStateError, "The player is in an
invalid state."); |
28 return; | 28 return; |
29 case blink::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported: | 29 case WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported: |
30 exceptionState.throwDOMException(NotSupportedError, "The key system prov
ided ('" + keySystem +"') is not supported."); | 30 exceptionState.throwDOMException(NotSupportedError, "The key system prov
ided ('" + keySystem +"') is not supported."); |
31 return; | 31 return; |
32 case blink::WebMediaPlayer::MediaKeyExceptionInvalidAccess: | 32 case WebMediaPlayer::MediaKeyExceptionInvalidAccess: |
33 exceptionState.throwDOMException(InvalidAccessError, "The session ID pro
vided ('" + sessionId + "') is invalid."); | 33 exceptionState.throwDOMException(InvalidAccessError, "The session ID pro
vided ('" + sessionId + "') is invalid."); |
34 return; | 34 return; |
35 } | 35 } |
36 | 36 |
37 ASSERT_NOT_REACHED(); | 37 ASSERT_NOT_REACHED(); |
38 return; | 38 return; |
39 } | 39 } |
40 | 40 |
41 HTMLMediaElementEncryptedMedia::HTMLMediaElementEncryptedMedia() | 41 HTMLMediaElementEncryptedMedia::HTMLMediaElementEncryptedMedia() |
42 : m_emeMode(EmeModeNotSelected) | 42 : m_emeMode(EmeModeNotSelected) |
(...skipping 20 matching lines...) Expand all Loading... |
63 bool HTMLMediaElementEncryptedMedia::setEmeMode(EmeMode emeMode, ExceptionState&
exceptionState) | 63 bool HTMLMediaElementEncryptedMedia::setEmeMode(EmeMode emeMode, ExceptionState&
exceptionState) |
64 { | 64 { |
65 if (m_emeMode != EmeModeNotSelected && m_emeMode != emeMode) { | 65 if (m_emeMode != EmeModeNotSelected && m_emeMode != emeMode) { |
66 exceptionState.throwDOMException(InvalidStateError, "Mixed use of EME pr
efixed and unprefixed API not allowed."); | 66 exceptionState.throwDOMException(InvalidStateError, "Mixed use of EME pr
efixed and unprefixed API not allowed."); |
67 return false; | 67 return false; |
68 } | 68 } |
69 m_emeMode = emeMode; | 69 m_emeMode = emeMode; |
70 return true; | 70 return true; |
71 } | 71 } |
72 | 72 |
73 blink::WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryp
tionModule() | 73 WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionMod
ule() |
74 { | 74 { |
75 return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0; | 75 return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0; |
76 } | 76 } |
77 | 77 |
78 MediaKeys* HTMLMediaElementEncryptedMedia::mediaKeys(HTMLMediaElement& element) | 78 MediaKeys* HTMLMediaElementEncryptedMedia::mediaKeys(HTMLMediaElement& element) |
79 { | 79 { |
80 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); | 80 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); |
81 return thisElement.m_mediaKeys.get(); | 81 return thisElement.m_mediaKeys.get(); |
82 } | 82 } |
83 | 83 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 webkitInitializer.cancelable = false; | 128 webkitInitializer.cancelable = false; |
129 | 129 |
130 return MediaKeyEvent::create(EventTypeNames::webkitneedkey, webkitInitialize
r); | 130 return MediaKeyEvent::create(EventTypeNames::webkitneedkey, webkitInitialize
r); |
131 } | 131 } |
132 | 132 |
133 void HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest(HTMLMediaElement&
element, const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionStat
e& exceptionState) | 133 void HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest(HTMLMediaElement&
element, const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionStat
e& exceptionState) |
134 { | 134 { |
135 HTMLMediaElementEncryptedMedia::from(element).generateKeyRequest(element.web
MediaPlayer(), keySystem, initData, exceptionState); | 135 HTMLMediaElementEncryptedMedia::from(element).generateKeyRequest(element.web
MediaPlayer(), keySystem, initData, exceptionState); |
136 } | 136 } |
137 | 137 |
138 void HTMLMediaElementEncryptedMedia::generateKeyRequest(blink::WebMediaPlayer* w
ebMediaPlayer, const String& keySystem, PassRefPtr<Uint8Array> initData, Excepti
onState& exceptionState) | 138 void HTMLMediaElementEncryptedMedia::generateKeyRequest(WebMediaPlayer* webMedia
Player, const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionState
& exceptionState) |
139 { | 139 { |
140 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest"); | 140 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest"); |
141 | 141 |
142 if (!setEmeMode(EmeModePrefixed, exceptionState)) | 142 if (!setEmeMode(EmeModePrefixed, exceptionState)) |
143 return; | 143 return; |
144 | 144 |
145 if (keySystem.isEmpty()) { | 145 if (keySystem.isEmpty()) { |
146 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); | 146 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); |
147 return; | 147 return; |
148 } | 148 } |
149 | 149 |
150 if (!webMediaPlayer) { | 150 if (!webMediaPlayer) { |
151 exceptionState.throwDOMException(InvalidStateError, "No media has been l
oaded."); | 151 exceptionState.throwDOMException(InvalidStateError, "No media has been l
oaded."); |
152 return; | 152 return; |
153 } | 153 } |
154 | 154 |
155 const unsigned char* initDataPointer = 0; | 155 const unsigned char* initDataPointer = 0; |
156 unsigned initDataLength = 0; | 156 unsigned initDataLength = 0; |
157 if (initData) { | 157 if (initData) { |
158 initDataPointer = initData->data(); | 158 initDataPointer = initData->data(); |
159 initDataLength = initData->length(); | 159 initDataLength = initData->length(); |
160 } | 160 } |
161 | 161 |
162 blink::WebMediaPlayer::MediaKeyException result = webMediaPlayer->generateKe
yRequest(keySystem, initDataPointer, initDataLength); | 162 WebMediaPlayer::MediaKeyException result = webMediaPlayer->generateKeyReques
t(keySystem, initDataPointer, initDataLength); |
163 throwExceptionIfMediaKeyExceptionOccurred(keySystem, String(), result, excep
tionState); | 163 throwExceptionIfMediaKeyExceptionOccurred(keySystem, String(), result, excep
tionState); |
164 } | 164 } |
165 | 165 |
166 void HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest(HTMLMediaElement&
mediaElement, const String& keySystem, ExceptionState& exceptionState) | 166 void HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest(HTMLMediaElement&
mediaElement, const String& keySystem, ExceptionState& exceptionState) |
167 { | 167 { |
168 webkitGenerateKeyRequest(mediaElement, keySystem, Uint8Array::create(0), exc
eptionState); | 168 webkitGenerateKeyRequest(mediaElement, keySystem, Uint8Array::create(0), exc
eptionState); |
169 } | 169 } |
170 | 170 |
171 void HTMLMediaElementEncryptedMedia::webkitAddKey(HTMLMediaElement& element, con
st String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initDat
a, const String& sessionId, ExceptionState& exceptionState) | 171 void HTMLMediaElementEncryptedMedia::webkitAddKey(HTMLMediaElement& element, con
st String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initDat
a, const String& sessionId, ExceptionState& exceptionState) |
172 { | 172 { |
173 HTMLMediaElementEncryptedMedia::from(element).addKey(element.webMediaPlayer(
), keySystem, key, initData, sessionId, exceptionState); | 173 HTMLMediaElementEncryptedMedia::from(element).addKey(element.webMediaPlayer(
), keySystem, key, initData, sessionId, exceptionState); |
174 } | 174 } |
175 | 175 |
176 void HTMLMediaElementEncryptedMedia::addKey(blink::WebMediaPlayer* webMediaPlaye
r, const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> i
nitData, const String& sessionId, ExceptionState& exceptionState) | 176 void HTMLMediaElementEncryptedMedia::addKey(WebMediaPlayer* webMediaPlayer, cons
t String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData
, const String& sessionId, ExceptionState& exceptionState) |
177 { | 177 { |
178 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitAddKey"); | 178 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitAddKey"); |
179 | 179 |
180 if (!setEmeMode(EmeModePrefixed, exceptionState)) | 180 if (!setEmeMode(EmeModePrefixed, exceptionState)) |
181 return; | 181 return; |
182 | 182 |
183 if (keySystem.isEmpty()) { | 183 if (keySystem.isEmpty()) { |
184 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); | 184 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); |
185 return; | 185 return; |
186 } | 186 } |
(...skipping 13 matching lines...) Expand all Loading... |
200 return; | 200 return; |
201 } | 201 } |
202 | 202 |
203 const unsigned char* initDataPointer = 0; | 203 const unsigned char* initDataPointer = 0; |
204 unsigned initDataLength = 0; | 204 unsigned initDataLength = 0; |
205 if (initData) { | 205 if (initData) { |
206 initDataPointer = initData->data(); | 206 initDataPointer = initData->data(); |
207 initDataLength = initData->length(); | 207 initDataLength = initData->length(); |
208 } | 208 } |
209 | 209 |
210 blink::WebMediaPlayer::MediaKeyException result = webMediaPlayer->addKey(key
System, key->data(), key->length(), initDataPointer, initDataLength, sessionId); | 210 WebMediaPlayer::MediaKeyException result = webMediaPlayer->addKey(keySystem,
key->data(), key->length(), initDataPointer, initDataLength, sessionId); |
211 throwExceptionIfMediaKeyExceptionOccurred(keySystem, sessionId, result, exce
ptionState); | 211 throwExceptionIfMediaKeyExceptionOccurred(keySystem, sessionId, result, exce
ptionState); |
212 } | 212 } |
213 | 213 |
214 void HTMLMediaElementEncryptedMedia::webkitAddKey(HTMLMediaElement& mediaElement
, const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionState& exception
State) | 214 void HTMLMediaElementEncryptedMedia::webkitAddKey(HTMLMediaElement& mediaElement
, const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionState& exception
State) |
215 { | 215 { |
216 webkitAddKey(mediaElement, keySystem, key, Uint8Array::create(0), String(),
exceptionState); | 216 webkitAddKey(mediaElement, keySystem, key, Uint8Array::create(0), String(),
exceptionState); |
217 } | 217 } |
218 | 218 |
219 void HTMLMediaElementEncryptedMedia::webkitCancelKeyRequest(HTMLMediaElement& el
ement, const String& keySystem, const String& sessionId, ExceptionState& excepti
onState) | 219 void HTMLMediaElementEncryptedMedia::webkitCancelKeyRequest(HTMLMediaElement& el
ement, const String& keySystem, const String& sessionId, ExceptionState& excepti
onState) |
220 { | 220 { |
221 HTMLMediaElementEncryptedMedia::from(element).cancelKeyRequest(element.webMe
diaPlayer(), keySystem, sessionId, exceptionState); | 221 HTMLMediaElementEncryptedMedia::from(element).cancelKeyRequest(element.webMe
diaPlayer(), keySystem, sessionId, exceptionState); |
222 } | 222 } |
223 | 223 |
224 void HTMLMediaElementEncryptedMedia::cancelKeyRequest(blink::WebMediaPlayer* web
MediaPlayer, const String& keySystem, const String& sessionId, ExceptionState& e
xceptionState) | 224 void HTMLMediaElementEncryptedMedia::cancelKeyRequest(WebMediaPlayer* webMediaPl
ayer, const String& keySystem, const String& sessionId, ExceptionState& exceptio
nState) |
225 { | 225 { |
226 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitCancelKeyRequest"); | 226 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitCancelKeyRequest"); |
227 | 227 |
228 if (!setEmeMode(EmeModePrefixed, exceptionState)) | 228 if (!setEmeMode(EmeModePrefixed, exceptionState)) |
229 return; | 229 return; |
230 | 230 |
231 if (keySystem.isEmpty()) { | 231 if (keySystem.isEmpty()) { |
232 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); | 232 exceptionState.throwDOMException(SyntaxError, "The key system provided i
s empty."); |
233 return; | 233 return; |
234 } | 234 } |
235 | 235 |
236 if (!webMediaPlayer) { | 236 if (!webMediaPlayer) { |
237 exceptionState.throwDOMException(InvalidStateError, "No media has been l
oaded."); | 237 exceptionState.throwDOMException(InvalidStateError, "No media has been l
oaded."); |
238 return; | 238 return; |
239 } | 239 } |
240 | 240 |
241 blink::WebMediaPlayer::MediaKeyException result = webMediaPlayer->cancelKeyR
equest(keySystem, sessionId); | 241 WebMediaPlayer::MediaKeyException result = webMediaPlayer->cancelKeyRequest(
keySystem, sessionId); |
242 throwExceptionIfMediaKeyExceptionOccurred(keySystem, sessionId, result, exce
ptionState); | 242 throwExceptionIfMediaKeyExceptionOccurred(keySystem, sessionId, result, exce
ptionState); |
243 } | 243 } |
244 | 244 |
245 void HTMLMediaElementEncryptedMedia::keyAdded(HTMLMediaElement& element, const S
tring& keySystem, const String& sessionId) | 245 void HTMLMediaElementEncryptedMedia::keyAdded(HTMLMediaElement& element, const S
tring& keySystem, const String& sessionId) |
246 { | 246 { |
247 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyAdded"); | 247 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyAdded"); |
248 | 248 |
249 MediaKeyEventInit initializer; | 249 MediaKeyEventInit initializer; |
250 initializer.keySystem = keySystem; | 250 initializer.keySystem = keySystem; |
251 initializer.sessionId = sessionId; | 251 initializer.sessionId = sessionId; |
252 initializer.bubbles = false; | 252 initializer.bubbles = false; |
253 initializer.cancelable = false; | 253 initializer.cancelable = false; |
254 | 254 |
255 RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webk
itkeyadded, initializer); | 255 RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webk
itkeyadded, initializer); |
256 event->setTarget(&element); | 256 event->setTarget(&element); |
257 element.scheduleEvent(event.release()); | 257 element.scheduleEvent(event.release()); |
258 } | 258 } |
259 | 259 |
260 void HTMLMediaElementEncryptedMedia::keyError(HTMLMediaElement& element, const S
tring& keySystem, const String& sessionId, blink::WebMediaPlayerClient::MediaKey
ErrorCode errorCode, unsigned short systemCode) | 260 void HTMLMediaElementEncryptedMedia::keyError(HTMLMediaElement& element, const S
tring& keySystem, const String& sessionId, WebMediaPlayerClient::MediaKeyErrorCo
de errorCode, unsigned short systemCode) |
261 { | 261 { |
262 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyError: session
ID=%s, errorCode=%d, systemCode=%d", sessionId.utf8().data(), errorCode, systemC
ode); | 262 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyError: session
ID=%s, errorCode=%d, systemCode=%d", sessionId.utf8().data(), errorCode, systemC
ode); |
263 | 263 |
264 MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN; | 264 MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN; |
265 switch (errorCode) { | 265 switch (errorCode) { |
266 case blink::WebMediaPlayerClient::MediaKeyErrorCodeUnknown: | 266 case WebMediaPlayerClient::MediaKeyErrorCodeUnknown: |
267 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN; | 267 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN; |
268 break; | 268 break; |
269 case blink::WebMediaPlayerClient::MediaKeyErrorCodeClient: | 269 case WebMediaPlayerClient::MediaKeyErrorCodeClient: |
270 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_CLIENT; | 270 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_CLIENT; |
271 break; | 271 break; |
272 case blink::WebMediaPlayerClient::MediaKeyErrorCodeService: | 272 case WebMediaPlayerClient::MediaKeyErrorCodeService: |
273 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_SERVICE; | 273 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_SERVICE; |
274 break; | 274 break; |
275 case blink::WebMediaPlayerClient::MediaKeyErrorCodeOutput: | 275 case WebMediaPlayerClient::MediaKeyErrorCodeOutput: |
276 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_OUTPUT; | 276 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_OUTPUT; |
277 break; | 277 break; |
278 case blink::WebMediaPlayerClient::MediaKeyErrorCodeHardwareChange: | 278 case WebMediaPlayerClient::MediaKeyErrorCodeHardwareChange: |
279 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_HARDWARECHANGE; | 279 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_HARDWARECHANGE; |
280 break; | 280 break; |
281 case blink::WebMediaPlayerClient::MediaKeyErrorCodeDomain: | 281 case WebMediaPlayerClient::MediaKeyErrorCodeDomain: |
282 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_DOMAIN; | 282 mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_DOMAIN; |
283 break; | 283 break; |
284 } | 284 } |
285 | 285 |
286 MediaKeyEventInit initializer; | 286 MediaKeyEventInit initializer; |
287 initializer.keySystem = keySystem; | 287 initializer.keySystem = keySystem; |
288 initializer.sessionId = sessionId; | 288 initializer.sessionId = sessionId; |
289 initializer.errorCode = MediaKeyError::create(mediaKeyErrorCode); | 289 initializer.errorCode = MediaKeyError::create(mediaKeyErrorCode); |
290 initializer.systemCode = systemCode; | 290 initializer.systemCode = systemCode; |
291 initializer.bubbles = false; | 291 initializer.bubbles = false; |
292 initializer.cancelable = false; | 292 initializer.cancelable = false; |
293 | 293 |
294 RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webk
itkeyerror, initializer); | 294 RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webk
itkeyerror, initializer); |
295 event->setTarget(&element); | 295 event->setTarget(&element); |
296 element.scheduleEvent(event.release()); | 296 element.scheduleEvent(event.release()); |
297 } | 297 } |
298 | 298 |
299 void HTMLMediaElementEncryptedMedia::keyMessage(HTMLMediaElement& element, const
String& keySystem, const String& sessionId, const unsigned char* message, unsig
ned messageLength, const blink::WebURL& defaultURL) | 299 void HTMLMediaElementEncryptedMedia::keyMessage(HTMLMediaElement& element, const
String& keySystem, const String& sessionId, const unsigned char* message, unsig
ned messageLength, const WebURL& defaultURL) |
300 { | 300 { |
301 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyMessage: sessi
onID=%s", sessionId.utf8().data()); | 301 WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyMessage: sessi
onID=%s", sessionId.utf8().data()); |
302 | 302 |
303 MediaKeyEventInit initializer; | 303 MediaKeyEventInit initializer; |
304 initializer.keySystem = keySystem; | 304 initializer.keySystem = keySystem; |
305 initializer.sessionId = sessionId; | 305 initializer.sessionId = sessionId; |
306 initializer.message = Uint8Array::create(message, messageLength); | 306 initializer.message = Uint8Array::create(message, messageLength); |
307 initializer.defaultURL = KURL(defaultURL); | 307 initializer.defaultURL = KURL(defaultURL); |
308 initializer.bubbles = false; | 308 initializer.bubbles = false; |
309 initializer.cancelable = false; | 309 initializer.cancelable = false; |
(...skipping 27 matching lines...) Expand all Loading... |
337 #if ENABLE(OILPAN) | 337 #if ENABLE(OILPAN) |
338 // FIXME: Oilpan: remove this once the media player is on the heap. crbug.co
m/378229 | 338 // FIXME: Oilpan: remove this once the media player is on the heap. crbug.co
m/378229 |
339 if (element.isFinalizing()) | 339 if (element.isFinalizing()) |
340 return; | 340 return; |
341 #endif | 341 #endif |
342 | 342 |
343 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); | 343 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); |
344 thisElement.setMediaKeysInternal(element, 0); | 344 thisElement.setMediaKeysInternal(element, 0); |
345 } | 345 } |
346 | 346 |
347 blink::WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryp
tionModule(HTMLMediaElement& element) | 347 WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionMod
ule(HTMLMediaElement& element) |
348 { | 348 { |
349 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); | 349 HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia
::from(element); |
350 return thisElement.contentDecryptionModule(); | 350 return thisElement.contentDecryptionModule(); |
351 } | 351 } |
352 | 352 |
353 void HTMLMediaElementEncryptedMedia::trace(Visitor* visitor) | 353 void HTMLMediaElementEncryptedMedia::trace(Visitor* visitor) |
354 { | 354 { |
355 visitor->trace(m_mediaKeys); | 355 visitor->trace(m_mediaKeys); |
356 WillBeHeapSupplement<HTMLMediaElement>::trace(visitor); | 356 WillBeHeapSupplement<HTMLMediaElement>::trace(visitor); |
357 } | 357 } |
358 | 358 |
359 } // namespace blink | 359 } // namespace blink |
OLD | NEW |