Deprecating AutoplayExperimentHelper

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 47 matching lines @@
 #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/api/LayoutMediaItem.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/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/MIMETypeFromURL.h"
@@ skipping 200 matching lines @@
     case WebMediaPlayer::PreloadAuto:
       return "auto";
   }
 
   NOTREACHED();
   return String();
 }
 
 }  // anonymous namespace
 
-class HTMLMediaElement::AutoplayHelperClientImpl
-    : public AutoplayExperimentHelper::Client {
- public:
-  static AutoplayHelperClientImpl* create(HTMLMediaElement* element) {
-    return new AutoplayHelperClientImpl(element);
-  }
-
-  virtual ~AutoplayHelperClientImpl();
-
-  using RecordMetricsBehavior = HTMLMediaElement::RecordMetricsBehavior;
-
-  double currentTime() const override { return m_element->currentTime(); }
-  double duration() const override { return m_element->duration(); }
-  bool paused() const override { return m_element->paused(); }
-  bool ended() const override { return m_element->ended(); }
-  bool muted() const override { return m_element->muted(); }
-  void setMuted(bool muted) override { m_element->setMuted(muted); }
-  void playInternal() override { m_element->playInternal(); }
-  void pauseInternal() override { m_element->pauseInternal(); }
-  bool isLockedPendingUserGesture() const override {
-    return m_element->isLockedPendingUserGesture();
-  }
-  void unlockUserGesture() override { m_element->unlockUserGesture(); }
-  void recordAutoplayMetric(AutoplayMetrics metric) override {
-    m_element->recordAutoplayMetric(metric);
-  }
-  bool shouldAutoplay() override {
-    return m_element->shouldAutoplay(RecordMetricsBehavior::DoNotRecord);
-  }
-  bool isHTMLVideoElement() const override {
-    return m_element->isHTMLVideoElement();
-  }
-  bool isHTMLAudioElement() const override {
-    return m_element->isHTMLAudioElement();
-  }
-
-  // Document
-  bool isLegacyViewportType() override;
-  PageVisibilityState pageVisibilityState() const override;
-  String autoplayExperimentMode() const override;
-
-  // Frame
-  bool isCrossOrigin() const override {
-    const LocalFrame* frame = m_element->document().frame();
-    return frame && frame->isCrossOriginSubframe();
-  }
-
-  bool isAutoplayAllowedPerSettings() 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) {}
-
-  Member<HTMLMediaElement> m_element;
-};
-
-void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric) {
-  DEFINE_STATIC_LOCAL(EnumerationHistogram, autoplayHistogram,
-                      ("Blink.MediaElement.Autoplay", NumberOfAutoplayMetrics));
-  autoplayHistogram.count(metric);
-}
-
 MIMETypeRegistry::SupportsType HTMLMediaElement::supportsType(
     const ContentType& contentType) {
   DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
   String type = contentType.type().lower();
   // The codecs string is not lower-cased because MP4 values are case sensitive
   // per http://tools.ietf.org/html/rfc4281#page-7.
   String typeCodecs = contentType.parameter(codecs);
 
   if (type.isEmpty())
@@ skipping 76 matching lines @@
       m_textTracksVisible(false),
       m_shouldPerformAutomaticTrackSelection(true),
       m_tracksAreReady(true),
       m_processingPreferenceChange(false),
       m_playingRemotely(false),
       m_inOverlayFullscreenVideo(false),
       m_audioTracks(this, AudioTrackList::create(*this)),
       m_videoTracks(this, VideoTrackList::create(*this)),
       m_textTracks(this, nullptr),
       m_audioSourceNode(nullptr),
-      m_autoplayHelperClient(AutoplayHelperClientImpl::create(this)),
-      m_autoplayHelper(
-          AutoplayExperimentHelper::create(m_autoplayHelperClient.get())),
       m_autoplayUmaHelper(AutoplayUmaHelper::create(this)),
       m_remotePlaybackClient(nullptr),
       m_autoplayVisibilityObserver(nullptr) {
   ThreadState::current()->registerPreFinalizer(this);
 
   BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
 
   // If any experiment is enabled, then we want to enable a user gesture by
   // default, otherwise the experiment does nothing.
   if ((document.settings() &&
-       document.settings()->mediaPlaybackRequiresUserGesture()) ||
-      m_autoplayHelper->isExperimentEnabled()) {
+       document.settings()->mediaPlaybackRequiresUserGesture())) {
     m_lockedPendingUserGesture = true;
   }
 
   LocalFrame* frame = document.frame();
   if (frame) {
     m_remotePlaybackClient =
         frame->loader().client()->createWebRemotePlaybackClient(*this);
   }
 
   setHasCustomStyleCallbacks();
@@ skipping 26 matching lines @@
 }
 
 void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument) {
   BLINK_MEDIA_LOG << "didMoveToNewDocument(" << (void*)this << ")";
 
   m_autoplayUmaHelper->didMoveToNewDocument(oldDocument);
   // If any experiment is enabled, then we want to enable a user gesture by
   // default, otherwise the experiment does nothing.
   bool oldDocumentRequiresUserGesture =
       (oldDocument.settings() &&
-       oldDocument.settings()->mediaPlaybackRequiresUserGesture()) ||
-      m_autoplayHelper->isExperimentEnabled();
+       oldDocument.settings()->mediaPlaybackRequiresUserGesture());
   bool newDocumentRequiresUserGesture =
       (document().settings() &&
-       document().settings()->mediaPlaybackRequiresUserGesture()) ||
-      m_autoplayHelper->isExperimentEnabled();
+       document().settings()->mediaPlaybackRequiresUserGesture());
   if (newDocumentRequiresUserGesture && !oldDocumentRequiresUserGesture) {
     m_lockedPendingUserGesture = true;
   }
 
   if (m_shouldDelayLoadEvent) {
     document().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 {
@@ skipping 209 matching lines @@
 
   BLINK_MEDIA_LOG << "canPlayType(" << (void*)this << ", " << mimeType
                   << ") -> " << canPlay;
 
   return canPlay;
 }
 
 void HTMLMediaElement::load() {
   BLINK_MEDIA_LOG << "load(" << (void*)this << ")";
 
-  m_autoplayHelper->loadMethodCalled();
+  if (isLockedPendingUserGesture() &&
+      UserGestureIndicator::utilizeUserGesture()) {
+    unlockUserGesture();
+  }
 
   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 300 matching lines @@
 
   LocalFrame* frame = document().frame();
   if (!frame) {
     mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     return;
   }
 
   // The resource fetch algorithm
   setNetworkState(kNetworkLoading);
 
-  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);
 
   BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ") - m_currentSrc -> "
                   << urlForLoggingMedia(m_currentSrc);
@@ skipping 641 matching lines @@
 
   if (m_readyState == kHaveEnoughData && oldState < kHaveEnoughData &&
       tracksAreReady) {
     if (oldState <= kHaveCurrentData) {
       scheduleEvent(EventTypeNames::canplay);
       if (isPotentiallyPlaying)
         scheduleNotifyPlaying();
     }
 
     // Check for autoplay, and record metrics about it if needed.
-    if (shouldAutoplay(RecordMetricsBehavior::DoRecord)) {
+    if (shouldAutoplay()) {
       m_autoplayUmaHelper->onAutoplayInitiated(AutoplaySource::Attribute);
 
-      // If the autoplay experiment says that it's okay to play now,
-      // then don't require a user gesture.
-      m_autoplayHelper->becameReadyToPlay();
-
       if (!isGestureNeededForPlayback()) {
         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 (!m_autoplayVisibilityObserver) {
             m_autoplayVisibilityObserver = new ElementVisibilityObserver(
                 this,
                 WTF::bind(&HTMLMediaElement::onVisibilityChangedForAutoplay,
@@ skipping 353 matching lines @@
   // 4.8.10.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() == Forward;
 }
 
 bool HTMLMediaElement::autoplay() const {
   return fastHasAttribute(autoplayAttr);
 }
 
-bool HTMLMediaElement::shouldAutoplay(
-    const RecordMetricsBehavior recordMetrics) {
-  if (m_autoplaying && m_paused && autoplay()) {
-    if (document().isSandboxed(SandboxAutomaticFeatures)) {
-      if (recordMetrics == RecordMetricsBehavior::DoRecord)
-        m_autoplayHelper->recordSandboxFailure();
-      return false;
-    }
-
-    return true;
-  }
-
-  return false;
+bool HTMLMediaElement::shouldAutoplay() {
+  if (document().isSandboxed(SandboxAutomaticFeatures))
+    return false;
+  return m_autoplaying && m_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);
 }
@@ skipping 88 matching lines @@
     resolver->reject(DOMException::create(code.get(), message));
     return promise;
   }
 
   return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::play() {
   BLINK_MEDIA_LOG << "play(" << (void*)this << ")";
 
-  m_autoplayHelper->playMethodCalled();
-
   if (!UserGestureIndicator::processingUserGesture()) {
     m_autoplayUmaHelper->onAutoplayInitiated(AutoplaySource::Method);
     if (isGestureNeededForPlayback()) {
-      // If playback is deferred, then don't start playback but don't
-      // fail yet either.
-      if (m_autoplayHelper->isPlaybackDeferred())
-        return nullptr;
-
       // If we're already playing, then this play would do nothing anyway.
       // Call playInternal to handle scheduling the promise resolution.
       if (!m_paused) {
         playInternal();
         return nullptr;
       }
 
-      recordAutoplayMetric(PlayMethodFailed);
       String message = ExceptionMessages::failedToExecute(
           "play", "HTMLMediaElement",
           "API can only be initiated by a user gesture.");
       document().addConsoleMessage(ConsoleMessage::create(
           JSMessageSource, WarningMessageLevel, message));
       return NotAllowedError;
     }
   } else {
     UserGestureIndicator::utilizeUserGesture();
-    // We ask the helper to remove the gesture requirement for us, so that
-    // it can record the reason.
-    m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByPlayMethod);
+    unlockUserGesture();
   }
 
   if (m_error && m_error->code() == MediaError::kMediaErrSrcNotSupported)
     return NotSupportedError;
 
   playInternal();
 
   return nullptr;
 }
 
@@ skipping 46 matching lines @@
 
   pauseInternal();
 }
 
 void HTMLMediaElement::pauseInternal() {
   BLINK_MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
 
   if (m_networkState == kNetworkEmpty)
     invokeResourceSelectionAlgorithm();
 
-  m_autoplayHelper->pauseMethodCalled();
-
   m_autoplaying = false;
 
   if (!m_paused) {
     m_paused = true;
     scheduleTimeupdateEvent(false);
     scheduleEvent(EventTypeNames::pause);
 
     // Force an update to official playback position. Automatic updates from
     // currentPlaybackPosition() will be blocked while m_paused = true. This
     // blocking is desired while paused, but its good to update it one final
@@ skipping 102 matching lines @@
     return;
 
   bool wasAutoplayingMuted = isAutoplayingMuted();
   bool wasPendingAutoplayMuted = m_autoplayVisibilityObserver && paused() &&
                                  m_muted && isLockedPendingUserGesture();
 
   if (UserGestureIndicator::processingUserGesture())
     unlockUserGesture();
 
   m_muted = muted;
-  m_autoplayHelper->mutedChanged();
 
   scheduleEvent(EventTypeNames::volumechange);
 
   // If an element autoplayed while muted, it needs to be unlocked to unmute,
   // otherwise, it will be paused.
   if (wasAutoplayingMuted) {
     if (isGestureNeededForPlayback()) {
       pause();
       m_autoplayUmaHelper->recordAutoplayUnmuteStatus(
           AutoplayUnmuteActionStatus::Failure);
@@ skipping 867 matching lines @@
   if (shouldBePlaying) {
     setDisplayMode(Video);
 
     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());
       webMediaPlayer()->setVolume(effectiveMediaVolume());
       webMediaPlayer()->play();
-      m_autoplayHelper->playbackStarted();
     }
 
     startPlaybackProgressTimer();
     m_playing = true;
   } else {  // Should not be playing right now
     if (isPlaying) {
       webMediaPlayer()->pause();
-      m_autoplayHelper->playbackStopped();
     }
 
     m_playbackProgressTimer.stop();
     m_playing = false;
     double time = currentTime();
     if (time > m_lastSeekTime)
       addPlayedRange(m_lastSeekTime, time);
   }
 
   if (layoutObject())
@@ skipping 458 matching lines @@
   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_playPromiseResolvers);
   visitor->trace(m_playPromiseResolveList);
   visitor->trace(m_playPromiseRejectList);
   visitor->trace(m_audioSourceProvider);
-  visitor->trace(m_autoplayHelperClient);
-  visitor->trace(m_autoplayHelper);
   visitor->trace(m_autoplayUmaHelper);
   visitor->trace(m_srcObject);
   visitor->trace(m_autoplayVisibilityObserver);
   visitor->template registerWeakMembers<HTMLMediaElement,
                                         &HTMLMediaElement::clearWeakMembers>(
       this);
   Supplementable<HTMLMediaElement>::trace(visitor);
   HTMLElement::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
@@ skipping 61 matching lines @@
   // - Autoplay is enabled in settings;
   if (isHTMLVideoElement() && muted() &&
       RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
       !(document().settings() && document().settings()->dataSaverEnabled()) &&
       !(document().settings() &&
         document().settings()->forcePreloadNoneForMediaElements()) &&
       isAutoplayAllowedPerSettings()) {
     return false;
   }
 
-  if (m_autoplayHelper->isGestureRequirementOverridden())
-    return false;
-
   return true;
 }
 
 bool HTMLMediaElement::isAutoplayAllowedPerSettings() const {
   LocalFrame* frame = document().frame();
   if (!frame)
     return false;
   FrameLoaderClient* frameLoaderClient = frame->loader().client();
   return frameLoaderClient && frameLoaderClient->allowAutoplay(false);
 }
 
 void HTMLMediaElement::setNetworkState(NetworkState state) {
   if (m_networkState != state) {
     m_networkState = state;
     if (MediaControls* controls = mediaControls())
       controls->networkStateChanged();
   }
 }
 
 void HTMLMediaElement::videoWillBeDrawnToCanvas() const {
   DCHECK(isHTMLVideoElement());
   UseCounter::count(document(), UseCounter::VideoInCanvas);
   if (m_autoplayUmaHelper->hasSource() && !m_autoplayUmaHelper->isVisible())
     UseCounter::count(document(), UseCounter::HiddenAutoplayedVideoInCanvas);
 }
 
-void HTMLMediaElement::notifyPositionMayHaveChanged(
-    const IntRect& visibleRect) {
-  m_autoplayHelper->positionChanged(visibleRect);
-}
-
-void HTMLMediaElement::updatePositionNotificationRegistration() {
-  m_autoplayHelper->updatePositionNotificationRegistration();
-}
-
-// TODO(liberato): remove once autoplay gesture override experiment concludes.
-void HTMLMediaElement::triggerAutoplayViewportCheckForTesting() {
-  if (FrameView* view = document().view())
-    m_autoplayHelper->positionChanged(
-        view->rootFrameToContents(view->computeVisibleArea()));
-  m_autoplayHelper->triggerAutoplayViewportCheckForTesting();
-}
-
 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(m_playPromiseResolveList.isEmpty() ||
          m_playPromiseResolveTaskHandle.isActive());
   if (m_playPromiseResolvers.isEmpty())
@@ skipping 178 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;
-}
-
-bool HTMLMediaElement::AutoplayHelperClientImpl::isAutoplayAllowedPerSettings()
-    const {
-  return m_element->isAutoplayAllowedPerSettings();
-}
-
-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