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 189 matching lines @@
     case WebMediaPlayer::PreloadAuto:
         return "auto";
     }
 
     ASSERT_NOT_REACHED();
     return String();
 }
 
 } // 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 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(); }
+    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 66 matching lines @@
     , m_seeking(false)
     , m_sentStalledEvent(false)
     , m_sentEndEvent(false)
     , m_closedCaptionsVisible(false)
     , m_ignorePreloadNone(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()))
     , m_remotePlaybackClient(nullptr)
 {
 #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 236 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();
 
     m_ignorePreloadNone = 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 221 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 113 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 81 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 29 matching lines @@
     } else if (m_readyState >= HAVE_FUTURE_DATA) {
         scheduleResolvePlayPromises();
     }
 
     m_autoplaying = false;
 
     setIgnorePreloadNone();
     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)
         invokeResourceSelectionAlgorithm();
 
-    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 603 matching lines @@
             if (!m_paused) {
                 // changes paused to true and fires a simple event named pause at the media element.
                 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 195 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"));
+            m_autoplayHelper->playbackStopped();
         }
 
         refreshCachedTime();
 
         m_playbackProgressTimer.stop();
         m_playing = false;
         double time = currentTime();
         if (time > m_lastSeekTime)
             addPlayedRange(m_lastSeekTime, time);
 
@@ skipping 46 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();
 
     // Clear everything in the Media Element
     clearMediaPlayer();
     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();
 }
 
 void HTMLMediaElement::setRemotePlaybackClient(WebRemotePlaybackClient* client)
 {
     m_remotePlaybackClient = client;
 }
 
 // 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 111 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