Implement autoplay gesture override experiment.

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
@@ skipping 231 matching lines @@
     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
     // it cannot render.
     if (contentMIMEType != "application/octet-stream" || contentTypeCodecs.isEmpty()) {
         WebMimeRegistry::SupportsType supported = Platform::current()->mimeRegistry()->supportsMediaMIMEType(contentMIMEType, contentTypeCodecs, keySystem.lower());
         return supported > WebMimeRegistry::IsNotSupported;
     }
 
     return false;
 }
 
-// These values are used for a histogram. Do not reorder.
-enum AutoplayMetrics {
-    // Media element with autoplay seen.
-    AutoplayMediaFound = 0,
-    // Autoplay enabled and user stopped media play at any point.
-    AutoplayStopped = 1,
-    // Autoplay enabled but user bailed out on media play early.
-    AutoplayBailout = 2,
-    // Autoplay disabled but user manually started media.
-    AutoplayManualStart = 3,
-    // Autoplay was (re)enabled through a user-gesture triggered load()
-    AutoplayEnabledThroughLoad = 4,
-    // Autoplay disabled by sandbox flags.
-    AutoplayDisabledBySandbox = 5,
-    // This enum value must be last.
-    NumberOfAutoplayMetrics,
-};
-
-static void recordAutoplayMetric(AutoplayMetrics metric)
+void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric)
 {
     Platform::current()->histogramEnumeration("Blink.MediaElement.Autoplay", metric, NumberOfAutoplayMetrics);
 }
 
 WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(const ContentType& contentType, const String& keySystem)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
     if (!RuntimeEnabledFeatures::mediaEnabled())
         return WebMimeRegistry::IsNotSupported;
@@ skipping 10 matching lines @@
     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
     // user agent knows it cannot render or is the type "application/octet-stream"
     if (type == "application/octet-stream")
         return WebMimeRegistry::IsNotSupported;
 
     return Platform::current()->mimeRegistry()->supportsMediaMIMEType(type, typeCodecs, system);
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
+class HTMLMediaElement::AutoplayExperimentScrollListener : public EventListener  {
+    public:
+        AutoplayExperimentScrollListener(HTMLMediaElement* element) : EventListener(CPPEventListenerType), m_element(element) { }
+        virtual bool operator==(const EventListener& them)
+        {
+            return &them == this;
+        }
+
+        void handleEvent(ExecutionContext*, Event*) override
+        {
+            if (m_element)
+                m_element->autoplayExperimentMaybeStartPlaying();
+        }
+
+    private:
+        HTMLMediaElement* m_element;
+};
+
 void HTMLMediaElement::setMediaStreamRegistry(URLRegistry* registry)
 {
     ASSERT(!s_mediaStreamRegistry);
     s_mediaStreamRegistry = registry;
 }
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url)
 {
     return s_mediaStreamRegistry ? s_mediaStreamRegistry->contains(url) : false;
 }
@@ skipping 41 matching lines @@
     , m_completelyLoaded(false)
     , m_havePreparedToPlay(false)
     , m_tracksAreReady(true)
     , m_haveVisibleTextTrack(false)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
     , m_isFinalizing(false)
     , m_initialPlayWithoutUserGestures(false)
     , m_autoplayMediaCounted(false)
+    , m_autoplayExperimentPlayPending(false)
+    , m_autoplayExperimentStartedByExperiment(false)
+    , m_autoplayExperimentMode(ExperimentOff)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
 #if ENABLE(WEB_AUDIO)
     , m_audioSourceNode(nullptr)
 #endif
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
     ASSERT(RuntimeEnabledFeatures::mediaEnabled());
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         m_userGestureRequiredForPlay = true;
 
+    if (document.settings()) {
+        const String& autoplayMode = document.settings()->autoplayExperimentMode();
+        if (autoplayMode == "always") {
+            m_autoplayExperimentMode = ExperimentAlways;
+        } else if (autoplayMode == "if-muted") {
+            m_autoplayExperimentMode = ExperimentIfMuted;
+        } else if (autoplayMode == "play-muted") {
+            m_autoplayExperimentMode = ExperimentPlayMuted;
+        }
+
+        if (m_autoplayExperimentMode != ExperimentOff) {
+            WTF_LOG(Media, "HTMLMediaElement: autoplay experiment set to '%s'",
+                autoplayMode.ascii().data());
+        }
+    }
+
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
     WTF_LOG(Media, "HTMLMediaElement::~HTMLMediaElement(%p)", this);
+
+    autoplayExperimentClearScrollListenerIfNeeded();
+
 #if !ENABLE(OILPAN)
     // HTMLMediaElement and m_asyncEventQueue always become unreachable
     // together. So HTMLMediaElement and m_asyncEventQueue are destructed in
     // the same GC. We don't need to close it explicitly in Oilpan.
     m_asyncEventQueue->close();
 
     setShouldDelayLoadEvent(false);
 
     if (m_textTracks)
         m_textTracks->clearOwner();
@@ skipping 1120 matching lines @@
             scheduleEvent(EventTypeNames::canplay);
             if (isPotentiallyPlaying)
                 scheduleEvent(EventTypeNames::playing);
         }
 
         if (m_autoplaying && m_paused && autoplay()) {
             autoplayMediaEncountered();
 
             if (document().isSandboxed(SandboxAutomaticFeatures)) {
                 recordAutoplayMetric(AutoplayDisabledBySandbox);
-            } else if (!m_userGestureRequiredForPlay) {
-                m_paused = false;
-                invalidateCachedTime();
-                scheduleEvent(EventTypeNames::play);
-                scheduleEvent(EventTypeNames::playing);
+            } else {
+                // If the autoplay experiment says that it's okay to play now,
+                // then don't require a user gesture.
+                if (autoplayExperimentIsEligible()) {
+                    if (autoplayExperimentIsVisible()) {
+                        autoplayExperimentPrepareToPlay(AutoplayExperimentStartedByLoad);
+                        // Will play below.
+                    } else {
+                        // Wait for visibility checks to pass.
+                        autoplayExperimentInstallScrollListenerIfNeeded();
+                    }
+                }
+
+                if (!m_userGestureRequiredForPlay) {
+                    m_paused = false;
+                    invalidateCachedTime();
+                    scheduleEvent(EventTypeNames::play);
+                    scheduleEvent(EventTypeNames::playing);
+                }
             }
         }
 
         scheduleEvent(EventTypeNames::canplaythrough);
 
         shouldUpdateDisplayState = true;
     }
 
     if (shouldUpdateDisplayState) {
         updateDisplayState();
@@ skipping 378 matching lines @@
 
 MediaPlayer::Preload HTMLMediaElement::effectivePreloadType() const
 {
     return autoplay() ? MediaPlayer::Auto : preloadType();
 }
 
 void HTMLMediaElement::play()
 {
     WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
 
+    // Set the pending state, even if the play isn't going to be pending.
+    // Eligibility can change if, for example, the mute status changes.
+    // Having this set is okay.
+    m_autoplayExperimentPlayPending = true;
+
     if (!UserGestureIndicator::processingUserGesture()) {
         autoplayMediaEncountered();
+
+        if (autoplayExperimentIsEligible()) {
+            // Remember that m_userGestureRequiredForPlay is required for
+            // us to be eligible for the experiment.
+            // If we are able to override the gesture requirement now, then
+            // do so.  Otherwise, install a scroll listener if we need one.
+            if (autoplayExperimentIsVisible()) {
+                // Override the gesture and play.
+                autoplayExperimentPrepareToPlay(AutoplayExperimentStartedByPlay);
+            } else {
+                // Wait for visibility.
+                autoplayExperimentInstallScrollListenerIfNeeded();
+            }
+        }
+
         if (m_userGestureRequiredForPlay) {
             String message = ExceptionMessages::failedToExecute("play", "HTMLMediaElement", "API can only be initiated by a user gesture.");
             document().executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             return;
         }
     } else if (m_userGestureRequiredForPlay) {
         if (m_autoplayMediaCounted)
             recordAutoplayMetric(AutoplayManualStart);
         m_userGestureRequiredForPlay = false;
+        autoplayExperimentClearScrollListenerIfNeeded();
     }
 
     playInternal();
 }
 
 void HTMLMediaElement::playInternal()
 {
     WTF_LOG(Media, "HTMLMediaElement::playInternal(%p)", this);
 
     // 4.8.10.9. Playing the media resource
@@ skipping 36 matching lines @@
     }
 }
 
 void HTMLMediaElement::gesturelessInitialPlayHalted()
 {
     ASSERT(m_initialPlayWithoutUserGestures);
     m_initialPlayWithoutUserGestures = false;
 
     recordAutoplayMetric(AutoplayStopped);
 
+    if (m_autoplayExperimentStartedByExperiment)
+        recordAutoplayMetric(AutoplayExperimentStopped);
+
     // We count the user as having bailed-out on the video if they watched
     // less than one minute and less than 50% of it.
     double playedTime = currentTime();
     if (playedTime < 60) {
         double progress = playedTime / duration();
-        if (progress < 0.5)
+        if (progress < 0.5) {
             recordAutoplayMetric(AutoplayBailout);
+            // If this autoplay was started by the experiment, then record
+            // that separately.
+            if (m_autoplayExperimentStartedByExperiment)
+                recordAutoplayMetric(AutoplayExperimentBailout);
+        }
     }
 }
 
 void HTMLMediaElement::pause()
 {
     WTF_LOG(Media, "HTMLMediaElement::pause(%p)", this);
 
     if (!m_player || m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
+    // Don't try to autoplay, if we would have.
+    m_autoplayExperimentPlayPending = false;
+    autoplayExperimentClearScrollListenerIfNeeded();
+
     m_autoplaying = false;
 
     if (!m_paused) {
         if (m_initialPlayWithoutUserGestures)
             gesturelessInitialPlayHalted();
 
         m_paused = true;
         scheduleTimeupdateEvent(false);
         scheduleEvent(EventTypeNames::pause);
     }
@@ skipping 77 matching lines @@
 
 void HTMLMediaElement::setMuted(bool muted)
 {
     WTF_LOG(Media, "HTMLMediaElement::setMuted(%p, %s)", this, boolString(muted));
 
     if (m_muted == muted)
         return;
 
     m_muted = muted;
 
+    // If we are no longer eligible for the autoplay experiment, then also
+    // quit listening to scroll events.  If we are eligible, and if we should
+    // be playing, then start playing.  In other words, start playing if
+    // we just needed 'mute' to autoplay.
+    if (!autoplayExperimentIsEligible()) {
+        autoplayExperimentClearScrollListenerIfNeeded();
+    } else {
+        // Try to play.  If we can't, then install a visibility listener.
+        if (!autoplayExperimentMaybeStartPlaying())
+            autoplayExperimentInstallScrollListenerIfNeeded();
+    }
+
     updateVolume();
 
     scheduleEvent(EventTypeNames::volumechange);
 }
 
 void HTMLMediaElement::updateVolume()
 {
     if (webMediaPlayer())
         webMediaPlayer()->setVolume(effectiveMediaVolume());
 
@@ skipping 1584 matching lines @@
 }
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!Heap::isHeapObjectAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(nullptr);
 }
 #endif
 
+void HTMLMediaElement::autoplayExperimentInstallScrollListenerIfNeeded()
+{
+    if (document().domWindow() && !m_autoplayExperimentScrollListener)  {
+        m_autoplayExperimentScrollListener = adoptRef(new AutoplayExperimentScrollListener(this));
+        document().domWindow()->addEventListener("scroll", m_autoplayExperimentScrollListener, false);

[philipj_slow, 2015/07/21 12:51:29]

I take it this will prevent smooth scrolling while dragging with the finger over
the video? There must be some way of learning about scrolling without falling of
the fast scrolling path?

[liberato (no reviews please), 2015/07/27 06:03:09]

good point.  we really only care if it ends up in view, not happens to scroll
by.

however, i wasn't able to find much else that catches all the cases of
scrolling.  the next CL will focus on touch end / cancel and poll a few times to
find the end of any inertial scroll.  scrollIntoView() won't be noticed, and
similar.

i'll collect some feedback on whether this is a reasonable approximation.  for
now, let's assume that it is.

[Rick Byers, 2015/08/05 14:27:59]

Listening to scroll events doesn't "prevent smooth scrolling".  scroll events
are async and don't block threaded scrolling (although they do tweak some
scheduler settings, but if that's visibly observable then it's probably a
schedule bug and not your issue).  Most major mobile websites have scroll
listeners on the document anyway, so adding one more isn't really a problem - as
long as you're careful to not do much work or dirty layout etc.

Touch event handlers, on the other hand, do block the start of scrolling.  In
general it's preferable to watch 'scroll' than lower level input like 'touch*',
'wheel', etc.

[philipj_slow, 2015/08/05 14:40:12]

Oh... http://rbyers.github.io/EventListenerOptions/EventListenerOptions.html
mentions "wheel" and but I remembered it as "scroll".

In that case, all of this will be much nicer. Is there a way to know for sure
that a scroll has ended?

+    }
 }
+
+void HTMLMediaElement::autoplayExperimentClearScrollListenerIfNeeded()
+{
+    if (m_autoplayExperimentScrollListener) {
+        LocalDOMWindow* domWindow = document().domWindow();
+        if (domWindow) {
+            domWindow->removeEventListener("scroll", m_autoplayExperimentScrollListener, false);
+        }
+        // Either way, clear our ref.
+        m_autoplayExperimentScrollListener.clear();
+    }
+}
+
+bool HTMLMediaElement::autoplayExperimentIsVisible()
+{
+    // We could check for eligibility here, but we skip it.  Some of our
+    // callers need to do it separately, and we don't want to check more
+    // than we need to.
+
+    // Autoplay is requested, and we're willing to override if the visibility
+    // requirements are met.
+
+    // Check visibility.
+    const LocalDOMWindow* domWindow = document().domWindow();
+    if (!domWindow)
+        return false;
+
+    FloatRect us(offsetLeft(), offsetTop(), clientWidth(), clientHeight());
+    FloatRect screen(domWindow->scrollX(), domWindow->scrollY(), domWindow->innerWidth(), domWindow->innerHeight());
+
+    return screen.contains(us);
+}
+
+bool HTMLMediaElement::autoplayExperimentMaybeStartPlaying()
+{
+    // Make sure that we're eligible and visible.
+    if (!autoplayExperimentIsEligible() || !autoplayExperimentIsVisible()) {
+        return false;
+    }
+
+    // Start playing!
+    autoplayExperimentPrepareToPlay(AutoplayExperimentStartedByScroll);
+    // Why are we always preparing?  Just go!
+    playInternal();
+
+    return true;
+}
+
+bool HTMLMediaElement::autoplayExperimentIsEligible() const
+{
+    // If no user gesture is required, then the experiment doesn't apply.
+    // This is what prevents us from starting playback more than once.
+    // Since this flag is never set to true once it's cleared, it will block
+    // the autoplay experiment forever.
+    if (!m_userGestureRequiredForPlay)
+        return false;
+
+    if (m_autoplayExperimentMode == ExperimentOff)
+        return false;
+
+    // If nobody has requested playback, either by the autoplay attribute or
+    // a play() call, then do nothing.
+    if (!m_autoplayExperimentPlayPending && !autoplay())
+        return false;
+
+    // If the video is already playing, then do nothing.  Note that there
+    // is not a path where a user gesture is required but the video is
+    // playing.  However, we check for completeness.
+    if (!m_paused)
+        return false;
+
+    // Note that the viewport test always returns false on desktop.  For
+    // tests, we allow an override.
+    const bool optimizedForMobile = document().viewportDescription().isLegacyViewportType()
+        || (document().settings() && document().settings()->overrideOptimizedForMobileCheck());
+
+    if (!optimizedForMobile)
+        return false;
+
+    if (m_autoplayExperimentMode == ExperimentIfMuted) {
+        // If media is muted, then autoplay when it comes into view.
+        return fastHasAttribute(mutedAttr) || m_muted;
+    }
+
+    // Autoplay when it comes into view, maybe muted.
+    return true;
+}
+
+void HTMLMediaElement::autoplayExperimentMuteIfNeeded()
+{
+    if (m_autoplayExperimentMode == ExperimentPlayMuted) {
+        m_muted = true;
+        updateVolume();
+    }
+}
+
+void HTMLMediaElement::autoplayExperimentPrepareToPlay(AutoplayMetrics metric)
+{
+    recordAutoplayMetric(metric);
+
+    // This also causes !autoplayExperimentIsEligible, so that we don't
+    // allow autoplay more than once.
+    m_userGestureRequiredForPlay = false;
+
+    m_autoplayExperimentStartedByExperiment = true;
+    autoplayExperimentClearScrollListenerIfNeeded();
+    autoplayExperimentMuteIfNeeded();
+
+    // Record that this autoplayed without a user gesture.  This is normally
+    // set when we discover an autoplay attribute, but we include all cases
+    // where playback started without a user gesture, e.g., play().
+    m_initialPlayWithoutUserGestures = true;
+}
+
+}