Changeset 236006 in webkit

Timestamp:

Sep 14, 2018 8:37:14 AM (6 years ago)

Author:

calvaris@igalia.com

Message:

[EME] Add support the waitingforkey event
​https://bugs.webkit.org/show_bug.cgi?id=189616

Reviewed by Philippe Normand.

Crossplatform support to fire the waitingforkey event from the
player to the element. The element implements the W3C specified
algorithm.

• html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::mediaPlayerWaitingForKey):
(WebCore::HTMLMediaElement::attemptToResumePlaybackIfNecessary):

• html/HTMLMediaElement.h:
• platform/graphics/MediaPlayer.cpp:

(WebCore::MediaPlayer::waitingForKey):

• platform/graphics/MediaPlayer.h:

(WebCore::MediaPlayerClient::mediaPlayerWaitingForKey):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• html/HTMLMediaElement.cpp (modified) (3 diffs)
• html/HTMLMediaElement.h (modified) (2 diffs)
• platform/graphics/MediaPlayer.cpp (modified) (1 diff)
• platform/graphics/MediaPlayer.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2018-09-14  Xabier Rodriguez Calvar  <calvaris@igalia.com>
+
+        [EME] Add support the waitingforkey event
+        https://bugs.webkit.org/show_bug.cgi?id=189616
+
+        Reviewed by Philippe Normand.
+
+        Crossplatform support to fire the waitingforkey event from the
+        player to the element. The element implements the W3C specified
+        algorithm.
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::mediaPlayerWaitingForKey):
+        (WebCore::HTMLMediaElement::attemptToResumePlaybackIfNecessary):
+        * html/HTMLMediaElement.h:
+        * platform/graphics/MediaPlayer.cpp:
+        (WebCore::MediaPlayer::waitingForKey):
+        * platform/graphics/MediaPlayer.h:
+        (WebCore::MediaPlayerClient::mediaPlayerWaitingForKey):
+
 2018-09-14  Mike Gorse  <mgorse@suse.com>
 

trunk/Source/WebCore/html/HTMLMediaElement.cpp

@@ -2788 +2788 @@
 }
 
+void HTMLMediaElement::mediaPlayerWaitingForKey()
+{
+    // https://www.w3.org/TR/encrypted-media/#wait-for-key
+    // W3C Recommendation 18 September 2017
+
+    // The Wait for Key algorithm queues a waitingforkey event and
+    // updates readyState. It should only be called when the
+    // HTMLMediaElement object is potentially playing and its
+    // readyState is equal to HAVE_FUTURE_DATA or greater. Requests to
+    // run this algorithm include a target HTMLMediaElement object.
+
+    // The following steps are run:
+
+    // 1. Let the media element be the specified HTMLMediaElement
+    // object.
+    // 2. If the media element's playback blocked waiting for key
+    // value is true, abort these steps.
+    if (m_playbackBlockedWaitingForKey)
+        return;
+
+    // 3. Set the media element's playback blocked waiting for key
+    // value to true.
+    m_playbackBlockedWaitingForKey = true;
+
+    // NOTE
+    // As a result of the above step, the media element will become a
+    // blocked media element if it wasn't already. In that case, the
+    // media element will stop playback.
+
+    // 4. Follow the steps for the first matching condition from the
+    // following list:
+
+    // If data for the immediate current playback position is
+    // available
+    // Set the readyState of media element to HAVE_CURRENT_DATA.
+    // Otherwise
+    // Set the readyState of media element to HAVE_METADATA.
+    ReadyState nextReadyState = buffered()->contain(currentTime()) ? HAVE_CURRENT_DATA : HAVE_METADATA;
+    if (nextReadyState < m_readyState)
+        setReadyState(static_cast<MediaPlayer::ReadyState>(nextReadyState));
+
+    // NOTE
+    // In other words, if the video frame and audio data for the
+    // current playback position have been decoded because they were
+    // unencrypted and/or successfully decrypted, set readyState to
+    // HAVE_CURRENT_DATA. Otherwise, including if this was previously
+    // the case but the data is no longer available, set readyState to
+    // HAVE_METADATA.
+
+    // 5. Queue a task to fire a simple event named waitingforkey at the
+    // media element.
+    scheduleEvent(eventNames().waitingforkeyEvent);
+
+    // 6. Suspend playback.
+    // GStreamer handles this without suspending explicitly.
+}
+
 void HTMLMediaElement::attemptToDecrypt()
 {
@@ -2828 +2885 @@
     // 1. Let the media element be the specified HTMLMediaElement object.
     // 2. If the media element's playback blocked waiting for key is false, abort these steps.
-    // FIXME: ^
+    if (!m_playbackBlockedWaitingForKey)
+        return;
 
     // 3. Run the Attempt to Decrypt algorithm on the media element.
@@ -2835 +2893 @@
     // 4. If the user agent can advance the current playback position in the direction of playback:
     //   4.1. Set the media element's decryption blocked waiting for key value to false.
+    // FIXME: ^
     //   4.2. Set the media element's playback blocked waiting for key value to false.
+    m_playbackBlockedWaitingForKey = false;
+
     //   4.3. Set the media element's readyState value to HAVE_CURRENT_DATA, HAVE_FUTURE_DATA or HAVE_ENOUGH_DATA as appropriate.
-    // FIXME: ^
+    setReadyState(m_player->readyState());
 }
 

trunk/Source/WebCore/html/HTMLMediaElement.h

@@ -674 +674 @@
 #if ENABLE(ENCRYPTED_MEDIA)
     void mediaPlayerInitializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&) final;
+    void mediaPlayerWaitingForKey() final;
 
     void attemptToDecrypt();
@@ -1149 +1150 @@
     RefPtr<MediaKeys> m_mediaKeys;
     bool m_attachingMediaKeys { false };
+    bool m_playbackBlockedWaitingForKey { false };
     GenericTaskQueue<Timer> m_encryptedMediaQueue;
 #endif

trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

@@ -1267 +1267 @@
 }
 
+void MediaPlayer::waitingForKey()
+{
+    client().mediaPlayerWaitingForKey();
+}
 #endif
 

trunk/Source/WebCore/platform/graphics/MediaPlayer.h

@@ -170 +170 @@
 #if ENABLE(ENCRYPTED_MEDIA)
     virtual void mediaPlayerInitializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&) { }
+    virtual void mediaPlayerWaitingForKey() { }
 #endif
     
@@ -488 +489 @@
 #if ENABLE(ENCRYPTED_MEDIA)
     void initializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&);
+    void waitingForKey();
 #endif