Autoplay experiment metric fixes and additions.

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

 // Copyright 2015 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 "config.h"
 #include "core/html/AutoplayExperimentHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
@@ skipping 13 matching lines @@
 
 // Seconds to wait after a video has stopped moving before playing it.
 static const double kViewportTimerPollDelay = 0.5;
 
 AutoplayExperimentHelper::AutoplayExperimentHelper(HTMLMediaElement& element)
     : m_element(&element)
     , m_mode(Mode::ExperimentOff)
     , m_playPending(false)
     , m_registeredWithLayoutObject(false)
     , m_wasInViewport(false)
+    , m_autoplayMediaCounted(false)
+    , m_initialPlayWithoutUserGesture(false)
+    , m_recordedElement(false)
     , m_lastLocationUpdateTime(-std::numeric_limits<double>::infinity())
     , m_viewportTimer(this, &AutoplayExperimentHelper::viewportTimerFired)
+    , m_autoplayDeferredMetric(GesturelessPlaybackUnknownReason)
 {
     if (document().settings()) {
         m_mode = fromString(document().settings()->autoplayExperimentMode());
 
         if (m_mode != Mode::ExperimentOff) {
             WTF_LOG(Media, "HTMLMediaElement: autoplay experiment set to %d",
                 m_mode);
         }
     }
 }
 
 AutoplayExperimentHelper::~AutoplayExperimentHelper()
 {
     unregisterForPositionUpdatesIfNeeded();
 }
 
 void AutoplayExperimentHelper::becameReadyToPlay()
 {
     // Assuming that we're eligible to override the user gesture requirement,
     // either play if we meet the visibility checks, or install a listener
-    // to wait for them to pass.
+    // to wait for them to pass.  We do not actually start playback; our
+    // caller must do that.
     if (isEligible()) {
         if (meetsVisibilityRequirements())
-            prepareToPlay(GesturelessPlaybackStartedByAutoplayFlagImmediately);
+            prepareToAutoplay(GesturelessPlaybackStartedByAutoplayFlagImmediately);
         else
             registerForPositionUpdatesIfNeeded();
     }
+
+    autoplayMediaEncountered();
 }
 
 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 (!UserGestureIndicator::processingUserGesture()) {
-
         if (isEligible()) {
             // Remember that 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 an event listener if we need one.
             if (meetsVisibilityRequirements()) {
-                // Override the gesture and play.
-                prepareToPlay(GesturelessPlaybackStartedByPlayMethodImmediately);
+                // Override the gesture and assume that play() will succeed.
+                prepareToAutoplay(GesturelessPlaybackStartedByPlayMethodImmediately);
             } else {
                 // Wait for viewport visibility.
                 registerForPositionUpdatesIfNeeded();
             }
         }
 
-    } else if (element().isUserGestureRequiredForPlay()) {
+        // Now that we might have also overridden the gesture requirement,
+        // record the autoplay attempt.
+        autoplayMediaEncountered();
+    } else if (isUserGestureRequiredForPlay()) {
+        if (m_autoplayMediaCounted)
+            recordAutoplayMetric(AutoplayManualStart);
+        // Don't let future gestureless playbacks affect metrics.
+        m_autoplayMediaCounted = true;
+
         unregisterForPositionUpdatesIfNeeded();
     }
 }
 
 void AutoplayExperimentHelper::pauseMethodCalled()
 {
     // Don't try to autoplay, if we would have.
     m_playPending = false;
     unregisterForPositionUpdatesIfNeeded();
+
+    if (!element().paused())
+        recordMetricsBeforePause();
+}
+
+void AutoplayExperimentHelper::loadMethodCalled()
+{
+    if (!element().paused())
+        recordMetricsBeforePause();
+
+    if (UserGestureIndicator::processingUserGesture() && isUserGestureRequiredForPlay()) {
+        recordAutoplayMetric(AutoplayEnabledThroughLoad);
+        element().removeUserGestureRequirement(GesturelessPlaybackEnabledByLoad);
+        // While usergesture-initiated load()s technically count as autoplayed,
+        // they don't feel like such to the users and hence we don't want to
+        // count them for the purposes of metrics.
+        m_autoplayMediaCounted = true;
+    }
 }
 
 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.
     if (!isEligible()) {
         unregisterForPositionUpdatesIfNeeded();
@@ skipping 140 matching lines @@
 }
 
 bool AutoplayExperimentHelper::maybeStartPlaying()
 {
     // See if we're allowed to autoplay now.
     if (!isEligible() || !meetsVisibilityRequirements()) {
         return false;
     }
 
     // Start playing!
-    prepareToPlay(element().shouldAutoplay()
+    prepareToAutoplay(element().shouldAutoplay()
         ? GesturelessPlaybackStartedByAutoplayFlagAfterScroll
         : GesturelessPlaybackStartedByPlayMethodAfterScroll);
+
+    // Record that this played without a user gesture.
+    autoplayMediaEncountered();
+
     element().playInternal();
 
     return true;
 }
 
 bool AutoplayExperimentHelper::isEligible() const
 {
     if (m_mode == Mode::ExperimentOff)
         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 (!element().isUserGestureRequiredForPlay())
+    if (!isUserGestureRequiredForPlay())
         return false;
 
     // Make sure that this is an element of the right type.
     if (!enabled(ForVideo) && isHTMLVideoElement(element()))
         return false;
 
     if (!enabled(ForAudio) && isHTMLAudioElement(element()))
         return false;
 
     // If nobody has requested playback, either by the autoplay attribute or
@@ skipping 20 matching lines @@
 {
     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.
         element().setMuted(true);
     }
 }
 
-void AutoplayExperimentHelper::prepareToPlay(AutoplayMetrics metric)
+void AutoplayExperimentHelper::prepareToAutoplay(AutoplayMetrics metric)
 {
-    element().recordAutoplayMetric(metric);
-
     // This also causes !isEligible, so that we don't allow autoplay more than
     // once.  Be sure to do this before muteIfNeeded().
-    element().removeUserGestureRequirement();
+    // 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 autoplayMediaEncountered() do that later.
+    element().removeUserGestureRequirement(metric);
+
+    // Don't bother to call autoplayMediaEncountered, since whoever initiates
+    // playback has do it anyway, in case we don't allow autoplay.
 
     unregisterForPositionUpdatesIfNeeded();
     muteIfNeeded();
 
-    // 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().
-    element().setInitialPlayWithoutUserGestures(true);
-
     // Do not actually start playback here.
 }
 
 Document& AutoplayExperimentHelper::document() const
 {
     return element().document();
 }
 
 HTMLMediaElement& AutoplayExperimentHelper::element() const
 {
@@ skipping 15 matching lines @@
     if (mode.contains("-ifmuted"))
         value |= IfMuted;
     if (mode.contains("-ifmobile"))
         value |= IfMobile;
     if (mode.contains("-playmuted"))
         value |= PlayMuted;
 
     return value;
 }
 
+void AutoplayExperimentHelper::autoplayMediaEncountered()
+{
+    if (!m_autoplayMediaCounted) {
+        m_autoplayMediaCounted = true;
+        recordAutoplayMetric(AutoplayMediaFound);
+
+        // If no user gesture was required, then assume that playback will
+        // actually start.
+        if (!isUserGestureRequiredForPlay()) {
+            m_initialPlayWithoutUserGesture = true;
+            recordAutoplayMetric(m_autoplayDeferredMetric);
+        }
+    }
 }
+
+void AutoplayExperimentHelper::initialPlayWithUserGesture()
+{
+    m_initialPlayWithoutUserGesture = false;
+}
+
+bool AutoplayExperimentHelper::isUserGestureRequiredForPlay() const
+{
+    return element().isUserGestureRequiredForPlay();
+}
+
+void AutoplayExperimentHelper::recordMetricsBeforePause()
+{
+    ASSERT(!element().paused());
+
+    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(AnyPlaybackPaused);
+    if (bailout)
+        recordAutoplayMetric(AnyPlaybackBailout);
+
+    // If this was a gestureless play, then record that separately.
+    // These cover attr and play() gestureless starts.
+    if (m_initialPlayWithoutUserGesture) {
+        m_initialPlayWithoutUserGesture = false;
+
+        recordAutoplayMetric(AutoplayPaused);
+
+        if (bailout)
+            recordAutoplayMetric(AutoplayBailout);
+    }
+}
+
+void AutoplayExperimentHelper::playbackStarted()
+{
+    recordAutoplayMetric(AnyPlaybackStarted);
+}
+
+void AutoplayExperimentHelper::playbackEnded()
+{
+    recordAutoplayMetric(AnyPlaybackComplete);
+    if (m_initialPlayWithoutUserGesture) {
+        m_initialPlayWithoutUserGesture = false;
+        recordAutoplayMetric(AutoplayComplete);
+    }
+}
+
+void AutoplayExperimentHelper::recordAutoplayMetric(AutoplayMetrics metric)
+{
+    element().recordAutoplayMetric(metric);
+}
+
+bool AutoplayExperimentHelper::isBailout() const
+{
+    // We count the user as having bailed-out on the video if they watched
+    // less than one minute and less than 50% of it.
+    const double playedTime = element().currentTime();
+    const double progress = playedTime / element().duration();
+    return (playedTime < 60) && (progress < 0.5);
+}
+
+void AutoplayExperimentHelper::recordSandboxFailure()
+{
+    // We record autoplayMediaEncountered here because we know
+    // that the autoplay attempt will fail.
+    autoplayMediaEncountered();
+    recordAutoplayMetric(AutoplayDisabledBySandbox);
+}
+
+void AutoplayExperimentHelper::loadingStarted()
+{
+    if (m_recordedElement)
+        return;
+
+    m_recordedElement = true;
+    recordAutoplayMetric(element().isHTMLVideoElement()
+        ? AnyVideoElement : AnyAudioElement);
+}
+
+void AutoplayExperimentHelper::setGestureRemovalReason(AutoplayMetrics deferredMetric)
+{
+    m_autoplayDeferredMetric = deferredMetric;
+}
+
+}