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

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

 // 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.
 
 #ifndef AutoplayExperimentHelper_h
 #define AutoplayExperimentHelper_h
 
 #include "core/page/Page.h"
 #include "platform/Timer.h"
 #include "platform/geometry/IntRect.h"
@@ skipping 90 matching lines @@
 
 public:
     // For easier testing, collect all the things we care about here.
     class Client : public GarbageCollectedFinalized<Client> {
     public:
         virtual ~Client() {}
 
         // HTMLMediaElement
         virtual double currentTime() const = 0;
         virtual double duration() const = 0;
+        virtual bool paused() const = 0;
         virtual bool ended() const = 0;
         virtual bool muted() const = 0;
         virtual void setMuted(bool) = 0;
         virtual void playInternal() = 0;
-        virtual bool isUserGestureRequiredForPlay() const = 0;
-        virtual void removeUserGestureRequirement() = 0;
+        virtual bool isLockedPendingUserGesture() const = 0;
+        virtual void unlockUserGesture() = 0;
         virtual void recordAutoplayMetric(AutoplayMetrics) = 0;
         virtual bool shouldAutoplay() = 0;
         virtual bool isHTMLVideoElement() const = 0;
         virtual bool isHTMLAudioElement() const = 0;
 
         // Document
         virtual bool isLegacyViewportType() = 0;
         virtual PageVisibilityState pageVisibilityState() const = 0;
         virtual String autoplayExperimentMode() const = 0;
 
@@ skipping 12 matching lines @@
     {
         return new AutoplayExperimentHelper(client);
     }
 
     ~AutoplayExperimentHelper();
 
     void becameReadyToPlay();
     void playMethodCalled();
     void pauseMethodCalled();
     void loadMethodCalled();
-    void mutedChanged();
     void positionChanged(const IntRect&);
     void updatePositionNotificationRegistration();
     void recordSandboxFailure();
     void loadingStarted();
     void playbackStarted();
     void playbackStopped();
     void initialPlayWithUserGesture();
 
     // Returns true if and only if any experiment is enabled (i.e., |m_mode|
     // is not ExperimentOff).
     bool isExperimentEnabled();
 
     // Clean up.  For Oilpan, this means "early in HTMLMediaElement's dispose".
     // For non-Oilpan, just delete the object.
     void dispose();
 
     // Remove the user gesture requirement, and record why.  If there is no
     // gesture requirement, then this does nothing.
-    void removeUserGestureRequirement(AutoplayMetrics);
+    void unlockUserGesture(AutoplayMetrics);
+
+    // Set the reason that we're overridding the user gesture.  If there is no
+    // gesture requirement, then this does nothing.
+    void setDeferredOverrideReason(AutoplayMetrics);
+
+    // Return true if and only if the user gesture requirement is currently
+    // overridden by the experiment, permitting playback.
+    bool isGestureRequirementOverridden() const;
+
+    // Return true if and only if playback is queued but hasn't started yet,
+    // such as if the element doesn't meet visibility requirements.
+    bool isPlaybackDeferred() const;
 
     // Set the position to the current view's position, and
     void triggerAutoplayViewportCheckForTesting();
 
     enum Mode {
         // Do not enable the autoplay experiment.
         ExperimentOff     = 0,
         // Enable gestureless autoplay for video elements.
         ForVideo          = 1 << 0,
         // Enable gestureless autoplay for audio elements.
@@ skipping 24 matching lines @@
 private:
     explicit AutoplayExperimentHelper(Client*);
 
     // Register to receive position updates, if we haven't already.  If we
     // have, then this does nothing.
     void registerForPositionUpdatesIfNeeded();
 
     // Un-register for position updates, if we are currently registered.
     void unregisterForPositionUpdatesIfNeeded();
 
+    // Modifiers for checking isEligible().
+    enum EligibilityMode {
+        // Perform all normal eligibility checks.
+        Normal = 0,
+
+        // Perform normal eligibility checks, but skip checking if autoplay has
+        // actually been requested.  In other words, don't fail just becase
+        // nobody has called play() and/or set the autoplay attribute.
+        IgnorePendingPlayback = 1
+    };
+
     // Return true if any only if this player meets (most) of the eligibility
     // requirements for the experiment to override the need for a user
     // gesture.  This includes everything except the visibility test.
-    bool isEligible() const;
+    // |mode| modifies the eligibility check, as described above.
+    bool isEligible(EligibilityMode = Normal) const;
 
     // Return false if and only if m_element is not visible, and we care
     // that it must be visible.
     bool meetsVisibilityRequirements() const;
 
     // Set the muted flag on the media if we're in an experiment mode that
     // requires it, else do nothing.
     void muteIfNeeded();
 
     // Maybe override the requirement for a user gesture, and start playing
@@ skipping 15 matching lines @@
     void recordMetricsBeforePause();
 
     // Process a timer for checking visibility.
     void viewportTimerFired(Timer<AutoplayExperimentHelper>*);
 
     // Return our media element's document.
     Document& document() const;
 
     Client& client() const;
 
-    bool isUserGestureRequiredForPlay() const;
+    bool isLockedPendingUserGesture() const;
 
     inline bool enabled(Mode mode) const
     {
         return ((int)m_mode) & ((int)mode);
     }
 
     Mode fromString(const String& mode);
 
     void recordAutoplayMetric(AutoplayMetrics);
 
@@ skipping 23 matching lines @@
     // a media element tries to autoplay, and we record that via the
     // AutoplayMediaFound metric.
     bool m_autoplayMediaEncountered : 1;
 
     // Have we recorded a metric about the cause of the initial playback of
     // this media yet?
     bool m_playbackStartedMetricRecorded : 1;
 
     // Is the current playback the result of autoplay?  If so, then this flag
     // records that the pause / stop should be counted in the autoplay metrics.
-    bool m_waitingForAutoplayPlaybackEnd : 1;
+    bool m_waitingForAutoplayPlaybackStop : 1;
 
     // Did we record that this media element exists in the metrics yet?  This is
     // independent of whether it autoplays; we just want to know how many
     // elements exist for the Any{Audio|Video}Element metrics.
     bool m_recordedElement : 1;
 
     // According to our last position update, where was our element?
     IntRect m_lastLocation;
     IntRect m_lastVisibleRect;
 
     // When was m_lastLocation set?
     double m_lastLocationUpdateTime;
 
     Timer<AutoplayExperimentHelper> m_viewportTimer;
 
     // Reason that autoplay would be allowed to proceed without a user gesture.
     AutoplayMetrics m_autoplayDeferredMetric;
 };
 
 inline AutoplayExperimentHelper::Mode& operator|=(AutoplayExperimentHelper::Mode& a,
     const AutoplayExperimentHelper::Mode& b)
 {
     a = static_cast<AutoplayExperimentHelper::Mode>(static_cast<int>(a) | static_cast<int>(b));
     return a;
 }
 
 } // namespace blink
 
 #endif // AutoplayExperimentHelper_h