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 94 matching lines @@
     public:
         virtual ~Client() {}
 
         // HTMLMediaElement
         virtual double currentTime() const = 0;
         virtual double duration() 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;
 
         // Frame
         virtual bool isCrossOrigin() const = 0;
         virtual bool isAutoplayAllowedPerSettings() const = 0;
 
         // LayoutObject
         virtual void setRequestPositionUpdates(bool) = 0;
         virtual IntRect absoluteBoundingBoxRect() const = 0;
 
         DEFINE_INLINE_VIRTUAL_TRACE() { }
     };
 
     static AutoplayExperimentHelper* create(Client* client)
     {
         return new AutoplayExperimentHelper(client);
     }
 
     ~AutoplayExperimentHelper();
 
     void becameReadyToPlay();
-    void playMethodCalled();
+    void playMethodCalled(bool playing);

[mlamouri (slow - plz ping), 2016/05/06 15:05:47]

Could you add a `virtual bool paused() const = 0;` to the Client interface
instead? I think it would be better than passing the Client's state as a
function paramater.

[liberato (no reviews please), 2016/05/17 21:24:33]

Done.

     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 53 matching lines @@
 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