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 35 matching lines @@
 
 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();
     }
 }
 
 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);
+                prepareToAutoplay(GesturelessPlaybackStartedByPlayMethodImmediately);
             } else {
                 // Wait for viewport visibility.
                 registerForPositionUpdatesIfNeeded();
             }
         }
-
     } else if (element().isUserGestureRequiredForPlay()) {
         unregisterForPositionUpdatesIfNeeded();
     }
 }
 
 void AutoplayExperimentHelper::pauseMethodCalled()
 {
     // Don't try to autoplay, if we would have.
     m_playPending = false;
     unregisterForPositionUpdatesIfNeeded();
@@ skipping 150 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.
+    element().autoplayMediaEncountered();
+
     element().playInternal();
 
     return true;
 }
 
 bool AutoplayExperimentHelper::isEligible() const
 {
     if (m_mode == Mode::ExperimentOff)
         return false;
 
@@ skipping 35 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();
+    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 16 matching lines @@
         value |= IfMuted;
     if (mode.contains("-ifmobile"))
         value |= IfMobile;
     if (mode.contains("-playmuted"))
         value |= PlayMuted;
 
     return value;
 }
 
 }