Autoplay experiment metric fixes and additions.

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 19 matching lines @@
 #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/ElementTraversal.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
+#include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLMediaSource.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/HTMLTrackElement.h"
 #include "core/html/MediaError.h"
 #include "core/html/MediaFragmentURIParser.h"
 #include "core/html/TimeRanges.h"
 #include "core/html/shadow/MediaControls.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/LayoutVideo.h"
 #include "core/layout/LayoutView.h"
+#include "core/layout/api/LayoutMediaItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "platform/ContentType.h"
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeFromURL.h"
@@ skipping 173 matching lines @@
     if (contentMIMEType != "application/octet-stream" || contentTypeCodecs.isEmpty()) {
         WebMimeRegistry::SupportsType supported = Platform::current()->mimeRegistry()->supportsMediaMIMEType(contentMIMEType, contentTypeCodecs);
         return supported > WebMimeRegistry::IsNotSupported;
     }
 
     return false;
 }
 
 } // anonymous namespace
 
+class HTMLMediaElement::AutoplayHelperClientImpl :
+    public AutoplayExperimentHelper::Client {
+
+public:
+    static PassOwnPtrWillBeRawPtr<AutoplayHelperClientImpl> create(HTMLMediaElement* element)
+    {
+        return adoptPtrWillBeNoop(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
+    {
+        bool isPlaying = m_element->webMediaPlayer()
+            &&!m_element->webMediaPlayer()->paused();

[liberato (no reviews please), 2016/03/15 14:10:49]

here.  sorry, i forgot that i rebased somewhere in there.

[philipj_slow, 2016/03/16 11:37:43]

Looks a bit odd to check both the paused state (what we want to do) and the
actual state. Would `return !m_element->webMediaPlayer() ||
m_element->webMediaPlayer()->paused()` suffice? A comment about why just the
paused state isn't enough (because it can be out of sync with reality, by
design) would be helpful too.

[liberato (no reviews please), 2016/03/16 14:59:58]

i added a comment.  i also tried removing m_paused, but it turns out that
checking the media player's state alone doesn't work.  it requires that
updatePlayState has notified the player before the helper finds out, else we
miss pause() when we notify the helper before the media player.

probably, pause metrics should be moved into updatePlayState as well, so that
it's actually symmetric.  then, paused() here can check just the media player,
or (better yet) the helper won't need to check paused() at all.

i'm going to look into how big of a change that is.  if it's small, then i'll
make it here.  otherwise, it's probably left for future work, since i'd really
rather like to avoid tearing it all up again, and possibly breaking it.

+        return m_element->paused() || !isPlaying;
+    }
+    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(); }
+    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;
+    PageVisibilityState pageVisibilityState() const override;
+    String autoplayExperimentMode() const override;
+
+    // LayoutObject
+    void setRequestPositionUpdates(bool) override;
+    IntRect absoluteBoundingBoxRect() const override;
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_element);
+        Client::trace(visitor);
+    }
+
+private:
+    AutoplayHelperClientImpl(HTMLMediaElement* element) : m_element(element) {}
+
+    RawPtrWillBeMember<HTMLMediaElement> m_element;
+};
+
+
 void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, autoplayHistogram, ("Blink.MediaElement.Autoplay", NumberOfAutoplayMetrics));
     autoplayHistogram.count(metric);
 }
 
 WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(const ContentType& contentType)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
@@ skipping 65 matching lines @@
     , m_seeking(false)
     , m_sentStalledEvent(false)
     , m_sentEndEvent(false)
     , m_closedCaptionsVisible(false)
     , m_havePreparedToPlay(false)
     , m_tracksAreReady(true)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
     , m_isFinalizing(false)
-    , m_initialPlayWithoutUserGesture(false)
-    , m_autoplayMediaCounted(false)
     , m_inOverlayFullscreenVideo(false)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
     , m_playPromiseResolveTask(CancellableTaskFactory::create(this, &HTMLMediaElement::resolvePlayPromises))
     , m_playPromiseRejectTask(CancellableTaskFactory::create(this, &HTMLMediaElement::rejectPlayPromises))
     , m_audioSourceNode(nullptr)
-    , m_autoplayHelper(*this)
+    , m_autoplayHelperClient(AutoplayHelperClientImpl::create(this))
+    , m_autoplayHelper(AutoplayExperimentHelper::create(m_autoplayHelperClient.get()))
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         m_userGestureRequiredForPlay = true;
 
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 
     UseCounter::count(document, UseCounter::HTMLMediaElement);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
     WTF_LOG(Media, "HTMLMediaElement::~HTMLMediaElement(%p)", this);
 
 #if !ENABLE(OILPAN)
+    // Destruction of the autoplay helper requires the client, so be sure that
+    // this happens before the client is destructed.
+    if (m_autoplayHelper)
+        m_autoplayHelper.clear();
+
     // HTMLMediaElement and m_asyncEventQueue always become unreachable
     // together. So HTMLMediaElement and m_asyncEventQueue are destructed in
     // the same GC. We don't need to close it explicitly in Oilpan.
     m_asyncEventQueue->close();
 
     setShouldDelayLoadEvent(false);
 
     if (m_textTracks)
         m_textTracks->clearOwner();
     m_audioTracks->shutdown();
@@ skipping 19 matching lines @@
     // m_audioSourceNode is explicitly cleared by AudioNode::dispose().
     // Since AudioNode::dispose() is guaranteed to be always called before
     // the AudioNode is destructed, m_audioSourceNode is explicitly cleared
     // even if the AudioNode and the HTMLMediaElement die together.
     ASSERT(!m_audioSourceNode);
 }
 
 #if ENABLE(OILPAN)
 void HTMLMediaElement::dispose()
 {
+    // This must happen before we're destructed.
+    if (m_autoplayHelper)
+        m_autoplayHelper->dispose();
+
     // If the HTMLMediaElement dies with the Document we are not
     // allowed to touch the Document to adjust delay load event counts
     // from the destructor, as the Document could have been already
     // destructed.
     //
     // Work around that restriction by accessing the Document from
     // a prefinalizer action instead, updating its delayed load count.
     // If needed - if the Document has been detached and informed its
     // ContextLifecycleObservers (which HTMLMediaElement is) that
     // it is being destroyed, the connection to the Document will
@@ skipping 240 matching lines @@
     case WebMimeRegistry::IsSupported:
         canPlay = "probably";
         break;
     }
 
     WTF_LOG(Media, "HTMLMediaElement::canPlayType(%p, %s) -> %s", this, mimeType.utf8().data(), canPlay.utf8().data());
 
     return canPlay;
 }
 
-void HTMLMediaElement::recordMetricsIfPausing()
-{
-    // If not playing, then nothing to record.
-    // TODO(liberato): test metrics.  this was m_paused.
-    if (m_paused)
-        return;
-
-    const bool bailout = isBailout();
-
-    // Record that play was paused.  We don't care if it was autoplay,
-    // play(), or the user manually started it.
-    recordAutoplayMetric(AnyPlaybackPaused);
-    if (bailout)
-        recordAutoplayMetric(AnyPlaybackBailout);
-
-    // If this was a gestureless play, then record that separately.
-    // These cover attr and play() gestureless starts.
-    if (m_initialPlayWithoutUserGesture) {
-        m_initialPlayWithoutUserGesture = false;
-
-        recordAutoplayMetric(AutoplayPaused);
-
-        if (bailout)
-            recordAutoplayMetric(AutoplayBailout);
-    }
-}
-
 void HTMLMediaElement::load()
 {
     WTF_LOG(Media, "HTMLMediaElement::load(%p)", this);
 
-    recordMetricsIfPausing();
-
-    if (UserGestureIndicator::processingUserGesture() && m_userGestureRequiredForPlay) {
-        recordAutoplayMetric(AutoplayEnabledThroughLoad);
-        m_userGestureRequiredForPlay = false;
-        // While usergesture-initiated load()s technically count as autoplayed,
-        // they don't feel like such to the users and hence we don't want to
-        // count them for the purposes of metrics.
-        m_autoplayMediaCounted = true;
-    }
+    m_autoplayHelper->loadMethodCalled();
 
     prepareForLoad();
     loadInternal();
     prepareToPlay();
 }
 
 void HTMLMediaElement::prepareForLoad()
 {
     WTF_LOG(Media, "HTMLMediaElement::prepareForLoad(%p)", this);
 
@@ skipping 203 matching lines @@
 
     LocalFrame* frame = document().frame();
     if (!frame) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
     setNetworkState(NETWORK_LOADING);
 
+    m_autoplayHelper->loadingStarted();
+
     // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
     // cache is an internal detail not exposed through the media element API.
     m_currentSrc = url;
 
     if (m_audioSourceNode)
         m_audioSourceNode->onCurrentSrcChanged(m_currentSrc);
 
     WTF_LOG(Media, "HTMLMediaElement::loadResource(%p) - m_currentSrc -> %s", this, urlForLoggingMedia(m_currentSrc).utf8().data());
 
     startProgressEventTimer();
 
     // Reset display mode to force a recalculation of what to show because we are resetting the player.
     setDisplayMode(Unknown);
 
     setPlayerPreload();
 
     if (fastHasAttribute(mutedAttr))
         m_muted = true;
     updateVolume();
 
     ASSERT(!m_mediaSource);
 
     bool attemptLoad = true;
 
     if (url.protocolIs(mediaSourceBlobProtocol)) {
         if (isMediaStreamURL(url.getString())) {
-            m_userGestureRequiredForPlay = false;
+            m_autoplayHelper->removeUserGestureRequirement(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 568 matching lines @@
         if (oldState <= HAVE_CURRENT_DATA) {
             scheduleEvent(EventTypeNames::canplay);
             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();
+            m_autoplayHelper->becameReadyToPlay();
 
             if (!m_userGestureRequiredForPlay) {
                 m_paused = false;
                 invalidateCachedTime();
                 scheduleEvent(EventTypeNames::play);
                 scheduleNotifyPlaying();
                 m_autoplaying = false;
             }
         }
 
@@ skipping 118 matching lines @@
 
     m_lastSeekTime = time;
     m_sentEndEvent = false;
 
     // 10 - Queue a task to fire a simple event named seeking at the element.
     scheduleEvent(EventTypeNames::seeking);
 
     // 11 - Set the current playback position to the given new playback position.
     webMediaPlayer()->seek(time);
 
-    m_initialPlayWithoutUserGesture = false;
-
     // 14-17 are handled, if necessary, when the engine signals a readystate change or otherwise
     // satisfies seek completion and signals a time change.
 }
 
 void HTMLMediaElement::finishSeek()
 {
     WTF_LOG(Media, "HTMLMediaElement::finishSeek(%p)", this);
 
     // 14 - Set the seeking IDL attribute to false.
     m_seeking = false;
@@ skipping 163 matching lines @@
 }
 
 bool HTMLMediaElement::autoplay() const
 {
     return fastHasAttribute(autoplayAttr);
 }
 
 bool HTMLMediaElement::shouldAutoplay(const RecordMetricsBehavior recordMetrics)
 {
     if (m_autoplaying && m_paused && autoplay()) {
-        if (recordMetrics == RecordMetricsBehavior::DoRecord)
-            autoplayMediaEncountered();
-
         if (document().isSandboxed(SandboxAutomaticFeatures)) {
             if (recordMetrics == RecordMetricsBehavior::DoRecord)
-                recordAutoplayMetric(AutoplayDisabledBySandbox);
+                m_autoplayHelper->recordSandboxFailure();
             return false;
         }
 
         return true;
     }
 
     return false;
 }
 
 String HTMLMediaElement::preload() const
@@ skipping 79 matching lines @@
     ScriptPromise promise = resolver->promise();
 
     m_playResolvers.append(resolver);
     return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::play()
 {
     WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
 
-    m_autoplayHelper.playMethodCalled();
+    m_autoplayHelper->playMethodCalled();
 
     if (!UserGestureIndicator::processingUserGesture()) {
-        autoplayMediaEncountered();
-
         if (m_userGestureRequiredForPlay) {
             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 {
+        // 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"));
-        if (m_userGestureRequiredForPlay) {
-            if (m_autoplayMediaCounted)
-                recordAutoplayMetric(AutoplayManualStart);
-            m_userGestureRequiredForPlay = false;
-        }
+        m_autoplayHelper->removeUserGestureRequirement(GesturelessPlaybackEnabledByPlayMethod);
     }
 
     if (m_error && m_error->code() == MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED)
         return NotSupportedError;
 
     playInternal();
 
     return nullptr;
 }
 
@@ skipping 28 matching lines @@
             scheduleNotifyPlaying();
     } else if (m_readyState >= HAVE_FUTURE_DATA) {
         scheduleResolvePlayPromises();
     }
 
     m_autoplaying = false;
 
     updatePlayState();
 }
 
-void HTMLMediaElement::autoplayMediaEncountered()
-{
-    if (!m_autoplayMediaCounted) {
-        m_autoplayMediaCounted = true;
-        recordAutoplayMetric(AutoplayMediaFound);
-
-        if (!m_userGestureRequiredForPlay)
-            m_initialPlayWithoutUserGesture = true;
-    }
-}
-
-bool HTMLMediaElement::isBailout() const
-{
-    // We count the user as having bailed-out on the video if they watched
-    // less than one minute and less than 50% of it.
-    const double playedTime = currentTime();
-    const double progress = playedTime / duration();
-    return (playedTime < 60) && (progress < 0.5);
-}
-
 void HTMLMediaElement::pause()
 {
     WTF_LOG(Media, "HTMLMediaElement::pause(%p)", this);
 
     // Only buffer aggressively on a user-initiated pause. Other types of pauses
     // (which go directly to pauseInternal()) should not cause this behavior.
     if (webMediaPlayer() && UserGestureIndicator::processingUserGesture())
         webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Aggressive);
 
     pauseInternal();
 }
 
 void HTMLMediaElement::pauseInternal()
 {
     WTF_LOG(Media, "HTMLMediaElement::pauseInternal(%p)", this);
 
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
-    m_autoplayHelper.pauseMethodCalled();
+    m_autoplayHelper->pauseMethodCalled();
 
     m_autoplaying = false;
 
     if (!m_paused) {
-        recordMetricsIfPausing();
-
         m_paused = true;
         scheduleTimeupdateEvent(false);
         scheduleEvent(EventTypeNames::pause);
         scheduleRejectPlayPromises(AbortError);
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::requestRemotePlayback()
@@ skipping 89 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();
+    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 592 matching lines @@
         // If the media element has a loop attribute specified
         if (loop()) {
             m_sentEndEvent = false;
             //  then seek to the earliest possible position of the media resource and abort these steps.
             seek(0);
         } else {
             // If the media element has still ended playback, and the direction of playback is still
             // forwards, and paused is false,
             if (!m_paused) {
                 // changes paused to true and fires a simple event named pause at the media element.
+                m_autoplayHelper->playbackEnded();
                 m_paused = true;
                 scheduleEvent(EventTypeNames::pause);
             }
             // Queue a task to fire a simple event named ended at the media element.
             if (!m_sentEndEvent) {
                 m_sentEndEvent = true;
                 scheduleEvent(EventTypeNames::ended);
             }
-            recordMetricsIfPausing();
             Platform::current()->recordAction(UserMetricsAction("Media_Playback_Ended"));
         }
     } else {
         m_sentEndEvent = false;
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::durationChanged()
@@ skipping 189 matching lines @@
         invalidateCachedTime();
 
         if (!isPlaying) {
             // Set rate, muted before calling play in case they were set before the media engine was setup.
             // The media engine should just stash the rate and muted values since it isn't already playing.
             webMediaPlayer()->setRate(playbackRate());
             updateVolume();
             webMediaPlayer()->play();
             Platform::current()->recordAction(
                 UserMetricsAction("Media_Playback_Started"));
+            m_autoplayHelper->playbackStarted();
         }
 
         if (mediaControls())
             mediaControls()->playbackStarted();
         startPlaybackProgressTimer();
         m_playing = true;
-        recordAutoplayMetric(AnyPlaybackStarted);
 
     } else { // Should not be playing right now
         if (isPlaying) {
             webMediaPlayer()->pause();
             Platform::current()->recordAction(UserMetricsAction("Media_Paused"));
         }
 
         refreshCachedTime();
 
         m_playbackProgressTimer.stop();
@@ skipping 54 matching lines @@
         mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::stop()
 {
     WTF_LOG(Media, "HTMLMediaElement::stop(%p)", this);
 
-    recordMetricsIfPausing();
-
     // Close the async event queue so that no events are enqueued.
     cancelPendingEventsAndCallbacks();
     m_asyncEventQueue->close();
 
     // Stop the playback without generating events
     clearMediaPlayer(-1);
     m_readyState = HAVE_NOTHING;
     m_readyStateMaximum = HAVE_NOTHING;
     setNetworkState(NETWORK_EMPTY);
     setShouldDelayLoadEvent(false);
@@ skipping 454 matching lines @@
     visitor->trace(m_currentSourceNode);
     visitor->trace(m_nextChildNodeToConsider);
     visitor->trace(m_mediaSource);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     visitor->trace(m_cueTimeline);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
     visitor->trace(m_playResolvers);
     visitor->trace(m_audioSourceProvider);
+    visitor->trace(m_autoplayHelperClient);
+    visitor->trace(m_autoplayHelper);
     visitor->template registerWeakMembers<HTMLMediaElement, &HTMLMediaElement::clearWeakMembers>(this);
-    visitor->trace(m_autoplayHelper);
     HeapSupplementable<HTMLMediaElement>::trace(visitor);
 #endif
     HTMLElement::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 void HTMLMediaElement::createPlaceholderTracksIfNecessary()
 {
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
@@ skipping 24 matching lines @@
 bool HTMLMediaElement::isUserGestureRequiredForPlay() const
 {
     return m_userGestureRequiredForPlay;
 }
 
 void HTMLMediaElement::removeUserGestureRequirement()
 {
     m_userGestureRequiredForPlay = false;
 }
 
-void HTMLMediaElement::setInitialPlayWithoutUserGestures(bool value)
-{
-    m_initialPlayWithoutUserGesture = value;
-}
-
 void HTMLMediaElement::setNetworkState(NetworkState state)
 {
     if (m_networkState != state) {
         m_networkState = state;
         if (MediaControls* controls = mediaControls())
             controls->networkStateChanged();
     }
 }
 
 void HTMLMediaElement::notifyPositionMayHaveChanged(const IntRect& visibleRect)
 {
-    m_autoplayHelper.positionChanged(visibleRect);
+    m_autoplayHelper->positionChanged(visibleRect);
 }
 
 void HTMLMediaElement::updatePositionNotificationRegistration()
 {
-    m_autoplayHelper.updatePositionNotificationRegistration();
+    m_autoplayHelper->updatePositionNotificationRegistration();
 }
 
 // TODO(liberato): remove once autoplay gesture override experiment concludes.
 void HTMLMediaElement::triggerAutoplayViewportCheckForTesting()
 {
-    m_autoplayHelper.triggerAutoplayViewportCheckForTesting();
+    if (FrameView* view = document().view())
+        m_autoplayHelper->positionChanged(view->rootFrameToContents(view->computeVisibleArea()));
+    m_autoplayHelper->triggerAutoplayViewportCheckForTesting();
 }
 
 void HTMLMediaElement::scheduleResolvePlayPromises()
 {
     // Per spec, if there are two tasks in the queue, the first task will remove
     // all the pending promises making the second task useless unless a promise
     // can be added between the first and second task being run which is not
     // possible at the moment.
     if (m_playPromiseResolveTask->isPending())
         return;
@@ skipping 122 matching lines @@
 DEFINE_TRACE(HTMLMediaElement::AudioClientImpl)
 {
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 
+HTMLMediaElement::AutoplayHelperClientImpl::~AutoplayHelperClientImpl()
+{
+}
+
+bool HTMLMediaElement::AutoplayHelperClientImpl::isLegacyViewportType()
+{
+    return m_element->document().viewportDescription().isLegacyViewportType();
+}
+
+PageVisibilityState HTMLMediaElement::AutoplayHelperClientImpl::pageVisibilityState() const
+{
+    return m_element->document().pageVisibilityState();
+}
+
+String HTMLMediaElement::AutoplayHelperClientImpl::autoplayExperimentMode() const
+{
+    String mode;
+    if (m_element->document().settings())
+        mode = m_element->document().settings()->autoplayExperimentMode();
+
+    return mode;
+}
+
+void HTMLMediaElement::AutoplayHelperClientImpl::setRequestPositionUpdates(bool request)
+{
+    if (LayoutObject* layoutObject = m_element->layoutObject()) {
+        LayoutMediaItem layoutMediaItem = LayoutMediaItem(toLayoutMedia(layoutObject));
+        layoutMediaItem.setRequestPositionUpdates(request);
+    }
+}
+
+IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
+{
+    IntRect result;
+    if (LayoutObject* object = m_element->layoutObject())
+        result = object->absoluteBoundingBoxRect();
+    return result;
+}
+
 } // namespace blink