[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 18 matching lines @@
 #include <limits>
 #include "bindings/core/v8/ExceptionState.h"
 #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/AutoplayUmaHelper.h"
+#include "core/html/media/AutoplayPolicy.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"
 #include "core/html/track/InbandTextTrack.h"
 #include "core/html/track/TextTrackContainer.h"
 #include "core/html/track/TextTrackList.h"
 #include "core/html/track/VideoTrack.h"
 #include "core/html/track/VideoTrackList.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/IntersectionGeometry.h"
 #include "core/layout/LayoutMedia.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/ChromeClient.h"
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/RuntimeEnabledFeatures.h"
-#include "platform/UserGestureIndicator.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioSourceProviderClient.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/mediastream/MediaStreamDescriptor.h"
 #include "platform/network/NetworkStateNotifier.h"
 #include "platform/network/ParsedContentType.h"
 #include "platform/network/mime/ContentType.h"
 #include "platform/network/mime/MIMETypeFromURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/AutoReset.h"
@@ skipping 239 matching lines @@
 
   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_uma_helper_(AutoplayUmaHelper::Create(this)),
+      autoplay_policy_(new AutoplayPolicy(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 33 matching lines @@
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
   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 970 matching lines @@
   }
 
   if (ready_state_ == kHaveEnoughData && old_state < kHaveEnoughData &&
       tracks_are_ready) {
     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()) {
-          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();
-          }
-        } else {
-          paused_ = false;
-          ScheduleEvent(EventTypeNames::play);
-          ScheduleNotifyPlaying();
-          can_autoplay_ = false;
-        }
-      } else {
-        autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-            CrossOriginAutoplayResult::kAutoplayBlocked);
-      }
+    if (autoplay_policy_->RequestAutoplayByAttribute()) {
+      paused_ = false;
+      ScheduleEvent(EventTypeNames::play);
+      ScheduleNotifyPlaying();
+      can_autoplay_ = false;
     }
 
     ScheduleEvent(EventTypeNames::canplaythrough);
 
     should_update_display_state = true;
   }
 
   if (should_update_display_state)
     UpdateDisplayState();
 
@@ skipping 320 matching lines @@
   // 4.8.12.8 Playing the media resource
   // The ended attribute must return true if the media element has ended
   // playback and the direction of playback is forwards, and false otherwise.
   return EndedPlayback() && GetDirectionOfPlayback() == kForward;
 }
 
 bool HTMLMediaElement::Autoplay() const {
   return FastHasAttribute(autoplayAttr);
 }
 
-bool HTMLMediaElement::ShouldAutoplay() {
-  if (GetDocument().IsSandboxed(kSandboxAutomaticFeatures))
-    return false;
-  return can_autoplay_ && paused_ && Autoplay();
-}
-
 String HTMLMediaElement::preload() const {
   return PreloadTypeToString(PreloadType());
 }
 
 void HTMLMediaElement::setPreload(const AtomicString& preload) {
   BLINK_MEDIA_LOG << "setPreload(" << (void*)this << ", " << preload << ")";
   setAttribute(preloadAttr, preload);
 }
 
 WebMediaPlayer::Preload HTMLMediaElement::PreloadType() const {
@@ skipping 44 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;
-      }
+  Nullable<ExceptionCode> exception_code = autoplay_policy_->RequestPlay();
 
-      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);
-      }
+  if (exception_code == kNotAllowedError) {
+    // 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;
     }
-  } else {
-    autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
-        CrossOriginAutoplayResult::kPlayedWithGesture);
-    UserGestureIndicator::UtilizeUserGesture();
-    UnlockUserGesture();
+    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;
   }
 
+  autoplay_policy_->StopAutoplayMutedWhenVisible();
+
   if (error_ && error_->code() == MediaError::kMediaErrSrcNotSupported)
     return kNotSupportedError;
 
-  if (autoplay_visibility_observer_) {
-    autoplay_visibility_observer_->Stop();
-    autoplay_visibility_observer_ = nullptr;
-  }
+  DCHECK(exception_code.IsNull());
 
   PlayInternal();
 
   return nullptr;
 }
 
 void HTMLMediaElement::PlayInternal() {
   BLINK_MEDIA_LOG << "playInternal(" << (void*)this << ")";
 
   // 4.8.12.8. Playing the media resource
@@ skipping 20 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();
-
-  if (UserGestureIndicator::ProcessingUserGesture())
-    UnlockUserGesture();
-
   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 it is unmute and AutoplayPolicy doesn't want the playback to continue,
+  // pause the playback.
+  if (!muted_ && !autoplay_policy_->RequestAutoplayUnmute())
+    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 575 matching lines @@
   visitor->Trace(media_source_);
   visitor->Trace(audio_tracks_);
   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 {
   DCHECK(IsHTMLVideoElement());
   UseCounter::Count(GetDocument(), UseCounter::kVideoInCanvas);
-  if (autoplay_uma_helper_->HasSource() && !autoplay_uma_helper_->IsVisible())
-    UseCounter::Count(GetDocument(),
-                      UseCounter::kHiddenAutoplayedVideoInCanvas);
+  autoplay_policy_->VideoWillBeDrawnToCanvas();
 }
 
 void HTMLMediaElement::ScheduleResolvePlayPromises() {
   // TODO(mlamouri): per spec, we should create a new task but we can't create
   // a new cancellable task without cancelling the previous one. There are two
   // approaches then: cancel the previous task and create a new one with the
   // appended promise list or append the new promise to the current list. The
   // latter approach is preferred because it might be the less observable
   // change.
   DCHECK(play_promise_resolve_list_.IsEmpty() ||
@@ skipping 94 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