[Video] MediaSession API event handlers can resume background video.

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/HTMLMediaElement.h"
 
+#include <limits>
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLNames.h"
 #include "core/css/MediaList.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/DOMException.h"
+#include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ElementVisibilityObserver.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
@@ skipping 42 matching lines @@
 #include "public/platform/WebMediaPlayerSource.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackClient.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackState.h"
 #include "wtf/AutoReset.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/CString.h"
-#include <limits>
 
 #ifndef BLINK_MEDIA_LOG
 #define BLINK_MEDIA_LOG DVLOG(3)
 #endif
 
 #ifndef LOG_MEDIA_EVENTS
 // Default to not logging events because so many are generated they can
 // overwhelm the rest of the logging.
 #define LOG_MEDIA_EVENTS 0
 #endif
@@ skipping 2197 matching lines @@
 
   setIgnorePreloadNone();
   updatePlayState();
 }
 
 void HTMLMediaElement::pause() {
   BLINK_MEDIA_LOG << "pause(" << (void*)this << ")";
 
   // Only buffer aggressively on a user-initiated pause. Other types of pauses
   // (which go directly to pauseInternal()) should not cause this behavior.
-  if (webMediaPlayer() && UserGestureIndicator::utilizeUserGesture())
+  if (webMediaPlayer() && UserGestureIndicator::utilizeUserGesture()) {
     webMediaPlayer()->setBufferingStrategy(
         WebMediaPlayer::BufferingStrategy::Aggressive);
 
+    // Don't allow webpages to override user-initiated pause.
+    if (hasVideo() && computeLockedPendingUserGesture(document()))
+      m_lockedPendingUserGesture = true;
+  }
+
   if (m_autoplayVisibilityObserver) {
     m_autoplayVisibilityObserver->stop();
     m_autoplayVisibilityObserver = nullptr;
   }
 
   pauseInternal();
 }
 
 void HTMLMediaElement::pauseInternal() {
   BLINK_MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
@@ skipping 781 matching lines @@
   if (requestSeek)
     seek(duration);
 }
 
 void HTMLMediaElement::playbackStateChanged() {
   BLINK_MEDIA_LOG << "playbackStateChanged(" << (void*)this << ")";
 
   if (!webMediaPlayer())
     return;
 
+  // playbackStateChanged() is always a result of a user gesture.
+  UserGestureIndicator gestureIndicator(
+      DocumentUserGestureToken::create(&document()));

[mlamouri (slow - plz ping), 2017/02/17 12:31:31]

You can create the user gesture token from the callers. Why having it here?

[whywhat, 2017/02/17 16:30:24]

So the callers don't know a user gesture. Ideally we'd implement the default
notification in the same way the MediaSession API is implemented - so it would
just call play()/pause() on the HTMLMediaElement with the user gesture token.
However, that change is for another CL.

   if (webMediaPlayer()->paused())
-    pauseInternal();
+    pause();
   else
-    playInternal();
+    play();

[mlamouri (slow - plz ping), 2017/02/17 12:31:31]

I'm not sure I follow the reason why this is no longer calling the internal
methods.

[whywhat, 2017/02/17 16:30:24]

So that we respect the user gesture token and unlock the element back.

 }
 
 void HTMLMediaElement::requestSeek(double time) {
   // The player is the source of this seek request.
   setCurrentTime(time);
 }
 
 void HTMLMediaElement::remoteRouteAvailabilityChanged(
     WebRemotePlaybackAvailability availability) {
   if (remotePlaybackClient())
@@ skipping 41 matching lines @@
 void HTMLMediaElement::cancelledRemotePlaybackRequest() {
   if (remotePlaybackClient())
     remotePlaybackClient()->promptCancelled();
 }
 
 void HTMLMediaElement::remotePlaybackStarted() {
   if (remotePlaybackClient())
     remotePlaybackClient()->stateChanged(WebRemotePlaybackState::Connected);
 }
 
+void HTMLMediaElement::wasBackgrounded() {
+  if (hasVideo() && computeLockedPendingUserGesture(document()))
+    m_lockedPendingUserGesture = true;

[mlamouri (slow - plz ping), 2017/02/17 12:31:31]

We should probably discuss this more but I think this is going to break web
pages. For example, what would happen in the case of YouTube that auto-pauses
when in the background: will they be able to auto-resume when visible again? In
general, we never reset the lock boolean to true so I'm a bit worried about
this.

[whywhat, 2017/02/17 16:30:25]

I want to reuse the user gesture lock to enforce the following:
- user needs to resume playback for the background video to play
- if user pauses the video, website can't override it

I could add another flag to indicate with set the lock to true here or in
pause() while in the background so we reset it to false when foregrounded to
unlock the element back.

The current CL indicates that if the user paused the video in any state by
pressing pause or hiding it, the page won't be able to resume playback without a
gesture.

I should at least check if the video is not paused here, perhaps. If YouTube
pauses the video before this call, then we'd not lock it.

+}
+
 bool HTMLMediaElement::hasSelectedVideoTrack() {
   DCHECK(RuntimeEnabledFeatures::backgroundVideoTrackOptimizationEnabled());
 
   return m_videoTracks && m_videoTracks->selectedIndex() != -1;
 }
 
 WebMediaPlayer::TrackId HTMLMediaElement::getSelectedVideoTrackId() {
   DCHECK(RuntimeEnabledFeatures::backgroundVideoTrackOptimizationEnabled());
   DCHECK(hasSelectedVideoTrack());
 
   int selectedTrackIndex = m_videoTracks->selectedIndex();
   VideoTrack* track = m_videoTracks->anonymousIndexedGetter(selectedTrackIndex);
   return track->id();
 }
 
 bool HTMLMediaElement::isAutoplayingMuted() {
   if (!isHTMLVideoElement() ||
       !RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
     return false;
   }
 
   return !paused() && muted() && isLockedPendingUserGesture();
 }
 
+bool HTMLMediaElement::isBackgroundVideoPlaybackUnlocked() {
+  return !isLockedPendingUserGesture();
+}
+
 void HTMLMediaElement::requestReload(const WebURL& newUrl) {
   DCHECK(webMediaPlayer());
   DCHECK(!m_srcObject);
   DCHECK(newUrl.isValid());
   DCHECK(isSafeToLoadURL(newUrl, Complain));
   resetMediaPlayerAndMediaSource();
   startPlayerLoad(newUrl);
 }
 
 // MediaPlayerPresentation methods
@@ skipping 624 matching lines @@
 bool HTMLMediaElement::isLockedPendingUserGesture() const {
   return m_lockedPendingUserGesture;
 }
 
 void HTMLMediaElement::unlockUserGesture() {
   m_lockedPendingUserGesture = false;
   m_lockedPendingUserGestureIfCrossOriginExperimentEnabled = false;
 }
 
 bool HTMLMediaElement::isGestureNeededForPlayback() const {
-  if (!m_lockedPendingUserGesture)
+  if (!isLockedPendingUserGesture())
     return false;
 
   return isGestureNeededForPlaybackIfPendingUserGestureIsLocked();
 }
 
 bool HTMLMediaElement::
     isGestureNeededForPlaybackIfCrossOriginExperimentEnabled() const {
   if (!m_lockedPendingUserGestureIfCrossOriginExperimentEnabled)
     return false;
 
@@ skipping 281 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::viewportFillDebouncerTimerFired(TimerBase*) {
   m_mostlyFillingViewport = true;
   if (m_webMediaPlayer)
     m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
 }
 
 }  // namespace blink