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

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

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 280 matching lines @@
     {
         return new AutoplayHelperClientImpl(element);
     }
 
     virtual ~AutoplayHelperClientImpl();
 
     using RecordMetricsBehavior = HTMLMediaElement::RecordMetricsBehavior;
 
     double currentTime() const override { return m_element->currentTime(); }
     double duration() const override { return m_element->duration(); }
+    bool paused() const override { return m_element->paused(); }
     bool ended() const override { return m_element->ended(); }
     bool muted() const override { return m_element->muted(); }
     void setMuted(bool muted) override { m_element->setMuted(muted); }
     void playInternal() override { m_element->playInternal(); }
-    bool isUserGestureRequiredForPlay() const override { return m_element->isUserGestureRequiredForPlay(); }
-    void removeUserGestureRequirement() override { m_element->removeUserGestureRequirement(); }
+    bool isLockedPendingUserGesture() const override { return m_element->isLockedPendingUserGesture(); }
+    void unlockUserGesture() override { m_element->unlockUserGesture(); }
     void recordAutoplayMetric(AutoplayMetrics metric) override { m_element->recordAutoplayMetric(metric); }
     bool shouldAutoplay() override
     {
         return m_element->shouldAutoplay(RecordMetricsBehavior::DoNotRecord);
     }
     bool isHTMLVideoElement() const override { return m_element->isHTMLVideoElement(); }
     bool isHTMLAudioElement() const override { return m_element->isHTMLAudioElement(); }
 
     // Document
     bool isLegacyViewportType() override;
@@ skipping 88 matching lines @@
     , m_lastTimeUpdateEventMovieTime(0)
     , m_defaultPlaybackStartPosition(0)
     , m_loadState(WaitingForSource)
     , m_deferredLoadState(NotDeferred)
     , m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired)
     , m_webLayer(nullptr)
     , m_displayMode(Unknown)
     , m_cachedTime(std::numeric_limits<double>::quiet_NaN())
     , m_fragmentEndTime(std::numeric_limits<double>::quiet_NaN())
     , m_pendingActionFlags(0)
-    , m_userGestureRequiredForPlay(false)
+    , m_lockedPendingUserGesture(false)
     , m_playing(false)
     , m_shouldDelayLoadEvent(false)
     , m_haveFiredLoadedData(false)
     , m_autoplaying(true)
     , m_muted(false)
     , m_paused(true)
     , m_seeking(false)
     , m_sentStalledEvent(false)
     , m_ignorePreloadNone(false)
     , m_textTracksVisible(false)
@@ skipping 14 matching lines @@
     , m_remotePlaybackClient(nullptr)
 {
     ThreadState::current()->registerPreFinalizer(this);
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
     // If any experiment is enabled, then we want to enable a user gesture by
     // default, otherwise the experiment does nothing.
     if ((document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         || m_autoplayHelper->isExperimentEnabled()) {
-        m_userGestureRequiredForPlay = true;
+        m_lockedPendingUserGesture = true;
     }
 
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 
     UseCounter::count(document, UseCounter::HTMLMediaElement);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
@@ skipping 545 matching lines @@
     updateVolume();
 
     ASSERT(!m_mediaSource);
 
     bool attemptLoad = true;
 
     bool isStreamOrBlobUrl = source.isMediaStream() || url.protocolIs(mediaSourceBlobProtocol);
     if (isStreamOrBlobUrl) {
         bool isMediaStream = source.isMediaStream() || (source.isURL() && isMediaStreamURL(url.getString()));
         if (isMediaStream) {
-            m_autoplayHelper->removeUserGestureRequirement(GesturelessPlaybackEnabledByStream);
+            m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByStream);
         } else {
             m_mediaSource = HTMLMediaSource::lookup(url.getString());
 
             if (m_mediaSource) {
                 if (!m_mediaSource->attachToElement(this)) {
                     // Forget our reference to the MediaSource, so we leave it alone
                     // while processing remainder of load failure.
                     m_mediaSource = nullptr;
                     attemptLoad = false;
                 }
@@ skipping 586 matching lines @@
             if (isPotentiallyPlaying)
                 scheduleNotifyPlaying();
         }
 
         // Check for autoplay, and record metrics about it if needed.
         if (shouldAutoplay(RecordMetricsBehavior::DoRecord)) {
             // If the autoplay experiment says that it's okay to play now,
             // then don't require a user gesture.
             m_autoplayHelper->becameReadyToPlay();
 
-            if (!m_userGestureRequiredForPlay) {
+            if (!isGestureNeededForPlayback()) {
                 m_paused = false;
                 invalidateCachedTime();
                 scheduleEvent(EventTypeNames::play);
                 scheduleNotifyPlaying();
                 m_autoplaying = false;
             }
         }
 
         scheduleEvent(EventTypeNames::canplaythrough);
 
@@ skipping 405 matching lines @@
     return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::play()
 {
     WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
 
     m_autoplayHelper->playMethodCalled();
 
     if (!UserGestureIndicator::processingUserGesture()) {
-        if (m_userGestureRequiredForPlay) {
+        if (isGestureNeededForPlayback()) {
+            // If playback is deferred, then don't start playback but don't
+            // fail yet either.
+            if (m_autoplayHelper->isPlaybackDeferred())
+                return nullptr;
+
+            // If we're already playing, then this play would do nothing anyway.
+            // Call playInternal to handle scheduling the promise resolution.
+            if (!m_paused) {
+                playInternal();
+                return nullptr;
+            }
+
             recordAutoplayMetric(PlayMethodFailed);
             String message = ExceptionMessages::failedToExecute("play", "HTMLMediaElement", "API can only be initiated by a user gesture.");
             document().addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             return NotAllowedError;
         }
     } else {
         UserGestureIndicator::utilizeUserGesture();
         // We ask the helper to remove the gesture requirement for us, so that
         // it can record the reason.
         Platform::current()->recordAction(UserMetricsAction("Media_Play_WithGesture"));
-        m_autoplayHelper->removeUserGestureRequirement(GesturelessPlaybackEnabledByPlayMethod);
+        m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByPlayMethod);
     }
 
     if (m_error && m_error->code() == MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED)
         return NotSupportedError;
 
     playInternal();
 
     return nullptr;
 }
 
@@ skipping 162 matching lines @@
 
 void HTMLMediaElement::setMuted(bool muted)
 {
     WTF_LOG(Media, "HTMLMediaElement::setMuted(%p, %s)", this, boolString(muted));
 
     if (m_muted == muted)
         return;
 
     m_muted = muted;
 
-    m_autoplayHelper->mutedChanged();
-
     updateVolume();
 
     if (muted)
         Platform::current()->recordAction(UserMetricsAction("Media_Playback_Mute_On"));
     else
         Platform::current()->recordAction(UserMetricsAction("Media_Playback_Mute_Off"));
 
     scheduleEvent(EventTypeNames::volumechange);
 }
 
@@ skipping 1389 matching lines @@
 
     // Enable the first audio track if an audio track hasn't been enabled yet.
     if (audioTracks().length() > 0 && !audioTracks().hasEnabledTrack())
         audioTracks().anonymousIndexedGetter(0)->setEnabled(true);
 
     // Select the first video track if a video track hasn't been selected yet.
     if (videoTracks().length() > 0 && videoTracks().selectedIndex() == -1)
         videoTracks().anonymousIndexedGetter(0)->setSelected(true);
 }
 
-bool HTMLMediaElement::isUserGestureRequiredForPlay() const
+bool HTMLMediaElement::isLockedPendingUserGesture() const
 {
-    return m_userGestureRequiredForPlay;
+    return m_lockedPendingUserGesture;
 }
 
-void HTMLMediaElement::removeUserGestureRequirement()
+void HTMLMediaElement::unlockUserGesture()
 {
-    m_userGestureRequiredForPlay = false;
+    m_lockedPendingUserGesture = false;
+}
+
+bool HTMLMediaElement::isGestureNeededForPlayback() const
+{
+    return m_lockedPendingUserGesture
+        && !m_autoplayHelper->isGestureRequirementOverridden();
 }
 
 void HTMLMediaElement::setNetworkState(NetworkState state)
 {
     if (m_networkState != state) {
         m_networkState = state;
         if (MediaControls* controls = mediaControls())
             controls->networkStateChanged();
     }
 }
@@ skipping 194 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink