Don't remove the gesture requirement in the autoplay experiment.

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/html/AutoplayExperimentHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/layout/LayoutBox.h"
@@ skipping 13 matching lines @@
 static const double kViewportTimerPollDelay = 0.5;
 
 AutoplayExperimentHelper::AutoplayExperimentHelper(Client* client)
     : m_client(client)
     , m_mode(Mode::ExperimentOff)
     , m_playPending(false)
     , m_registeredWithLayoutObject(false)
     , m_wasInViewport(false)
     , m_autoplayMediaEncountered(false)
     , m_playbackStartedMetricRecorded(false)
-    , m_waitingForAutoplayPlaybackEnd(false)
+    , m_waitingForAutoplayPlaybackStop(false)
     , m_recordedElement(false)
     , m_lastLocationUpdateTime(-std::numeric_limits<double>::infinity())
     , m_viewportTimer(this, &AutoplayExperimentHelper::viewportTimerFired)
     , m_autoplayDeferredMetric(GesturelessPlaybackNotOverridden)
 {
     m_mode = fromString(this->client().autoplayExperimentMode());
 
     if (isExperimentEnabled()) {
         WTF_LOG(Media, "HTMLMediaElement: autoplay experiment set to %d",
             m_mode);
@@ skipping 21 matching lines @@
     if (isEligible()) {
         if (meetsVisibilityRequirements())
             prepareToAutoplay(GesturelessPlaybackStartedByAutoplayFlagImmediately);
         else
             registerForPositionUpdatesIfNeeded();
     }
 }
 
 void AutoplayExperimentHelper::playMethodCalled()
 {
-    // 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_playPending = true;
+    // If a play is already pending, then do nothing.  We're already trying
+    // to play.  Similarly, do nothing if we're already playing.
+    if (m_playPending || !m_client->paused())
+        return;
 
     if (!UserGestureIndicator::utilizeUserGesture()) {
         autoplayMediaEncountered();
 
-        if (isEligible()) {
-            // Remember that userGestureRequiredForPlay is required for
-            // us to be eligible for the experiment.
+        // Check for eligibility, but don't worry if playback is currently
+        // pending.  If we're still not eligible, then this play() will fail.
+        if (isEligible(IgnorePendingPlayback)) {
+            m_playPending = true;
+
             // If we are able to override the gesture requirement now, then
             // do so.  Otherwise, install an event listener if we need one.
+            // We do not actually start playback; play() will do that.
             if (meetsVisibilityRequirements()) {
                 // Override the gesture and assume that play() will succeed.
                 prepareToAutoplay(GesturelessPlaybackStartedByPlayMethodImmediately);
             } else {
                 // Wait for viewport visibility.
+                // TODO(liberato): if the autoplay is allowed soon enough, then
+                // it should still record *Immediately.  Otherwise, we end up
+                // here before the first layout sometimes, when the item is
+                // visible but we just don't know that yet.
                 registerForPositionUpdatesIfNeeded();
             }
         }
-    } else if (isUserGestureRequiredForPlay()) {
+    } else if (isLockedPendingUserGesture()) {
         // If this media tried to autoplay, and we haven't played it yet, then
         // record that the user provided the gesture to start it the first time.
         if (m_autoplayMediaEncountered && !m_playbackStartedMetricRecorded)
             recordAutoplayMetric(AutoplayManualStart);
         // Don't let future gestureless playbacks affect metrics.
         m_autoplayMediaEncountered = true;
         m_playbackStartedMetricRecorded = true;
+        m_playPending = false;
 
         unregisterForPositionUpdatesIfNeeded();
     }
 }
 
 void AutoplayExperimentHelper::pauseMethodCalled()
 {
     // Don't try to autoplay, if we would have.
     m_playPending = false;
     unregisterForPositionUpdatesIfNeeded();
 }
 
 void AutoplayExperimentHelper::loadMethodCalled()
 {
-    if (isUserGestureRequiredForPlay() && UserGestureIndicator::utilizeUserGesture()) {
+    if (isLockedPendingUserGesture() && UserGestureIndicator::utilizeUserGesture()) {
         recordAutoplayMetric(AutoplayEnabledThroughLoad);
-        removeUserGestureRequirement(GesturelessPlaybackEnabledByLoad);
+        unlockUserGesture(GesturelessPlaybackEnabledByLoad);
     }
 }
 
-void AutoplayExperimentHelper::mutedChanged()
-{
-    // If we are no longer eligible for the autoplay experiment, then also
-    // quit listening for 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.
-
-    // Make sure that autoplay was actually deferred.  If, for example, the
-    // autoplay attribute is set after the media is ready to play, then it
-    // would normally have no effect.  We don't want to start playing.
-    if (!m_autoplayMediaEncountered)
-        return;
-
-    if (!isEligible()) {
-        unregisterForPositionUpdatesIfNeeded();
-    } else {
-        // Try to play.  If we can't, then install a listener.
-        if (!maybeStartPlaying())
-            registerForPositionUpdatesIfNeeded();
-    }
-}
-
 void AutoplayExperimentHelper::registerForPositionUpdatesIfNeeded()
 {
     // If we don't require that the player is in the viewport, then we don't
     // need the listener.
     if (!requiresViewportVisibility()) {
         if (!enabled(IfPageVisible))
             return;
     }
 
     m_client->setRequestPositionUpdates(true);
@@ skipping 111 matching lines @@
         currentLocation.setY(m_lastVisibleRect.y());
         currentLocation.setHeight(m_lastVisibleRect.height());
     }
 
     return m_lastVisibleRect.contains(currentLocation);
 }
 
 bool AutoplayExperimentHelper::maybeStartPlaying()
 {
     // See if we're allowed to autoplay now.
-    if (!isEligible() || !meetsVisibilityRequirements()) {
+    if (!isGestureRequirementOverridden())
         return false;
-    }
 
     // Start playing!
     prepareToAutoplay(client().shouldAutoplay()
         ? GesturelessPlaybackStartedByAutoplayFlagAfterScroll
         : GesturelessPlaybackStartedByPlayMethodAfterScroll);
 
     // Record that this played without a user gesture.
     // This should rarely actually do anything.  Usually, playMethodCalled()
     // and becameReadyToPlay will handle it, but toggling muted state can,
     // in some cases, also trigger autoplay if the autoplay attribute is set
     // after the media is ready to play.
     autoplayMediaEncountered();
 
     client().playInternal();
 
     return true;
 }
 
-bool AutoplayExperimentHelper::isEligible() const
+bool AutoplayExperimentHelper::isGestureRequirementOverridden() const
+{
+    return isEligible() && meetsVisibilityRequirements();
+}
+
+bool AutoplayExperimentHelper::isPlaybackDeferred() const
+{
+    return m_playPending;
+}
+
+bool AutoplayExperimentHelper::isEligible(EligibilityMode mode) const
 {
     if (m_mode == Mode::ExperimentOff)
         return false;
 
     // If autoplay is disabled, no one is eligible.
     if (!client().isAutoplayAllowedPerSettings())
         return false;
 
     // 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 (!isUserGestureRequiredForPlay())
+    if (!isLockedPendingUserGesture())
         return false;
 
     // Make sure that this is an element of the right type.
     if (!enabled(ForVideo) && client().isHTMLVideoElement())
         return false;
 
     if (!enabled(ForAudio) && client().isHTMLAudioElement())
         return false;
 
     // If nobody has requested playback, either by the autoplay attribute or
     // a play() call, then do nothing.
 
-    if (!m_playPending && !client().shouldAutoplay())
+    if (mode !=  IgnorePendingPlayback && !m_playPending && !client().shouldAutoplay())
         return false;
 
     // Note that the viewport test always returns false on desktop, which is
     // why video-autoplay-experiment.html doesn't check -ifmobile .
     if (enabled(IfMobile)
         && !client().isLegacyViewportType())
         return false;
 
     // If we require same-origin, then check the origin.
     if (enabled(IfSameOrigin) && client().isCrossOrigin())
         return false;
 
     // If we require muted media and this is muted, then it is eligible.
     if (enabled(IfMuted))
         return client().muted();
 
     // Element is eligible for gesture override, maybe muted.
     return true;
 }
 
 void AutoplayExperimentHelper::muteIfNeeded()
 {
-    if (enabled(PlayMuted)) {
-        ASSERT(!isEligible());
-        // If we are actually changing the muted state, then this will call
-        // mutedChanged().  If isEligible(), then mutedChanged() will try
-        // to start playback, which we should not do here.
+    if (enabled(PlayMuted))
         client().setMuted(true);
-    }
 }
 
-void AutoplayExperimentHelper::removeUserGestureRequirement(AutoplayMetrics metric)
+void AutoplayExperimentHelper::unlockUserGesture(AutoplayMetrics metric)
 {
-    if (client().isUserGestureRequiredForPlay()) {
-        m_autoplayDeferredMetric = metric;
-        client().removeUserGestureRequirement();
-    }
+    // Note that this could be moved back into HTMLMediaElement fairly easily.
+    // It's only here so that we can record the reason, and we can hide the
+    // ordering between unlocking and recording from the element this way.
+    if (!client().isLockedPendingUserGesture())
+        return;
+
+    setDeferredOverrideReason(metric);
+    client().unlockUserGesture();
+}
+
+void AutoplayExperimentHelper::setDeferredOverrideReason(AutoplayMetrics metric)
+{
+    // If the player is unlocked, then we don't care about any later reason.
+    if (!client().isLockedPendingUserGesture())
+        return;
+
+    m_autoplayDeferredMetric = metric;
 }
 
 void AutoplayExperimentHelper::prepareToAutoplay(AutoplayMetrics metric)
 {
     // This also causes !isEligible, so that we don't allow autoplay more than
     // once.  Be sure to do this before muteIfNeeded().
     // Also note that, at this point, we know that we're goint to start
     // playback.  However, we still don't record the metric here.  Instead,
     // we let playbackStarted() do that later.
-    removeUserGestureRequirement(metric);
+    setDeferredOverrideReason(metric);
 
     // Don't bother to call autoplayMediaEncountered, since whoever initiates
     // playback has do it anyway, in case we don't allow autoplay.
 
     unregisterForPositionUpdatesIfNeeded();
     muteIfNeeded();
 
     // Do not actually start playback here.
 }
 
@@ skipping 28 matching lines @@
 }
 
 void AutoplayExperimentHelper::autoplayMediaEncountered()
 {
     if (!m_autoplayMediaEncountered) {
         m_autoplayMediaEncountered = true;
         recordAutoplayMetric(AutoplayMediaFound);
     }
 }
 
-bool AutoplayExperimentHelper::isUserGestureRequiredForPlay() const
+bool AutoplayExperimentHelper::isLockedPendingUserGesture() const
 {
-    return client().isUserGestureRequiredForPlay();
+    return client().isLockedPendingUserGesture();
 }
 
 void AutoplayExperimentHelper::playbackStarted()
 {
     recordAutoplayMetric(AnyPlaybackStarted);
 
+    // Forget about our most recent visibility check.  If another override is
+    // requested, then we'll have to refresh it.  That way, we don't need to
+    // keep it up to date in the interim.
+    m_lastVisibleRect = IntRect();
+    m_wasInViewport = false;
+
+    // Any pending play is now playing.
+    m_playPending = false;
+
     if (m_playbackStartedMetricRecorded)
         return;
 
+    // Whether we record anything or not, we only want to record metrics for
+    // the initial playback.
     m_playbackStartedMetricRecorded = true;
 
-    // If this is a gestureless start, record why it was allowed.
-    if (!UserGestureIndicator::processingUserGesture()) {
-        m_waitingForAutoplayPlaybackEnd = true;
+    // If this is a gestureless start, then record why it was allowed.
+    if (m_autoplayMediaEncountered) {
+        m_waitingForAutoplayPlaybackStop = true;
         recordAutoplayMetric(m_autoplayDeferredMetric);
     }
 }
 
 void AutoplayExperimentHelper::playbackStopped()
 {
     const bool ended = client().ended();
     const bool bailout = isBailout();
 
     // Record that play was paused.  We don't care if it was autoplay,
     // play(), or the user manually started it.
     recordAutoplayMetric(ended ? AnyPlaybackComplete : AnyPlaybackPaused);
     if (bailout)
         recordAutoplayMetric(AnyPlaybackBailout);
 
     // If this was a gestureless play, then record that separately.
     // These cover attr and play() gestureless starts.
-    if (m_waitingForAutoplayPlaybackEnd) {
-        m_waitingForAutoplayPlaybackEnd = false;
+    if (m_waitingForAutoplayPlaybackStop) {
+        m_waitingForAutoplayPlaybackStop = false;
 
         recordAutoplayMetric(ended ? AutoplayComplete : AutoplayPaused);
 
         if (bailout)
             recordAutoplayMetric(AutoplayBailout);
     }
 }
 
 void AutoplayExperimentHelper::recordAutoplayMetric(AutoplayMetrics metric)
 {
@@ skipping 32 matching lines @@
 {
     return client().isHTMLVideoElement() && (enabled(IfViewport) || enabled(IfPartialViewport));
 }
 
 bool AutoplayExperimentHelper::isExperimentEnabled()
 {
     return m_mode != Mode::ExperimentOff;
 }
 
 } // namespace blink