Source/core/html/HTMLMediaElement.cpp - Issue 157423003: Remove the dependency on encryptedmedia from HTMLMediaElement.

Unified Diff: Source/core/html/HTMLMediaElement.cpp

Issue 157423003: Remove the dependency on encryptedmedia from HTMLMediaElement. (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: Address ddorwin's review comments. Created 6 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments.

Jump to:

View side-by-side diff with in-line comments

« Source/core/html/HTMLMediaElement.h ('K') | « Source/core/html/HTMLMediaElement.h ('k') | Source/core/html/HTMLMediaElement.idl » ('j') | Source/modules/encryptedmedia/HTMLMediaElementEncryptedMedia.cpp » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: Source/core/html/HTMLMediaElement.cpp

diff --git a/Source/core/html/HTMLMediaElement.cpp b/Source/core/html/HTMLMediaElement.cpp

index cec3e8f28f9a7b68d9fdd7a07390770f9473bf65..27068e630e3f06cda9735cb477c1c8cb5e7ca31a 100644

--- a/Source/core/html/HTMLMediaElement.cpp

+++ b/Source/core/html/HTMLMediaElement.cpp

@@ -50,8 +50,6 @@

#include "core/html/MediaController.h"

#include "core/html/MediaError.h"

#include "core/html/MediaFragmentURIParser.h"

-#include "core/html/MediaKeyError.h"

-#include "core/html/MediaKeyEvent.h"

#include "core/html/TimeRanges.h"

#include "core/html/shadow/MediaControls.h"

#include "core/html/track/InbandTextTrack.h"

@@ -61,9 +59,6 @@

#include "core/rendering/RenderLayerCompositor.h"

#include "core/rendering/RenderVideo.h"

#include "core/rendering/RenderView.h"

-// FIXME: Remove dependency on modules/encryptedmedia (http://crbug.com/242754).

-#include "modules/encryptedmedia/MediaKeyNeededEvent.h"

-#include "modules/encryptedmedia/MediaKeys.h"

#include "platform/ContentType.h"

#include "platform/Language.h"

#include "platform/Logging.h"

@@ -151,26 +146,6 @@ static void removeElementFromDocumentMap(HTMLMediaElement* element, Document* do

map.add(document, set);

}

-static void throwExceptionForMediaKeyException(const String& keySystem, const String& sessionId, MediaPlayer::MediaKeyException exception, ExceptionState& exceptionState)

- switch (exception) {

- case MediaPlayer::NoError:

- return;

- case MediaPlayer::InvalidPlayerState:

- exceptionState.throwDOMException(InvalidStateError, "The player is in an invalid state.");

- return;

- case MediaPlayer::KeySystemNotSupported:

- exceptionState.throwDOMException(NotSupportedError, "The key system provided ('" + keySystem +"') is not supported.");

- return;

- case MediaPlayer::InvalidAccess:

- exceptionState.throwDOMException(InvalidAccessError, "The session ID provided ('" + sessionId + "') is invalid.");

- return;

- }

- ASSERT_NOT_REACHED();

- return;

class TrackDisplayUpdateScope {

public:

TrackDisplayUpdateScope(HTMLMediaElement* mediaElement)

@@ -307,7 +282,6 @@ HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document& docum

#if ENABLE(WEB_AUDIO)

, m_audioSourceNode(0)

#endif

- , m_emeMode(EmeModeNotSelected)

{

ASSERT(RuntimeEnabledFeatures::mediaEnabled());

@@ -349,8 +323,6 @@ HTMLMediaElement::~HTMLMediaElement()

closeMediaSource();

- setMediaKeysInternal(0);

removeElementFromDocumentMap(this, &document());

// Destroying the player may cause a resource load to be canceled,

@@ -549,12 +521,17 @@ void HTMLMediaElement::scheduleNextSourceChild()

m_loadTimer.startOneShot(0);

}

-void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)

+void HTMLMediaElement::scheduleNamedEvent(const AtomicString& eventName)

ddorwin 2014/03/01 01:08:48 Thank you for changing the name, but this introduc

c.shu 2014/03/02 15:35:06 Done.

+ scheduleEvent(Event::createCancelable(eventName));

+void HTMLMediaElement::scheduleEvent(PassRefPtr<Event> event)

{

#if LOG_MEDIA_EVENTS

- WTF_LOG(Media, "HTMLMediaElement::scheduleEvent - scheduling '%s'", eventName.ascii().data());

+ WTF_LOG(Media, "HTMLMediaElement::scheduleEvent - scheduling '%s'", event->type().ascii().data());

#endif

- m_asyncEventQueue->enqueueEvent(Event::createCancelable(eventName));

+ m_asyncEventQueue->enqueueEvent(event);

}

void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)

@@ -655,7 +632,7 @@ void HTMLMediaElement::prepareForLoad()

// 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue

// a task to fire a simple event named abort at the media element.

if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)

- scheduleEvent(EventTypeNames::abort);

+ scheduleNamedEvent(EventTypeNames::abort);

closeMediaSource();

@@ -670,7 +647,7 @@ void HTMLMediaElement::prepareForLoad()

m_paused = true;

m_seeking = false;

invalidateCachedTime();

- scheduleEvent(EventTypeNames::emptied);

+ scheduleNamedEvent(EventTypeNames::emptied);

updateMediaController();

if (RuntimeEnabledFeatures::videoTrackEnabled())

updateActiveTextTrackCues(0);

@@ -769,7 +746,7 @@ void HTMLMediaElement::selectMediaResource()

m_networkState = NETWORK_LOADING;

// 5 - Queue a task to fire a simple event named loadstart at the media element.

- scheduleEvent(EventTypeNames::loadstart);

+ scheduleNamedEvent(EventTypeNames::loadstart);

// 6 - If mode is attribute, then run these substeps

if (mode == attribute) {

@@ -1369,7 +1346,7 @@ void HTMLMediaElement::noneSupported()

m_networkState = NETWORK_NO_SOURCE;

// 7 - Queue a task to fire a simple event named error at the media element.

- scheduleEvent(EventTypeNames::error);

+ scheduleNamedEvent(EventTypeNames::error);

closeMediaSource();

@@ -1398,14 +1375,14 @@ void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)

m_error = err;

// 3 - Queue a task to fire a simple event named error at the media element.

- scheduleEvent(EventTypeNames::error);

+ scheduleNamedEvent(EventTypeNames::error);

closeMediaSource();

// 4 - Set the element's networkState attribute to the NETWORK_EMPTY value and queue a

// task to fire a simple event called emptied at the element.

m_networkState = NETWORK_EMPTY;

- scheduleEvent(EventTypeNames::emptied);

+ scheduleNamedEvent(EventTypeNames::emptied);

// 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.

setShouldDelayLoadEvent(false);

@@ -1511,8 +1488,8 @@ void HTMLMediaElement::changeNetworkStateFromLoadingToIdle()

// Schedule one last progress event so we guarantee that at least one is fired

// for files that load very quickly.

- scheduleEvent(EventTypeNames::progress);

- scheduleEvent(EventTypeNames::suspend);

+ scheduleNamedEvent(EventTypeNames::progress);

+ scheduleNamedEvent(EventTypeNames::suspend);

m_networkState = NETWORK_IDLE;

}

@@ -1560,7 +1537,7 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)

// it started seeking, but seeking caused its readyState attribute to change to a value

// lower than HAVE_FUTURE_DATA, then a waiting will be fired at the element.

if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA)

- scheduleEvent(EventTypeNames::waiting);

+ scheduleNamedEvent(EventTypeNames::waiting);

// 4.8.10.9 steps 12-14

if (m_readyState >= HAVE_CURRENT_DATA)

@@ -1569,16 +1546,16 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)

if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA) {

// 4.8.10.8

scheduleTimeupdateEvent(false);

- scheduleEvent(EventTypeNames::waiting);

+ scheduleNamedEvent(EventTypeNames::waiting);

}

if (m_readyState >= HAVE_METADATA && oldState < HAVE_METADATA) {

prepareMediaFragmentURI();

- scheduleEvent(EventTypeNames::durationchange);

+ scheduleNamedEvent(EventTypeNames::durationchange);

if (isVideo())

- scheduleEvent(EventTypeNames::resize);

- scheduleEvent(EventTypeNames::loadedmetadata);

+ scheduleNamedEvent(EventTypeNames::resize);

+ scheduleNamedEvent(EventTypeNames::loadedmetadata);

if (hasMediaControls())

mediaControls()->reset();

if (renderer())

@@ -1590,34 +1567,34 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)

if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {

m_haveFiredLoadedData = true;

shouldUpdateDisplayState = true;

- scheduleEvent(EventTypeNames::loadeddata);

+ scheduleNamedEvent(EventTypeNames::loadeddata);

setShouldDelayLoadEvent(false);

applyMediaFragmentURI();

}

bool isPotentiallyPlaying = potentiallyPlaying();

if (m_readyState == HAVE_FUTURE_DATA && oldState <= HAVE_CURRENT_DATA && tracksAreReady) {

- scheduleEvent(EventTypeNames::canplay);

+ scheduleNamedEvent(EventTypeNames::canplay);

if (isPotentiallyPlaying)

- scheduleEvent(EventTypeNames::playing);

+ scheduleNamedEvent(EventTypeNames::playing);

shouldUpdateDisplayState = true;

}

if (m_readyState == HAVE_ENOUGH_DATA && oldState < HAVE_ENOUGH_DATA && tracksAreReady) {

if (oldState <= HAVE_CURRENT_DATA) {

- scheduleEvent(EventTypeNames::canplay);

+ scheduleNamedEvent(EventTypeNames::canplay);

if (isPotentiallyPlaying)

- scheduleEvent(EventTypeNames::playing);

+ scheduleNamedEvent(EventTypeNames::playing);

}

if (m_autoplaying && m_paused && autoplay() && !document().isSandboxed(SandboxAutomaticFeatures) && !userGestureRequiredForPlay()) {

m_paused = false;

invalidateCachedTime();

- scheduleEvent(EventTypeNames::play);

- scheduleEvent(EventTypeNames::playing);

+ scheduleNamedEvent(EventTypeNames::play);

+ scheduleNamedEvent(EventTypeNames::playing);

}

- scheduleEvent(EventTypeNames::canplaythrough);

+ scheduleNamedEvent(EventTypeNames::canplaythrough);

shouldUpdateDisplayState = true;

}

@@ -1634,165 +1611,6 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)

updateActiveTextTrackCues(currentTime());

}

-void HTMLMediaElement::mediaPlayerKeyAdded(const String& keySystem, const String& sessionId)

- WTF_LOG(Media, "HTMLMediaElement::mediaPlayerKeyAdded");

- MediaKeyEventInit initializer;

- initializer.keySystem = keySystem;

- initializer.sessionId = sessionId;

- initializer.bubbles = false;

- initializer.cancelable = false;

- RefPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyadded, initializer);

- event->setTarget(this);

- m_asyncEventQueue->enqueueEvent(event.release());

-void HTMLMediaElement::mediaPlayerKeyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)

- WTF_LOG(Media, "HTMLMediaElement::mediaPlayerKeyError: sessionID=%s, errorCode=%d, systemCode=%d", sessionId.utf8().data(), errorCode, systemCode);

- MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;

- switch (errorCode) {

- case MediaPlayerClient::UnknownError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;

- break;

- case MediaPlayerClient::ClientError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_CLIENT;

- break;

- case MediaPlayerClient::ServiceError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_SERVICE;

- break;

- case MediaPlayerClient::OutputError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_OUTPUT;

- break;

- case MediaPlayerClient::HardwareChangeError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_HARDWARECHANGE;

- break;

- case MediaPlayerClient::DomainError:

- mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_DOMAIN;

- break;

- }

- MediaKeyEventInit initializer;

- initializer.keySystem = keySystem;

- initializer.sessionId = sessionId;

- initializer.errorCode = MediaKeyError::create(mediaKeyErrorCode);

- initializer.systemCode = systemCode;

- initializer.bubbles = false;

- initializer.cancelable = false;

- RefPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyerror, initializer);

- event->setTarget(this);

- m_asyncEventQueue->enqueueEvent(event.release());

-void HTMLMediaElement::mediaPlayerKeyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL)

- WTF_LOG(Media, "HTMLMediaElement::mediaPlayerKeyMessage: sessionID=%s", sessionId.utf8().data());

- MediaKeyEventInit initializer;

- initializer.keySystem = keySystem;

- initializer.sessionId = sessionId;

- initializer.message = Uint8Array::create(message, messageLength);

- initializer.defaultURL = defaultURL;

- initializer.bubbles = false;

- initializer.cancelable = false;

- RefPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeymessage, initializer);

- event->setTarget(this);

- m_asyncEventQueue->enqueueEvent(event.release());

-// Create a MediaKeyNeededEvent for WD EME.

-static PassRefPtr<Event> createNeedKeyEvent(const String& contentType, const unsigned char* initData, unsigned initDataLength)

- MediaKeyNeededEventInit initializer;

- initializer.contentType = contentType;

- initializer.initData = Uint8Array::create(initData, initDataLength);

- initializer.bubbles = false;

- initializer.cancelable = false;

- return MediaKeyNeededEvent::create(EventTypeNames::needkey, initializer);

-// Create a 'needkey' MediaKeyEvent for v0.1b EME.

-static PassRefPtr<Event> createWebkitNeedKeyEvent(const String& contentType, const unsigned char* initData, unsigned initDataLength)

- MediaKeyEventInit webkitInitializer;

- webkitInitializer.keySystem = String();

- webkitInitializer.sessionId = String();

- webkitInitializer.initData = Uint8Array::create(initData, initDataLength);

- webkitInitializer.bubbles = false;

- webkitInitializer.cancelable = false;

- return MediaKeyEvent::create(EventTypeNames::webkitneedkey, webkitInitializer);

-bool HTMLMediaElement::mediaPlayerKeyNeeded(const String& contentType, const unsigned char* initData, unsigned initDataLength)

- WTF_LOG(Media, "HTMLMediaElement::mediaPlayerKeyNeeded: contentType=%s", contentType.utf8().data());

- if (RuntimeEnabledFeatures::encryptedMediaEnabled()) {

- // Send event for WD EME.

- RefPtr<Event> event = createNeedKeyEvent(contentType, initData, initDataLength);

- event->setTarget(this);

- m_asyncEventQueue->enqueueEvent(event.release());

- }

- if (RuntimeEnabledFeatures::prefixedEncryptedMediaEnabled()) {

- // Send event for v0.1b EME.

- RefPtr<Event> event = createWebkitNeedKeyEvent(contentType, initData, initDataLength);

- event->setTarget(this);

- m_asyncEventQueue->enqueueEvent(event.release());

- }

- return true;

-bool HTMLMediaElement::setEmeMode(EmeMode emeMode, ExceptionState& exceptionState)

- if (m_emeMode != EmeModeNotSelected && m_emeMode != emeMode) {

- exceptionState.throwDOMException(InvalidStateError, "Mixed use of EME prefixed and unprefixed API not allowed.");

- return false;

- }

- m_emeMode = emeMode;

- return true;

-blink::WebContentDecryptionModule* HTMLMediaElement::contentDecryptionModule()

- return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0;

-void HTMLMediaElement::setMediaKeysInternal(MediaKeys* mediaKeys)

- WTF_LOG(Media, "HTMLMediaElement::setMediaKeys");

- if (m_mediaKeys == mediaKeys)

- return;

- ASSERT(m_emeMode = EmeModeUnprefixed);

- if (m_mediaKeys)

- m_mediaKeys->setMediaElement(0);

- m_mediaKeys = mediaKeys;

- if (m_mediaKeys)

- m_mediaKeys->setMediaElement(this);

- // If a player is connected, tell it that the CDM has changed.

- if (m_player)

- m_player->setContentDecryptionModule(contentDecryptionModule());

-void HTMLMediaElement::setMediaKeys(MediaKeys* mediaKeys, ExceptionState& exceptionState)

- if (!setEmeMode(EmeModeUnprefixed, exceptionState))

- return;

- setMediaKeysInternal(mediaKeys);

void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)

{

ASSERT(m_player);

@@ -1803,7 +1621,7 @@ void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)

double timedelta = time - m_previousProgressTime;

if (m_player->didLoadingProgress()) {

- scheduleEvent(EventTypeNames::progress);

+ scheduleNamedEvent(EventTypeNames::progress);

m_previousProgressTime = time;

m_sentStalledEvent = false;

if (renderer())

@@ -1811,7 +1629,7 @@ void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)

if (hasMediaControls())

mediaControls()->bufferingProgressed();

} else if (timedelta > 3.0 && !m_sentStalledEvent) {

- scheduleEvent(EventTypeNames::stalled);

+ scheduleNamedEvent(EventTypeNames::stalled);

m_sentStalledEvent = true;

setShouldDelayLoadEvent(false);

}

@@ -1905,11 +1723,11 @@ void HTMLMediaElement::seek(double time, ExceptionState& exceptionState)

if (noSeekRequired) {

if (time == now) {

- scheduleEvent(EventTypeNames::seeking);

+ scheduleNamedEvent(EventTypeNames::seeking);

// FIXME: There must be a stable state before timeupdate+seeked are dispatched and seeking

// is reset to false. See http://crbug.com/266631

scheduleTimeupdateEvent(false);

- scheduleEvent(EventTypeNames::seeked);

+ scheduleNamedEvent(EventTypeNames::seeked);

}

m_seeking = false;

return;

@@ -1924,7 +1742,7 @@ void HTMLMediaElement::seek(double time, ExceptionState& exceptionState)

m_sentEndEvent = false;

// 8 - Queue a task to fire a simple event named seeking at the element.

- scheduleEvent(EventTypeNames::seeking);

+ scheduleNamedEvent(EventTypeNames::seeking);

// 9 - Set the current playback position to the given new playback position

m_player->seek(time);

@@ -1945,7 +1763,7 @@ void HTMLMediaElement::finishSeek()

scheduleTimeupdateEvent(false);

// 14 - Queue a task to fire a simple event named seeked at the element.

- scheduleEvent(EventTypeNames::seeked);

+ scheduleNamedEvent(EventTypeNames::seeked);

setDisplayMode(Video);

}

@@ -2057,7 +1875,7 @@ void HTMLMediaElement::setDefaultPlaybackRate(double rate)

{

if (m_defaultPlaybackRate != rate) {

m_defaultPlaybackRate = rate;

- scheduleEvent(EventTypeNames::ratechange);

+ scheduleNamedEvent(EventTypeNames::ratechange);

}

@@ -2073,7 +1891,7 @@ void HTMLMediaElement::setPlaybackRate(double rate)

if (m_playbackRate != rate) {

m_playbackRate = rate;

invalidateCachedTime();

- scheduleEvent(EventTypeNames::ratechange);

+ scheduleNamedEvent(EventTypeNames::ratechange);

}

if (m_player && potentiallyPlaying() && m_player->rate() != rate && !m_mediaController)

@@ -2153,12 +1971,12 @@ void HTMLMediaElement::playInternal()

if (m_paused) {

m_paused = false;

invalidateCachedTime();

- scheduleEvent(EventTypeNames::play);

+ scheduleNamedEvent(EventTypeNames::play);

if (m_readyState <= HAVE_CURRENT_DATA)

- scheduleEvent(EventTypeNames::waiting);

+ scheduleNamedEvent(EventTypeNames::waiting);

else if (m_readyState >= HAVE_FUTURE_DATA)

- scheduleEvent(EventTypeNames::playing);

+ scheduleNamedEvent(EventTypeNames::playing);

}

m_autoplaying = false;

@@ -2178,7 +1996,7 @@ void HTMLMediaElement::pause()

if (!m_paused) {

m_paused = true;

scheduleTimeupdateEvent(false);

- scheduleEvent(EventTypeNames::pause);

+ scheduleNamedEvent(EventTypeNames::pause);

}

updatePlayState();

@@ -2193,103 +2011,6 @@ void HTMLMediaElement::closeMediaSource()

m_mediaSource = nullptr;

}

-void HTMLMediaElement::webkitGenerateKeyRequest(const String& keySystem, PassRefPtr<Uint8Array> initData, ExceptionState& exceptionState)

- WTF_LOG(Media, "HTMLMediaElement::webkitGenerateKeyRequest");

- if (!setEmeMode(EmeModePrefixed, exceptionState))

- return;

- if (keySystem.isEmpty()) {

- exceptionState.throwDOMException(SyntaxError, "The key system provided is empty.");

- return;

- }

- if (!m_player) {

- exceptionState.throwDOMException(InvalidStateError, "No media has been loaded.");

- return;

- }

- const unsigned char* initDataPointer = 0;

- unsigned initDataLength = 0;

- if (initData) {

- initDataPointer = initData->data();

- initDataLength = initData->length();

- }

- MediaPlayer::MediaKeyException result = m_player->generateKeyRequest(keySystem, initDataPointer, initDataLength);

- throwExceptionForMediaKeyException(keySystem, String(), result, exceptionState);

-void HTMLMediaElement::webkitGenerateKeyRequest(const String& keySystem, ExceptionState& exceptionState)

- webkitGenerateKeyRequest(keySystem, Uint8Array::create(0), exceptionState);

-void HTMLMediaElement::webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, PassRefPtr<Uint8Array> initData, const String& sessionId, ExceptionState& exceptionState)

- WTF_LOG(Media, "HTMLMediaElement::webkitAddKey");

- if (!setEmeMode(EmeModePrefixed, exceptionState))

- return;

- if (keySystem.isEmpty()) {

- exceptionState.throwDOMException(SyntaxError, "The key system provided is empty.");

- return;

- }

- if (!key) {

- exceptionState.throwDOMException(SyntaxError, "The key provided is invalid.");

- return;

- }

- if (!key->length()) {

- exceptionState.throwDOMException(TypeMismatchError, "The key provided is invalid.");

- return;

- }

- if (!m_player) {

- exceptionState.throwDOMException(InvalidStateError, "No media has been loaded.");

- return;

- }

- const unsigned char* initDataPointer = 0;

- unsigned initDataLength = 0;

- if (initData) {

- initDataPointer = initData->data();

- initDataLength = initData->length();

- }

- MediaPlayer::MediaKeyException result = m_player->addKey(keySystem, key->data(), key->length(), initDataPointer, initDataLength, sessionId);

- throwExceptionForMediaKeyException(keySystem, sessionId, result, exceptionState);

-void HTMLMediaElement::webkitAddKey(const String& keySystem, PassRefPtr<Uint8Array> key, ExceptionState& exceptionState)

- webkitAddKey(keySystem, key, Uint8Array::create(0), String(), exceptionState);

-void HTMLMediaElement::webkitCancelKeyRequest(const String& keySystem, const String& sessionId, ExceptionState& exceptionState)

- WTF_LOG(Media, "HTMLMediaElement::webkitCancelKeyRequest");

- if (!setEmeMode(EmeModePrefixed, exceptionState))

- return;

- if (keySystem.isEmpty()) {

- exceptionState.throwDOMException(SyntaxError, "The key system provided is empty.");

- return;

- }

- if (!m_player) {

- exceptionState.throwDOMException(InvalidStateError, "No media has been loaded.");

- return;

- }

- MediaPlayer::MediaKeyException result = m_player->cancelKeyRequest(keySystem, sessionId);

- throwExceptionForMediaKeyException(keySystem, sessionId, result, exceptionState);

bool HTMLMediaElement::loop() const

{

return fastHasAttribute(loopAttr);

@@ -2339,7 +2060,7 @@ void HTMLMediaElement::setVolume(double vol, ExceptionState& exceptionState)

if (m_volume != vol) {

m_volume = vol;

updateVolume();

- scheduleEvent(EventTypeNames::volumechange);

+ scheduleNamedEvent(EventTypeNames::volumechange);

}

@@ -2359,7 +2080,7 @@ void HTMLMediaElement::setMuted(bool muted)

if (hasMediaControls())

mediaControls()->changedMute();

}

- scheduleEvent(EventTypeNames::volumechange);

+ scheduleNamedEvent(EventTypeNames::volumechange);

}

@@ -2441,7 +2162,7 @@ void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)

// event at a given time so filter here

double movieTime = currentTime();

if (movieTime != m_lastTimeUpdateEventMovieTime) {

- scheduleEvent(EventTypeNames::timeupdate);

+ scheduleNamedEvent(EventTypeNames::timeupdate);

m_lastTimeUpdateEventWallTime = now;

m_lastTimeUpdateEventMovieTime = movieTime;

}

@@ -3045,12 +2766,12 @@ void HTMLMediaElement::mediaPlayerTimeChanged()

if (!m_mediaController && !m_paused) {

// changes paused to true and fires a simple event named pause at the media element.

m_paused = true;

- scheduleEvent(EventTypeNames::pause);

+ scheduleNamedEvent(EventTypeNames::pause);

}

// Queue a task to fire a simple event named ended at the media element.

if (!m_sentEndEvent) {

m_sentEndEvent = true;

- scheduleEvent(EventTypeNames::ended);

+ scheduleNamedEvent(EventTypeNames::ended);

}

// If the media element has a current media controller, then report the controller state

// for the media element's current media controller.

@@ -3078,7 +2799,7 @@ void HTMLMediaElement::durationChanged(double duration)

return;

m_duration = duration;

- scheduleEvent(EventTypeNames::durationchange);

+ scheduleNamedEvent(EventTypeNames::durationchange);

if (hasMediaControls())

mediaControls()->reset();

@@ -3135,7 +2856,7 @@ void HTMLMediaElement::mediaPlayerSizeChanged()

ASSERT(hasVideo()); // "resize" makes no sense absent video.

if (m_readyState > HAVE_NOTHING && isVideo())

- scheduleEvent(EventTypeNames::resize);

+ scheduleNamedEvent(EventTypeNames::resize);

if (renderer())

renderer()->updateFromElement();

@@ -3346,7 +3067,7 @@ void HTMLMediaElement::userCancelledLoad()

m_error = MediaError::create(MediaError::MEDIA_ERR_ABORTED);

// 3 - Queue a task to fire a simple event named error at the media element.

- scheduleEvent(EventTypeNames::abort);

+ scheduleNamedEvent(EventTypeNames::abort);

closeMediaSource();

@@ -3356,7 +3077,7 @@ void HTMLMediaElement::userCancelledLoad()

// attribute to the NETWORK_IDLE value.

if (m_readyState == HAVE_NOTHING) {

m_networkState = NETWORK_EMPTY;

- scheduleEvent(EventTypeNames::emptied);

+ scheduleNamedEvent(EventTypeNames::emptied);

}

else

m_networkState = NETWORK_IDLE;

@@ -3398,8 +3119,6 @@ void HTMLMediaElement::clearMediaPlayer(int flags)

closeMediaSource();

- setMediaKeysInternal(0);

clearMediaPlayerAndAudioSourceProviderClient();

stopPeriodicTimers();

@@ -3698,9 +3417,6 @@ void HTMLMediaElement::createMediaPlayer()

m_player = MediaPlayer::create(this);

- if (m_emeMode == EmeModeUnprefixed && m_player)

- m_player->setContentDecryptionModule(contentDecryptionModule());

#if ENABLE(WEB_AUDIO)

if (m_audioSourceNode) {

// When creating the player, make sure its AudioSourceProvider knows about the MediaElementAudioSourceNode.