[Blink>Media] Moving autoplay logic to AutoplayPolicy

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
@@ skipping 20 matching lines @@
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLNames.h"
 #include "core/css/MediaList.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
-#include "core/dom/ElementVisibilityObserver.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
-#include "core/frame/ContentSettingsClient.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/HTMLTrackElement.h"
 #include "core/html/TimeRanges.h"
+#include "core/html/media/AutoplayPolicy.h"
 #include "core/html/media/AutoplayUmaHelper.h"
 #include "core/html/media/HTMLMediaElementControlsList.h"
 #include "core/html/media/HTMLMediaSource.h"
 #include "core/html/media/MediaControls.h"
 #include "core/html/media/MediaError.h"
 #include "core/html/media/MediaFragmentURIParser.h"
 #include "core/html/track/AudioTrack.h"
 #include "core/html/track/AudioTrackList.h"
 #include "core/html/track/AutomaticTrackSelection.h"
 #include "core/html/track/CueTimeline.h"
@@ skipping 260 matching lines @@
     case WebMediaPlayer::kPreloadMetaData:
       return "metadata";
     case WebMediaPlayer::kPreloadAuto:
       return "auto";
   }
 
   NOTREACHED();
   return String();
 }
 
-bool IsDocumentCrossOrigin(Document& document) {
-  const LocalFrame* frame = document.GetFrame();
-  return frame && frame->IsCrossOriginSubframe();
-}
-
-bool IsDocumentWhitelisted(Document& document) {
-  DCHECK(document.GetSettings());
-
-  const String& whitelist_scope =
-      document.GetSettings()->GetMediaPlaybackGestureWhitelistScope();
-  if (whitelist_scope.IsNull() || whitelist_scope.IsEmpty())
-    return false;
-
-  return document.Url().GetString().StartsWith(whitelist_scope);
-}
-
-// Return true if and only if the document settings specifies media playback
-// requires user gesture.
-bool ComputeLockedPendingUserGesture(Document& document) {
-  if (!document.GetSettings())
-    return false;
-
-  if (IsDocumentWhitelisted(document)) {
-    return false;
-  }
-
-  if (document.GetSettings()
-          ->GetCrossOriginMediaPlaybackRequiresUserGesture() &&
-      IsDocumentCrossOrigin(document)) {
-    return true;
-  }
-
-  return document.GetSettings()->GetMediaPlaybackRequiresUserGesture();
-}
-
 std::unique_ptr<MediaControls::Factory>& MediaControlsFactory() {
   DEFINE_STATIC_LOCAL(std::unique_ptr<MediaControls::Factory>,
                       media_controls_factory, ());
   return media_controls_factory;
 }
 
 }  // anonymous namespace
 
 MIMETypeRegistry::SupportsType HTMLMediaElement::GetSupportsType(
     const ContentType& content_type) {
@@ skipping 117 matching lines @@
       deferred_load_timer_(
           TaskRunnerHelper::Get(TaskType::kUnthrottled, &document),
           this,
           &HTMLMediaElement::DeferredLoadTimerFired),
       web_layer_(nullptr),
       display_mode_(kUnknown),
       official_playback_position_(0),
       official_playback_position_needs_update_(true),
       fragment_end_time_(std::numeric_limits<double>::quiet_NaN()),
       pending_action_flags_(0),
-      locked_pending_user_gesture_(false),
-      locked_pending_user_gesture_if_cross_origin_experiment_enabled_(true),
       playing_(false),
       should_delay_load_event_(false),
       have_fired_loaded_data_(false),
       can_autoplay_(true),
       muted_(false),
       paused_(true),
       seeking_(false),
       sent_stalled_event_(false),
       ignore_preload_none_(false),
       text_tracks_visible_(false),
       should_perform_automatic_track_selection_(true),
       tracks_are_ready_(true),
       processing_preference_change_(false),
       playing_remotely_(false),
       in_overlay_fullscreen_video_(false),
       mostly_filling_viewport_(false),
       audio_tracks_(this, AudioTrackList::Create(*this)),
       video_tracks_(this, VideoTrackList::Create(*this)),
       text_tracks_(this, nullptr),
       audio_source_node_(nullptr),
+      autoplay_policy_(new AutoplayPolicy(this)),
       autoplay_uma_helper_(AutoplayUmaHelper::Create(this)),
       remote_playback_client_(nullptr),
-      autoplay_visibility_observer_(nullptr),
       media_controls_(nullptr),
       controls_list_(HTMLMediaElementControlsList::Create(this)) {
   BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
 
-  locked_pending_user_gesture_ = ComputeLockedPendingUserGesture(document);
-  locked_pending_user_gesture_if_cross_origin_experiment_enabled_ =
-      IsDocumentCrossOrigin(document);
-
   LocalFrame* frame = document.GetFrame();
   if (frame) {
     remote_playback_client_ =
         frame->Loader().Client()->CreateWebRemotePlaybackClient(*this);
   }
 
   SetHasCustomStyleCallbacks();
   AddElementToDocumentMap(this, &document);
 
   UseCounter::Count(document, UseCounter::kHTMLMediaElement);
@@ skipping 34 matching lines @@
   audio_tracks_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
   viewport_fill_debouncer_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
   check_viewport_intersection_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
   deferred_load_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
 
   autoplay_uma_helper_->DidMoveToNewDocument(old_document);
-  // If any experiment is enabled, then we want to enable a user gesture by
-  // default, otherwise the experiment does nothing.
-  bool old_document_requires_user_gesture =
-      ComputeLockedPendingUserGesture(old_document);
-  bool new_document_requires_user_gesture =
-      ComputeLockedPendingUserGesture(GetDocument());
-  if (new_document_requires_user_gesture && !old_document_requires_user_gesture)
-    locked_pending_user_gesture_ = true;
+  autoplay_policy_->DidMoveToNewDocument(old_document);
 
   if (should_delay_load_event_) {
     GetDocument().IncrementLoadEventDelayCount();
     // Note: Keeping the load event delay count increment on oldDocument that
     // was added when m_shouldDelayLoadEvent was set so that destruction of
     // m_webMediaPlayer can not cause load event dispatching in oldDocument.
   } else {
     // Incrementing the load event delay count so that destruction of
     // m_webMediaPlayer can not cause load event dispatching in oldDocument.
     old_document.IncrementLoadEventDelayCount();
   }
 
-  if (IsDocumentCrossOrigin(GetDocument()) &&
-      !IsDocumentCrossOrigin(old_document))
-    locked_pending_user_gesture_if_cross_origin_experiment_enabled_ = true;
-
   RemoveElementFromDocumentMap(this, &old_document);
   AddElementToDocumentMap(this, &GetDocument());
 
   // FIXME: This is a temporary fix to prevent this object from causing the
   // MediaPlayer to dereference LocalFrame and FrameLoader pointers from the
   // previous document. This restarts the load, as if the src attribute had been
   // set.  A proper fix would provide a mechanism to allow this object to
   // refresh the MediaPlayer's LocalFrame and FrameLoader references on document
   // changes so that playback can be resumed properly.
   ignore_preload_none_ = false;
@@ skipping 209 matching lines @@
 
   BLINK_MEDIA_LOG << "canPlayType(" << (void*)this << ", " << mime_type
                   << ") -> " << can_play;
 
   return can_play;
 }
 
 void HTMLMediaElement::load() {
   BLINK_MEDIA_LOG << "load(" << (void*)this << ")";
 
-  if (IsLockedPendingUserGesture() &&
-      UserGestureIndicator::UtilizeUserGesture()) {
-    UnlockUserGesture();
-  }
+  autoplay_policy_->TryUnlockingUserGesture();
 
   ignore_preload_none_ = true;
   InvokeLoadAlgorithm();
 }
 
 // TODO(srirama.m): Currently m_ignorePreloadNone is reset before calling
 // invokeLoadAlgorithm() in all places except load(). Move it inside here
 // once microtask is implemented for "Await a stable state" step
 // in resource selection algorithm.
 void HTMLMediaElement::InvokeLoadAlgorithm() {
@@ skipping 612 matching lines @@
   // (vs. non-CORS-enabled or failed).
   // taintsCanvas() does checkAccess() on the URL plus allow data sources,
   // to ensure that it is not a URL that requires CORS (basically same
   // origin).
   return HasSingleSecurityOrigin() &&
          ((GetWebMediaPlayer() &&
            GetWebMediaPlayer()->DidPassCORSAccessCheck()) ||
           !origin->TaintsCanvas(currentSrc()));
 }
 
-bool HTMLMediaElement::IsInCrossOriginFrame() const {
-  return IsDocumentCrossOrigin(GetDocument());
-}
-
 void HTMLMediaElement::StartProgressEventTimer() {
   if (progress_event_timer_.IsActive())
     return;
 
   previous_progress_time_ = WTF::CurrentTime();
   // 350ms is not magic, it is in the spec!
   progress_event_timer_.StartRepeating(0.350, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::WaitForSourceChange() {
@@ skipping 338 matching lines @@
     if (old_state <= kHaveCurrentData) {
       ScheduleEvent(EventTypeNames::canplay);
       if (is_potentially_playing)
         ScheduleNotifyPlaying();
     }
 
     // Check for autoplay, and record metrics about it if needed.
     if (ShouldAutoplay()) {
       autoplay_uma_helper_->OnAutoplayInitiated(AutoplaySource::kAttribute);
 
-      if (!IsGestureNeededForPlayback()) {
-        if (IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
+      if (!autoplay_policy_->IsGestureNeededForPlayback()) {
+        if (autoplay_policy_
+                ->IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
           autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
               CrossOriginAutoplayResult::kAutoplayBlocked);
         } else {
           autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
               CrossOriginAutoplayResult::kAutoplayAllowed);
         }
-        if (IsHTMLVideoElement() && muted() &&
-            RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
-          // We might end up in a situation where the previous
-          // observer didn't had time to fire yet. We can avoid
-          // creating a new one in this case.
-          if (!autoplay_visibility_observer_) {
-            autoplay_visibility_observer_ = new ElementVisibilityObserver(
-                this,
-                WTF::Bind(&HTMLMediaElement::OnVisibilityChangedForAutoplay,
-                          WrapWeakPersistent(this)));
-            autoplay_visibility_observer_->Start();
-          }
+        if (autoplay_policy_->IsEligibleForAutoplayMuted()) {
+          autoplay_policy_->StartAutoplayMutedWhenVisible();
         } else {
           paused_ = false;
           ScheduleEvent(EventTypeNames::play);
           ScheduleNotifyPlaying();
           can_autoplay_ = false;
         }
       } else {
         autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
             CrossOriginAutoplayResult::kAutoplayBlocked);
       }
@@ skipping 400 matching lines @@
   // https://crbug.com/310450
   UseCounter::Count(GetDocument(), UseCounter::kHTMLMediaElementPreloadDefault);
   return WebMediaPlayer::kPreloadAuto;
 }
 
 String HTMLMediaElement::EffectivePreload() const {
   return PreloadTypeToString(EffectivePreloadType());
 }
 
 WebMediaPlayer::Preload HTMLMediaElement::EffectivePreloadType() const {
-  if (Autoplay() && !IsGestureNeededForPlayback())
+  if (Autoplay() && !autoplay_policy_->IsGestureNeededForPlayback())
     return WebMediaPlayer::kPreloadAuto;
 
   WebMediaPlayer::Preload preload = PreloadType();
   if (ignore_preload_none_ && preload == WebMediaPlayer::kPreloadNone)
     return WebMediaPlayer::kPreloadMetaData;
 
   return preload;
 }
 
 ScriptPromise HTMLMediaElement::playForBindings(ScriptState* script_state) {
@@ skipping 25 matching lines @@
     resolver->Reject(DOMException::Create(code.Get(), message));
     return promise;
   }
 
   return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::Play() {
   BLINK_MEDIA_LOG << "play(" << (void*)this << ")";
 
-  if (!UserGestureIndicator::ProcessingUserGesture()) {
-    autoplay_uma_helper_->OnAutoplayInitiated(AutoplaySource::kMethod);
-    if (IsGestureNeededForPlayback()) {
-      // If we're already playing, then this play would do nothing anyway.
-      // Call playInternal to handle scheduling the promise resolution.
-      if (!paused_) {
-        PlayInternal();
-        return nullptr;
-      }
+  // If we're already playing, then this play would do nothing anyway.
+  // Call playInternal to handle scheduling the promise resolution.
+  if (!paused_) {
+    PlayInternal();
+    return nullptr;
+  }

[mlamouri (slow - plz ping), 2017/04/18 13:28:28]

The logic is slightly changing with this change. I'm all for a simpler logic but
what makes you think it will have no side effects?

[Zhiqiang Zhang (Slow), 2017/04/18 16:56:44]

OK, I moved the code a bit so it should have the same behavior now.

 
-      autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-          CrossOriginAutoplayResult::kAutoplayBlocked);
-      String message = ExceptionMessages::FailedToExecute(
-          "play", "HTMLMediaElement",
-          "API can only be initiated by a user gesture.");
-      GetDocument().AddConsoleMessage(ConsoleMessage::Create(
-          kJSMessageSource, kWarningMessageLevel, message));
-      return kNotAllowedError;
-    } else {
-      if (IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
-        autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-            CrossOriginAutoplayResult::kAutoplayBlocked);
-      } else {
-        autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-            CrossOriginAutoplayResult::kAutoplayAllowed);
-      }
-    }
-  } else {
-    autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-        CrossOriginAutoplayResult::kPlayedWithGesture);
-    UserGestureIndicator::UtilizeUserGesture();
-    UnlockUserGesture();
-  }
+  autoplay_policy_->StopAutoplayMutedWhenVisible();
 
   if (error_ && error_->code() == MediaError::kMediaErrSrcNotSupported)
     return kNotSupportedError;
 
-  if (autoplay_visibility_observer_) {
-    autoplay_visibility_observer_->Stop();
-    autoplay_visibility_observer_ = nullptr;
+  // The only place to call IsAutoplayAllowedFromPlayMethod(), don't call from
+  // anywhere else!

[mlamouri (slow - plz ping), 2017/04/18 13:28:28]

Comment is out of date, right?

[Zhiqiang Zhang (Slow), 2017/04/18 16:56:44]

Done.

+  Nullable<ExceptionCode> exception_code =
+      autoplay_policy_->CheckPlayMethodAllowed();
+
+  if (exception_code == kNotAllowedError) {
+    String message = ExceptionMessages::FailedToExecute(
+        "play", "HTMLMediaElement",
+        "API can only be initiated by a user gesture.");
+    GetDocument().AddConsoleMessage(ConsoleMessage::Create(
+        kJSMessageSource, kWarningMessageLevel, message));
+    return exception_code;
   }
 
+  DCHECK(exception_code.IsNull());
+
   PlayInternal();
 
   return nullptr;
 }
 
 void HTMLMediaElement::PlayInternal() {
   BLINK_MEDIA_LOG << "playInternal(" << (void*)this << ")";
 
   // 4.8.12.8. Playing the media resource
   if (network_state_ == kNetworkEmpty)
@@ skipping 19 matching lines @@
 
   can_autoplay_ = false;
 
   SetIgnorePreloadNone();
   UpdatePlayState();
 }
 
 void HTMLMediaElement::pause() {
   BLINK_MEDIA_LOG << "pause(" << (void*)this << ")";
 
-  if (autoplay_visibility_observer_) {
-    autoplay_visibility_observer_->Stop();
-    autoplay_visibility_observer_ = nullptr;
-  }
-
+  autoplay_policy_->StopAutoplayMutedWhenVisible();
   PauseInternal();
 }
 
 void HTMLMediaElement::PauseInternal() {
   BLINK_MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
 
   if (network_state_ == kNetworkEmpty)
     InvokeResourceSelectionAlgorithm();
 
   can_autoplay_ = false;
@@ skipping 127 matching lines @@
   return muted_;
 }
 
 void HTMLMediaElement::setMuted(bool muted) {
   BLINK_MEDIA_LOG << "setMuted(" << (void*)this << ", " << BoolString(muted)
                   << ")";
 
   if (muted_ == muted)
     return;
 
-  bool was_autoplaying_muted = IsAutoplayingMuted();
-  bool was_pending_autoplay_muted = autoplay_visibility_observer_ && paused() &&
-                                    muted_ && IsLockedPendingUserGesture();
+  // TODO(zqzhang): use TryUnlockingUserGesture?
+  if (UserGestureIndicator::ProcessingUserGesture())
+    autoplay_policy_->UnlockUserGesture();
 
-  if (UserGestureIndicator::ProcessingUserGesture())
-    UnlockUserGesture();
+  bool should_pause_after_unmute =
+      autoplay_policy_->CheckUnmuteShouldPauseAutoplay();

[mlamouri (slow - plz ping), 2017/04/18 13:28:28]

Not sure this is at the right place. Should this be called before
UnlockUserGesture?

[Zhiqiang Zhang (Slow), 2017/04/18 16:56:44]

The logic won't change actually.
The original logic was to check whether the video was autoplaying muted. If yes,
and and there's no user gesture, we should pause the video.
The gesture is unlocked before the gesture check.

The CheckUnmuteShouldPauseAutoplay (now called RequestAutoplayUnmute) does just
that :)

 
   muted_ = muted;
 
   ScheduleEvent(EventTypeNames::volumechange);
 
-  // If an element autoplayed while muted, it needs to be unlocked to unmute,
-  // otherwise, it will be paused.
-  if (was_autoplaying_muted) {
-    if (IsGestureNeededForPlayback()) {
-      pause();
-      autoplay_uma_helper_->RecordAutoplayUnmuteStatus(
-          AutoplayUnmuteActionStatus::kFailure);
-    } else {
-      autoplay_uma_helper_->RecordAutoplayUnmuteStatus(
-          AutoplayUnmuteActionStatus::kSuccess);
-    }
-  }
+  if (should_pause_after_unmute)
+    pause();
 
   // This is called after the volumechange event to make sure isAutoplayingMuted
   // returns the right value when webMediaPlayer receives the volume update.
   if (GetWebMediaPlayer())
     GetWebMediaPlayer()->SetVolume(EffectiveMediaVolume());
 
-  // If an element was a candidate for autoplay muted but not visible, it will
-  // have a visibility observer ready to start its playback.
-  if (was_pending_autoplay_muted) {
-    autoplay_visibility_observer_->Stop();
-    autoplay_visibility_observer_ = nullptr;
-  }
+  autoplay_policy_->StopAutoplayMutedWhenVisible();
 }
 
 double HTMLMediaElement::EffectiveMediaVolume() const {
   if (muted_)
     return 0;
 
   return volume_;
 }
 
 // The spec says to fire periodic timeupdate events (those sent while playing)
@@ skipping 701 matching lines @@
 WebMediaPlayer::TrackId HTMLMediaElement::GetSelectedVideoTrackId() {
   DCHECK(RuntimeEnabledFeatures::backgroundVideoTrackOptimizationEnabled());
   DCHECK(HasSelectedVideoTrack());
 
   int selected_track_index = video_tracks_->selectedIndex();
   VideoTrack* track =
       video_tracks_->AnonymousIndexedGetter(selected_track_index);
   return track->id();
 }
 
-bool HTMLMediaElement::IsAutoplayingMuted() {
-  if (!IsHTMLVideoElement() ||
-      !RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
-    return false;
-  }
-
-  return !paused() && muted() && IsLockedPendingUserGesture();
-}
-
 void HTMLMediaElement::RequestReload(const WebURL& new_url) {
   DCHECK(GetWebMediaPlayer());
   DCHECK(!src_object_);
   DCHECK(new_url.IsValid());
   DCHECK(IsSafeToLoadURL(new_url, kComplain));
   ResetMediaPlayerAndMediaSource();
   StartPlayerLoad(new_url);
 }
 
+bool HTMLMediaElement::IsAutoplayingMuted() {
+  return autoplay_policy_->IsAutoplayingMuted();
+}
+
 // MediaPlayerPresentation methods
 void HTMLMediaElement::Repaint() {
   if (web_layer_)
     web_layer_->Invalidate();
 
   UpdateDisplayState();
   if (GetLayoutObject())
     GetLayoutObject()->SetShouldDoFullPaintInvalidation();
 }
 
@@ skipping 577 matching lines @@
   visitor->Trace(video_tracks_);
   visitor->Trace(cue_timeline_);
   visitor->Trace(text_tracks_);
   visitor->Trace(text_tracks_when_resource_selection_began_);
   visitor->Trace(play_promise_resolvers_);
   visitor->Trace(play_promise_resolve_list_);
   visitor->Trace(play_promise_reject_list_);
   visitor->Trace(audio_source_provider_);
   visitor->Trace(autoplay_uma_helper_);
   visitor->Trace(src_object_);
-  visitor->Trace(autoplay_visibility_observer_);
+  visitor->Trace(autoplay_policy_);
   visitor->Trace(media_controls_);
   visitor->Trace(controls_list_);
   visitor->template RegisterWeakMembers<HTMLMediaElement,
                                         &HTMLMediaElement::ClearWeakMembers>(
       this);
   Supplementable<HTMLMediaElement>::Trace(visitor);
   HTMLElement::Trace(visitor);
   SuspendableObject::Trace(visitor);
 }
 
@@ skipping 29 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::IsLockedPendingUserGesture() const {
-  return locked_pending_user_gesture_;
-}
-
-void HTMLMediaElement::UnlockUserGesture() {
-  locked_pending_user_gesture_ = false;
-  locked_pending_user_gesture_if_cross_origin_experiment_enabled_ = false;
-}
-
-bool HTMLMediaElement::IsGestureNeededForPlayback() const {
-  if (!locked_pending_user_gesture_)
-    return false;
-
-  return IsGestureNeededForPlaybackIfPendingUserGestureIsLocked();
-}
-
-bool HTMLMediaElement::
-    IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled() const {
-  if (!locked_pending_user_gesture_if_cross_origin_experiment_enabled_)
-    return false;
-
-  return IsGestureNeededForPlaybackIfPendingUserGestureIsLocked();
-}
-
-bool HTMLMediaElement::IsGestureNeededForPlaybackIfPendingUserGestureIsLocked()
-    const {
-  if (GetLoadType() == WebMediaPlayer::kLoadTypeMediaStream)
-    return false;
-
-  // We want to allow muted video to autoplay if:
-  // - the flag is enabled;
-  // - Data Saver is not enabled;
-  // - Preload was not disabled (low end devices);
-  // - Autoplay is enabled in settings;
-  if (IsHTMLVideoElement() && muted() &&
-      RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
-      !(GetDocument().GetSettings() &&
-        GetDocument().GetSettings()->GetDataSaverEnabled()) &&
-      !(GetDocument().GetSettings() &&
-        GetDocument().GetSettings()->GetForcePreloadNoneForMediaElements()) &&
-      IsAutoplayAllowedPerSettings()) {
-    return false;
-  }
-
-  return true;
-}
-
-bool HTMLMediaElement::IsAutoplayAllowedPerSettings() const {
-  LocalFrame* frame = GetDocument().GetFrame();
-  if (!frame)
-    return false;
-  return frame->GetContentSettingsClient()->AllowAutoplay(true);
-}
-
 void HTMLMediaElement::SetNetworkState(NetworkState state) {
   if (network_state_ == state)
     return;
 
   network_state_ = state;
   if (GetMediaControls())
     GetMediaControls()->NetworkStateChanged();
 }
 
 void HTMLMediaElement::VideoWillBeDrawnToCanvas() const {
@@ skipping 109 matching lines @@
     DEFINE_STATIC_LOCAL(EnumerationHistogram, histogram,
                         ("Media.Controls.Show.Video", kMediaControlsShowMax));
     return histogram;
   }
 
   DEFINE_STATIC_LOCAL(EnumerationHistogram, histogram,
                       ("Media.Controls.Show.Audio", kMediaControlsShowMax));
   return histogram;
 }
 
-void HTMLMediaElement::OnVisibilityChangedForAutoplay(bool is_visible) {
-  if (!is_visible) {
-    if (can_autoplay_ && Autoplay()) {
-      PauseInternal();
-      can_autoplay_ = true;
-    }
-    return;
-  }
-
-  if (ShouldAutoplay()) {
-    paused_ = false;
-    ScheduleEvent(EventTypeNames::play);
-    ScheduleNotifyPlaying();
-
-    UpdatePlayState();
-  }
-}
-
 void HTMLMediaElement::ClearWeakMembers(Visitor* visitor) {
   if (!ThreadHeap::IsHeapObjectAlive(audio_source_node_)) {
     GetAudioSourceProvider().SetClient(nullptr);
     audio_source_node_ = nullptr;
   }
 }
 
 void HTMLMediaElement::AudioSourceProviderImpl::Wrap(
     WebAudioSourceProvider* provider) {
   MutexLocker locker(provide_input_lock);
@@ skipping 92 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::ViewportFillDebouncerTimerFired(TimerBase*) {
   mostly_filling_viewport_ = true;
   if (web_media_player_)
     web_media_player_->BecameDominantVisibleContent(mostly_filling_viewport_);
 }
 
 }  // namespace blink