Eliminate MediaPlayer & MediaPlayerClient abstractions

Source/modules/encryptedmedia/HTMLMediaElementEncryptedMedia.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 277 matching lines @@
     fail(code, errorMessage);
 }
 
 DEFINE_TRACE(SetMediaKeysHandler)
 {
     visitor->trace(m_element);
     visitor->trace(m_newMediaKeys);
     ScriptPromiseResolver::trace(visitor);
 }
 
-HTMLMediaElementEncryptedMedia::HTMLMediaElementEncryptedMedia()
-    : m_emeMode(EmeModeNotSelected)
+HTMLMediaElementEncryptedMedia::HTMLMediaElementEncryptedMedia(HTMLMediaElement& element)
+    : m_mediaElement(element)
+    , m_emeMode(EmeModeNotSelected)
     , m_isWaitingForKey(false)
 {
 }
 
 #if !ENABLE(OILPAN)
 HTMLMediaElementEncryptedMedia::~HTMLMediaElementEncryptedMedia()
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::~HTMLMediaElementEncryptedMedia");
     if (m_mediaKeys)
         m_mediaKeys->clearMediaElement();
 }
 #endif
 
 const char* HTMLMediaElementEncryptedMedia::supplementName()
 {
     return "HTMLMediaElementEncryptedMedia";
 }
 
 HTMLMediaElementEncryptedMedia& HTMLMediaElementEncryptedMedia::from(HTMLMediaElement& element)
 {
     HTMLMediaElementEncryptedMedia* supplement = static_cast<HTMLMediaElementEncryptedMedia*>(WillBeHeapSupplement<HTMLMediaElement>::from(element, supplementName()));
     if (!supplement) {
-        supplement = new HTMLMediaElementEncryptedMedia();
+        supplement = new HTMLMediaElementEncryptedMedia(element);
         provideTo(element, supplementName(), adoptPtrWillBeNoop(supplement));
     }
     return *supplement;
 }
 
 bool HTMLMediaElementEncryptedMedia::setEmeMode(EmeMode emeMode)
 {
     if (m_emeMode != EmeModeNotSelected && m_emeMode != emeMode)
         return false;
 
     m_emeMode = emeMode;
     return true;
 }
 
-WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionModule()
-{
-    return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0;
-}
-
 MediaKeys* HTMLMediaElementEncryptedMedia::mediaKeys(HTMLMediaElement& element)
 {
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
     return thisElement.m_mediaKeys.get();
 }
 
 ScriptPromise HTMLMediaElementEncryptedMedia::setMediaKeys(ScriptState* scriptState, HTMLMediaElement& element, MediaKeys* mediaKeys)
 {
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::setMediaKeys current(%p), new(%p)", thisElement.m_mediaKeys.get(), mediaKeys);
@@ skipping 142 matching lines @@
 
     if (!webMediaPlayer) {
         exceptionState.throwDOMException(InvalidStateError, "No media has been loaded.");
         return;
     }
 
     WebMediaPlayer::MediaKeyException result = webMediaPlayer->cancelKeyRequest(keySystem, sessionId);
     throwExceptionIfMediaKeyExceptionOccurred(keySystem, sessionId, result, exceptionState);
 }
 
-void HTMLMediaElementEncryptedMedia::keyAdded(HTMLMediaElement& element, const String& keySystem, const String& sessionId)
+void HTMLMediaElementEncryptedMedia::keyAdded(const WebString& keySystem, const WebString& sessionId)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyAdded");
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
 
     RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyadded, initializer);
-    event->setTarget(&element);
-    element.scheduleEvent(event.release());
+    event->setTarget(&m_mediaElement);
+    m_mediaElement.scheduleEvent(event.release());
 }
 
-void HTMLMediaElementEncryptedMedia::keyError(HTMLMediaElement& element, const String& keySystem, const String& sessionId, WebMediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
+void HTMLMediaElementEncryptedMedia::keyError(const WebString& keySystem, const WebString& sessionId, WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyError: sessionID=%s, errorCode=%d, systemCode=%d", sessionId.utf8().data(), errorCode, systemCode);
 
     MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;
     switch (errorCode) {
-    case WebMediaPlayerClient::MediaKeyErrorCodeUnknown:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeUnknown:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;
         break;
-    case WebMediaPlayerClient::MediaKeyErrorCodeClient:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeClient:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_CLIENT;
         break;
-    case WebMediaPlayerClient::MediaKeyErrorCodeService:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeService:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_SERVICE;
         break;
-    case WebMediaPlayerClient::MediaKeyErrorCodeOutput:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeOutput:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_OUTPUT;
         break;
-    case WebMediaPlayerClient::MediaKeyErrorCodeHardwareChange:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeHardwareChange:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_HARDWARECHANGE;
         break;
-    case WebMediaPlayerClient::MediaKeyErrorCodeDomain:
+    case WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCodeDomain:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_DOMAIN;
         break;
     }
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
     initializer.setErrorCode(MediaKeyError::create(mediaKeyErrorCode));
     initializer.setSystemCode(systemCode);
 
     RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyerror, initializer);
-    event->setTarget(&element);
-    element.scheduleEvent(event.release());
+    event->setTarget(&m_mediaElement);
+    m_mediaElement.scheduleEvent(event.release());
 }
 
-void HTMLMediaElementEncryptedMedia::keyMessage(HTMLMediaElement& element, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const WebURL& defaultURL)
+void HTMLMediaElementEncryptedMedia::keyMessage(const WebString& keySystem, const WebString& sessionId, const unsigned char* message, unsigned messageLength, const WebURL& defaultURL)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyMessage: sessionID=%s", sessionId.utf8().data());
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
     initializer.setMessage(DOMUint8Array::create(message, messageLength));
     initializer.setDefaultURL(KURL(defaultURL));
 
     RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeymessage, initializer);
-    event->setTarget(&element);
-    element.scheduleEvent(event.release());
+    event->setTarget(&m_mediaElement);
+    m_mediaElement.scheduleEvent(event.release());
 }
 
-void HTMLMediaElementEncryptedMedia::encrypted(HTMLMediaElement& element, WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
+void HTMLMediaElementEncryptedMedia::encrypted(WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::encrypted");
 
     if (RuntimeEnabledFeatures::encryptedMediaEnabled()) {
         // Send event for WD EME.
         RefPtrWillBeRawPtr<Event> event;
-        if (element.isMediaDataCORSSameOrigin(element.executionContext()->securityOrigin())) {
+        if (m_mediaElement.isMediaDataCORSSameOrigin(m_mediaElement.executionContext()->securityOrigin())) {
             event = createEncryptedEvent(initDataType, initData, initDataLength);
         } else {
             // Current page is not allowed to see content from the media file,
             // so don't return the initData. However, they still get an event.
             event = createEncryptedEvent(WebEncryptedMediaInitDataType::Unknown, nullptr, 0);
         }
 
-        event->setTarget(&element);
-        element.scheduleEvent(event.release());
+        event->setTarget(&m_mediaElement);
+        m_mediaElement.scheduleEvent(event.release());
     }
 
     if (RuntimeEnabledFeatures::prefixedEncryptedMediaEnabled()) {
         // Send event for v0.1b EME.
         RefPtrWillBeRawPtr<Event> event = createWebkitNeedKeyEvent(initData, initDataLength);
-        event->setTarget(&element);
-        element.scheduleEvent(event.release());
+        event->setTarget(&m_mediaElement);
+        m_mediaElement.scheduleEvent(event.release());
     }
 }
 
-void HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey(HTMLMediaElement& element)
+void HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey()
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey");
 
     // From https://w3c.github.io/encrypted-media/#queue-waitingforkey:
     // It should only be called when the HTMLMediaElement object is potentially
     // playing and its readyState is equal to HAVE_FUTURE_DATA or greater.
     // FIXME: Is this really required?
 
     // 1. Let the media element be the specified HTMLMediaElement object.
-    HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
+    // This is nothing but |this| element.
 
     // 2. If the media element's waiting for key value is false, queue a task
     //    to fire a simple event named waitingforkey at the media element.
-    if (!thisElement.m_isWaitingForKey) {
+    if (!m_isWaitingForKey) {
         RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::waitingforkey);
-        event->setTarget(&element);
-        element.scheduleEvent(event.release());
+        event->setTarget(&m_mediaElement);
+        m_mediaElement.scheduleEvent(event.release());
     }
 
     // 3. Set the media element's waiting for key value to true.
-    thisElement.m_isWaitingForKey = true;
+    m_isWaitingForKey = true;
 
     // 4. Suspend playback.
     //    (Already done on the Chromium side by the decryptors.)
 }
 
-void HTMLMediaElementEncryptedMedia::didResumePlaybackBlockedForKey(HTMLMediaElement& element)
+void HTMLMediaElementEncryptedMedia::didResumePlaybackBlockedForKey()
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::didResumePlaybackBlockedForKey");
 
     // Logic is on the Chromium side to attempt to resume playback when a new
     // key is available. However, |m_isWaitingForKey| needs to be cleared so
     // that a later waitingForKey() call can generate the event.
-    HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
-    thisElement.m_isWaitingForKey = false;
+    m_isWaitingForKey = false;
 }
 
-WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionModule(HTMLMediaElement& element)
+WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionModule()
 {
-    HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
-    return thisElement.contentDecryptionModule();
+    return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0;
 }
 
 DEFINE_TRACE(HTMLMediaElementEncryptedMedia)
 {
     visitor->trace(m_mediaKeys);
     WillBeHeapSupplement<HTMLMediaElement>::trace(visitor);
 }
 
 } // namespace blink