Changeset 162360 in webkit

Timestamp:

Jan 20, 2014, 11:23:40 AM (11 years ago)

Author:

eric.carlson@apple.com

Message:

Allow MediaSessionManager to restrict 'preload' behavior
​https://bugs.webkit.org/show_bug.cgi?id=127297

Reviewed by Jer Noble.

Source/WebCore:

Tests: media/video-restricted-no-preload-auto.html

media/video-restricted-no-preload-metadata.html

• html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::parseAttribute): Apply restrictions to preload attribute before

passing to media engine.

(WebCore::HTMLMediaElement::loadResource): Ditto.

• html/HTMLMediaSession.cpp:

(WebCore::HTMLMediaSession::effectivePreloadForElement): New, limit preload according to restrictions.

• html/HTMLMediaSession.h:

• platform/audio/MediaSessionManager.h:
• platform/audio/ios/MediaSessionManagerIOS.mm:

(WebCore::MediaSessionManageriOS::resetRestrictions): Limit preload to metadata only. Drive-by

static deviceClass initialization cleanup.

• testing/Internals.cpp:

(WebCore::Internals::setMediaSessionRestrictions): Support MetadataPreloadingNotPermitted and

AutoPreloadingNotPermitted.

LayoutTests:

• media/video-restricted-no-preload-auto-expected.txt: Added.
• media/video-restricted-no-preload-auto.html: Added.
• media/video-restricted-no-preload-metadata-expected.txt: Added.
• media/video-restricted-no-preload-metadata.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/media/video-restricted-no-preload-auto-expected.txt (added)
• LayoutTests/media/video-restricted-no-preload-auto.html (added)
• LayoutTests/media/video-restricted-no-preload-metadata-expected.txt (added)
• LayoutTests/media/video-restricted-no-preload-metadata.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/html/HTMLMediaElement.cpp (modified) (3 diffs)
• Source/WebCore/html/HTMLMediaElement.h (modified) (1 diff)
• Source/WebCore/html/HTMLMediaSession.cpp (modified) (1 diff)
• Source/WebCore/html/HTMLMediaSession.h (modified) (2 diffs)
• Source/WebCore/platform/audio/MediaSessionManager.h (modified) (1 diff)
• Source/WebCore/platform/audio/ios/MediaSessionManagerIOS.mm (modified) (1 diff)
• Source/WebCore/testing/Internals.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2014-01-20  Eric Carlson  <eric.carlson@apple.com>
+
+        Allow MediaSessionManager to restrict 'preload' behavior
+        https://bugs.webkit.org/show_bug.cgi?id=127297
+
+        Reviewed by Jer Noble.
+
+        * media/video-restricted-no-preload-auto-expected.txt: Added.
+        * media/video-restricted-no-preload-auto.html: Added.
+        * media/video-restricted-no-preload-metadata-expected.txt: Added.
+        * media/video-restricted-no-preload-metadata.html: Added.
+
 2014-01-20  Mihai Tica  <mitica@adobe.com>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-01-20  Eric Carlson  <eric.carlson@apple.com>
+
+        Allow MediaSessionManager to restrict 'preload' behavior
+        https://bugs.webkit.org/show_bug.cgi?id=127297
+
+        Reviewed by Jer Noble.
+
+        Tests: media/video-restricted-no-preload-auto.html
+               media/video-restricted-no-preload-metadata.html
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::parseAttribute): Apply restrictions to preload attribute before
+            passing to media engine.
+        (WebCore::HTMLMediaElement::loadResource): Ditto.
+
+        * html/HTMLMediaSession.cpp:
+        (WebCore::HTMLMediaSession::effectivePreloadForElement): New, limit preload according to restrictions.
+        * html/HTMLMediaSession.h:
+
+        * platform/audio/MediaSessionManager.h:
+        * platform/audio/ios/MediaSessionManagerIOS.mm:
+        (WebCore::MediaSessionManageriOS::resetRestrictions): Limit preload to metadata only. Drive-by
+            static deviceClass initialization cleanup.
+
+        * testing/Internals.cpp:
+        (WebCore::Internals::setMediaSessionRestrictions): Support MetadataPreloadingNotPermitted and
+            AutoPreloadingNotPermitted.
+
 2014-01-20  Andreas Kling  <akling@apple.com>
 

trunk/Source/WebCore/html/HTMLMediaElement.cpp

@@ -547 +547 @@
         // The attribute must be ignored if the autoplay attribute is present
         if (!autoplay() && m_player)
-            m_player->setPreload(m_preload);
+            m_player->setPreload(m_mediaSession->effectivePreloadForElement(*this));
 
     } else if (name == mediagroupAttr)
@@ -988 +988 @@
     // algorithm, but do it now because we won't start that until after the timer fires and the 
     // event may have already fired by then.
-    if (m_preload != MediaPlayer::None)
+    MediaPlayer::Preload effectivePreload = m_mediaSession->effectivePreloadForElement(*this);
+    if (effectivePreload != MediaPlayer::None)
         setShouldDelayLoadEvent(true);
 
 #if PLATFORM(IOS)
     Settings* settings = document().settings();
-    if (m_preload != MediaPlayer::None && settings && settings->mediaDataLoadsAutomatically())
+    if (effectivePreload != MediaPlayer::None && settings && settings->mediaDataLoadsAutomatically())
         prepareToPlay();
 #endif
@@ -1212 +1213 @@
 
     if (!autoplay())
-        m_player->setPreload(m_preload);
+        m_player->setPreload(m_mediaSession->effectivePreloadForElement(*this));
     m_player->setPreservesPitch(m_webkitPreservesPitch);
 

trunk/Source/WebCore/html/HTMLMediaElement.h

@@ -425 +425 @@
 #endif
 
+    MediaPlayer::Preload preloadValue() const { return m_preload; }
+
 protected:
     HTMLMediaElement(const QualifiedName&, Document&, bool);

trunk/Source/WebCore/html/HTMLMediaSession.cpp

@@ -144 +144 @@
 #endif
 
+MediaPlayer::Preload HTMLMediaSession::effectivePreloadForElement(const HTMLMediaElement& element) const
+{
+    MediaSessionManager::SessionRestrictions restrictions = MediaSessionManager::sharedManager().restrictions(mediaType());
+    MediaPlayer::Preload preload = element.preloadValue();
+
+    if ((restrictions & MediaSessionManager::MetadataPreloadingNotPermitted) == MediaSessionManager::MetadataPreloadingNotPermitted)
+        return MediaPlayer::None;
+
+    if ((restrictions & MediaSessionManager::AutoPreloadingNotPermitted) == MediaSessionManager::AutoPreloadingNotPermitted) {
+        if (preload > MediaPlayer::MetaData)
+            return MediaPlayer::MetaData;
+    }
+
+    return preload;
+}
+
 void HTMLMediaSession::clientWillBeginPlayback() const
 {

trunk/Source/WebCore/html/HTMLMediaSession.h

@@ -29 +29 @@
 #if ENABLE(VIDEO)
 
+#include "MediaPlayer.h"
 #include "MediaSession.h"
 
@@ -53 +54 @@
 #endif
     bool requiresFullscreenForVideoPlayback(const HTMLMediaElement&) const;
+    MediaPlayer::Preload effectivePreloadForElement(const HTMLMediaElement&) const;
 
     // Restrictions to modify default behaviors.

trunk/Source/WebCore/platform/audio/MediaSessionManager.h

@@ -51 +51 @@
         NoRestrictions = 0,
         ConcurrentPlaybackNotPermitted = 1 << 0,
-        InlineVideoPlaybackRestricted = 1 << 0,
+        InlineVideoPlaybackRestricted = 1 << 1,
+        MetadataPreloadingNotPermitted = 1 << 2,
+        AutoPreloadingNotPermitted = 1 << 3,
     };
     typedef unsigned SessionRestrictions;

trunk/Source/WebCore/platform/audio/ios/MediaSessionManagerIOS.mm

@@ -80 +80 @@
     MediaSessionManager::resetRestrictions();
 
-    DEFINE_STATIC_LOCAL(wkDeviceClass, deviceClass, (iosDeviceClass()));
-
+    static wkDeviceClass deviceClass = iosDeviceClass();
     if (deviceClass == wkDeviceClassiPhone || deviceClass == wkDeviceClassiPod)
         addRestriction(MediaSession::Video, InlineVideoPlaybackRestricted);
 
     addRestriction(MediaSession::Video, ConcurrentPlaybackNotPermitted);
+    removeRestriction(MediaSession::Audio, MetadataPreloadingNotPermitted);
+    removeRestriction(MediaSession::Video, MetadataPreloadingNotPermitted);
+    addRestriction(MediaSession::Audio, AutoPreloadingNotPermitted);
+    addRestriction(MediaSession::Video, AutoPreloadingNotPermitted);
 }
 

trunk/Source/WebCore/testing/Internals.cpp

@@ -2212 +2212 @@
     if (equalIgnoringCase(restrictionsString, "InlineVideoPlaybackRestricted"))
         restrictions += MediaSessionManager::InlineVideoPlaybackRestricted;
-    
+    if (equalIgnoringCase(restrictionsString, "MetadataPreloadingNotPermitted"))
+        restrictions += MediaSessionManager::MetadataPreloadingNotPermitted;
+    if (equalIgnoringCase(restrictionsString, "AutoPreloadingNotPermitted"))
+        restrictions += MediaSessionManager::AutoPreloadingNotPermitted;
+
     MediaSessionManager::sharedManager().addRestriction(mediaType, restrictions);
 }