Changeset 187031 in webkit

Timestamp:

Jul 20, 2015 1:16:18 PM (9 years ago)

Author:

akling@apple.com

Message:

Improve behavior of media elements in page cache.
<​https://webkit.org/b/147020>
<rdar://problem/21712311>

Reviewed by Chris Dumez.

Source/WebCore:

Make improvements for media elements when transitioning in/out of page cache:

• Events that were scheduled when going into cache will now be delivered when the page is restored from cache.

• Data buffering is turned off while in the cache. This reduces the memory cost of cached pages with media elements on iOS (where mediaserverd would keep upcoming video frames in memory for cached pages.)

Test: media/restore-from-page-cache.html (amended)

• dom/GenericEventQueue.h:
• dom/GenericEventQueue.cpp:

(WebCore::GenericEventQueue::enqueueEvent):
(WebCore::GenericEventQueue::suspend):
(WebCore::GenericEventQueue::resume):

Add a simple suspend/resume mechanism to GenericEventQueue that can
be used to support page caching.

• html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::stop):
(WebCore::HTMLMediaElement::suspend):
(WebCore::HTMLMediaElement::resume):
(WebCore::HTMLMediaElement::stopWithoutDestroyingMediaPlayer):

Adapt to event queueing changes and add calls to setShouldBufferData().

• html/HTMLSourceElement.h:
• html/HTMLSourceElement.cpp:

(WebCore::HTMLSourceElement::HTMLSourceElement):
(WebCore::HTMLSourceElement::create):
(WebCore::HTMLSourceElement::activeDOMObjectName):
(WebCore::HTMLSourceElement::canSuspendForPageCache):
(WebCore::HTMLSourceElement::suspend):
(WebCore::HTMLSourceElement::resume):
(WebCore::HTMLSourceElement::stop):

Turn HTMLSourceElement into an ActiveDOMObject so it gets all the
appropriate page cache notifications directly. Suspend the delayed
error event delivery timer when cached.

LayoutTests:

Add some coverage for suspend/resume of queued events on cached media elements.

• media/restore-from-page-cache-expected.txt:
• media/restore-from-page-cache.html:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/media/restore-from-page-cache-expected.txt (modified) (1 diff)
• LayoutTests/media/restore-from-page-cache.html (modified) (2 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/dom/GenericEventQueue.cpp (modified) (3 diffs)
• Source/WebCore/dom/GenericEventQueue.h (modified) (2 diffs)
• Source/WebCore/html/HTMLMediaElement.cpp (modified) (3 diffs)
• Source/WebCore/html/HTMLSourceElement.cpp (modified) (3 diffs)
• Source/WebCore/html/HTMLSourceElement.h (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2015-07-20  Andreas Kling  <akling@apple.com>
+
+        Improve behavior of media elements in page cache.
+        <https://webkit.org/b/147020>
+        <rdar://problem/21712311>
+
+        Reviewed by Chris Dumez.
+
+        Add some coverage for suspend/resume of queued events on cached media elements.
+
+        * media/restore-from-page-cache-expected.txt:
+        * media/restore-from-page-cache.html:
+
 2015-07-19  Tim Horton  <timothy_horton@apple.com>
 

trunk/LayoutTests/media/restore-from-page-cache-expected.txt

@@ -6 +6 @@
 EXPECTED (loadCount == '0') OK
 *** Page going into cache
+*** Changing playbackRate just before going into cache, to schedule a ratechange event.
+*** Changing volume just before going into cache, to schedule a volumechange event.
 *** Page returned from cache
 EXPECTED (loadCount == '1') OK
 EXPECTED (videoComputedStyle.width == '320px') OK
 EXPECTED (videoComputedStyle.height == '240px') OK
+*** ratechange event fired. This should happen AFTER returning from cache.
+*** volumechange event fired. This should happen AFTER returning from cache.
 

trunk/LayoutTests/media/restore-from-page-cache.html

@@ -34 +34 @@
                 }
             }
-                
+
+            function pagehide()
+            {
+                // Have the video element generate some events that need to be suspended.
+                // We use multiple events to verify that they fire in the correct order.
+                consoleWrite("*** Changing playbackRate just before going into cache, to schedule a ratechange event.");
+                document.getElementsByTagName("video")[0].playbackRate = 2; 
+                consoleWrite("*** Changing volume just before going into cache, to schedule a volumechange event.");
+                document.getElementsByTagName("video")[0].volume = 0.5; 
+            }
+
             function canplaythrough() 
             {
                 testExpected("loadCount", 0);
                 if (!loadCount) {
+                    video = document.getElementsByTagName('video')[0];
                     consoleWrite("*** Page going into cache");
                     setTimeout('window.location = "data:text/html,<script>history.back()<" + "/script>"', 0);
                 }
                 ++loadCount;
+            }
+
+            function propertyChangeCallback(evt)
+            {
+                consoleWrite("*** " + evt.type +  " event fired. This should happen AFTER returning from cache.");
             }
 
@@ -53 +69 @@
                 
                 video.src = mediaFile;
+
+                video.onratechange = propertyChangeCallback;
+                video.onvolumechange = propertyChangeCallback;
             }
 
             window.onpageshow = pageshow;
+            window.onpagehide = pagehide;
         </script>
     </head>

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-07-20  Andreas Kling  <akling@apple.com>
+
+        Improve behavior of media elements in page cache.
+        <https://webkit.org/b/147020>
+        <rdar://problem/21712311>
+
+        Reviewed by Chris Dumez.
+
+        Make improvements for media elements when transitioning in/out of page cache:
+
+        - Events that were scheduled when going into cache will now be delivered
+          when the page is restored from cache.
+
+        - Data buffering is turned off while in the cache. This reduces the memory
+          cost of cached pages with media elements on iOS (where mediaserverd would
+          keep upcoming video frames in memory for cached pages.)
+
+        Test: media/restore-from-page-cache.html (amended)
+
+        * dom/GenericEventQueue.h:
+        * dom/GenericEventQueue.cpp:
+        (WebCore::GenericEventQueue::enqueueEvent):
+        (WebCore::GenericEventQueue::suspend):
+        (WebCore::GenericEventQueue::resume):
+
+            Add a simple suspend/resume mechanism to GenericEventQueue that can
+            be used to support page caching.
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::stop):
+        (WebCore::HTMLMediaElement::suspend):
+        (WebCore::HTMLMediaElement::resume):
+        (WebCore::HTMLMediaElement::stopWithoutDestroyingMediaPlayer):
+
+            Adapt to event queueing changes and add calls to setShouldBufferData().
+
+        * html/HTMLSourceElement.h:
+        * html/HTMLSourceElement.cpp:
+        (WebCore::HTMLSourceElement::HTMLSourceElement):
+        (WebCore::HTMLSourceElement::create):
+        (WebCore::HTMLSourceElement::activeDOMObjectName):
+        (WebCore::HTMLSourceElement::canSuspendForPageCache):
+        (WebCore::HTMLSourceElement::suspend):
+        (WebCore::HTMLSourceElement::resume):
+        (WebCore::HTMLSourceElement::stop):
+
+            Turn HTMLSourceElement into an ActiveDOMObject so it gets all the
+            appropriate page cache notifications directly. Suspend the delayed
+            error event delivery timer when cached.
+
 2015-07-20  Mark Lam  <mark.lam@apple.com>
 

trunk/Source/WebCore/dom/GenericEventQueue.cpp

@@ -46 +46 @@
 }
 
-bool GenericEventQueue::enqueueEvent(PassRefPtr<Event> event)
+void GenericEventQueue::enqueueEvent(PassRefPtr<Event> event)
 {
     if (m_isClosed)
-        return false;
+        return;
 
     if (event->target() == &m_owner)
@@ -55 +55 @@
 
     m_pendingEvents.append(event);
+
+    if (m_isSuspended)
+        return;
+
     pendingQueues().append(m_weakPtrFactory.createWeakPtr());
     if (!sharedTimer().isActive())
         sharedTimer().startOneShot(0);
-
-    return true;
 }
 
@@ -121 +123 @@
 }
 
+void GenericEventQueue::suspend()
+{
+    ASSERT(!m_isSuspended);
+    m_isSuspended = true;
+    m_weakPtrFactory.revokeAll();
 }
+
+void GenericEventQueue::resume()
+{
+    ASSERT(m_isSuspended);
+    m_isSuspended = false;
+
+    if (m_pendingEvents.isEmpty())
+        return;
+
+    for (unsigned i = 0; i < m_pendingEvents.size(); ++i)
+        pendingQueues().append(m_weakPtrFactory.createWeakPtr());
+
+    if (!sharedTimer().isActive())
+        sharedTimer().startOneShot(0);
+}
+
+}

trunk/Source/WebCore/dom/GenericEventQueue.h

@@ -43 +43 @@
     ~GenericEventQueue();
 
-    bool enqueueEvent(PassRefPtr<Event>);
+    void enqueueEvent(PassRefPtr<Event>);
     void close();
 
     void cancelAllEvents();
     bool hasPendingEvents() const;
+
+    void suspend();
+    void resume();
 
 private:
@@ -60 +63 @@
     WeakPtrFactory<GenericEventQueue> m_weakPtrFactory;
     bool m_isClosed;
+    bool m_isSuspended { false };
 };
 

trunk/Source/WebCore/html/HTMLMediaElement.cpp

@@ -4891 +4891 @@
     
     stopPeriodicTimers();
-    cancelPendingEventsAndCallbacks();
+
+    updateSleepDisabling();
+}
+
+void HTMLMediaElement::stop()
+{
+    LOG(Media, "HTMLMediaElement::stop(%p)", this);
+
+    stopWithoutDestroyingMediaPlayer();
 
     m_asyncEventQueue.close();
-
-    updateSleepDisabling();
-}
-
-void HTMLMediaElement::stop()
-{
-    LOG(Media, "HTMLMediaElement::stop(%p)", this);
-
-    stopWithoutDestroyingMediaPlayer();
 
     // Once an active DOM object has been stopped it can not be restarted, so we can deallocate
@@ -4919 +4918 @@
         case PageCache:
             stopWithoutDestroyingMediaPlayer();
+            m_asyncEventQueue.suspend();
+            setShouldBufferData(false);
             m_mediaSession->addBehaviorRestriction(MediaElementSession::RequirePageConsentToResumeMedia);
             break;
@@ -4935 +4936 @@
 
     m_inActiveDocument = true;
+
+    m_asyncEventQueue.resume();
+
+    setShouldBufferData(true);
 
     if (!m_mediaSession->pageAllowsPlaybackAfterResuming(*this))

trunk/Source/WebCore/html/HTMLSourceElement.cpp

@@ -41 +41 @@
 inline HTMLSourceElement::HTMLSourceElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
+    , ActiveDOMObject(&document)
     , m_errorEventTimer(*this, &HTMLSourceElement::errorEventTimerFired)
 {
@@ -49 +50 @@
 Ref<HTMLSourceElement> HTMLSourceElement::create(const QualifiedName& tagName, Document& document)
 {
-    return adoptRef(*new HTMLSourceElement(tagName, document));
+    Ref<HTMLSourceElement> sourceElement = adoptRef(*new HTMLSourceElement(tagName, document));
+    sourceElement->suspendIfNeeded();
+    return sourceElement;
 }
 
@@ -122 +125 @@
 }
 
+const char* HTMLSourceElement::activeDOMObjectName() const
+{
+    return "HTMLSourceElement";
+}
+
+bool HTMLSourceElement::canSuspendForPageCache() const
+{
+    return true;
+}
+
+void HTMLSourceElement::suspend(ReasonForSuspension why)
+{
+    if (why == PageCache) {
+        m_shouldRescheduleErrorEventOnResume = m_errorEventTimer.isActive();
+        m_errorEventTimer.stop();
+    }
+}
+
+void HTMLSourceElement::resume()
+{
+    if (m_shouldRescheduleErrorEventOnResume) {
+        m_errorEventTimer.startOneShot(0);
+        m_shouldRescheduleErrorEventOnResume = false;
+    }
+}
+
+void HTMLSourceElement::stop()
+{
+    cancelPendingErrorEvent();
+}
+
 }
 

trunk/Source/WebCore/html/HTMLSourceElement.h

@@ -33 +33 @@
 namespace WebCore {
 
-class HTMLSourceElement final : public HTMLElement {
+class HTMLSourceElement final : public HTMLElement, public ActiveDOMObject {
 public:
     static Ref<HTMLSourceElement> create(const QualifiedName&, Document&);
@@ -53 +53 @@
     virtual bool isURLAttribute(const Attribute&) const override;
 
+    // ActiveDOMObject.
+    const char* activeDOMObjectName() const override;
+    bool canSuspendForPageCache() const override;
+    void suspend(ReasonForSuspension) override;
+    void resume() override;
+    void stop() override;
+
     void errorEventTimerFired();
 
     Timer m_errorEventTimer;
+    bool m_shouldRescheduleErrorEventOnResume { false };
 };