Monitor the intersection of video and viewport.

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 445 matching lines @@
           this,
           &HTMLMediaElement::resolveScheduledPlayPromises)),
       m_playPromiseRejectTask(CancellableTaskFactory::create(
           this,
           &HTMLMediaElement::rejectScheduledPlayPromises)),
       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) {
+      m_remotePlaybackClient(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()) {
     m_lockedPendingUserGesture = true;
   }
 
   LocalFrame* frame = document.frame();
   if (frame) {
     m_remotePlaybackClient =
         frame->loader().client()->createWebRemotePlaybackClient(*this);
   }
 
   setHasCustomStyleCallbacks();
   addElementToDocumentMap(this, &document);
 
   UseCounter::count(document, UseCounter::HTMLMediaElement);
+
+  m_viewportIntersectionObserver = new ElementViewportIntersectionObserver(
+      this, WTF::bind(&HTMLMediaElement::onVideoViewportIntersectionChanged,
+                      wrapWeakPersistent(this)));
+  m_viewportIntersectionObserver->start();
 }
 
 HTMLMediaElement::~HTMLMediaElement() {
   BLINK_MEDIA_LOG << "~HTMLMediaElement(" << (void*)this << ")";
 
   // 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.
   DCHECK(!m_audioSourceNode);
 }
 
 void HTMLMediaElement::dispose() {
   closeMediaSource();
 
+  m_viewportIntersectionObserver->stop();
+
   // Destroying the player may cause a resource load to be canceled,
   // which could result in LocalDOMWindow::dispatchWindowLoadEvent() being
   // called via ResourceFetch::didLoadResource(), then
   // FrameLoader::checkCompleted(). But it's guaranteed that the load event
   // doesn't get dispatched during the object destruction.
   // See Document::isDelayingLoadEvent().
   // Also see http://crbug.com/275223 for more details.
   clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
 }
 
@@ skipping 1220 matching lines @@
     if (shouldAutoplay(RecordMetricsBehavior::DoRecord)) {
       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,
-                          wrapWeakPersistent(this)));
-            m_autoplayVisibilityObserver->start();
-          }
+          m_shouldAutoplayWhenVisible = true;
         } else {
           m_paused = false;
           scheduleEvent(EventTypeNames::play);
           scheduleNotifyPlaying();
           m_autoplaying = false;
         }
       }
     }
 
     scheduleEvent(EventTypeNames::canplaythrough);
@@ skipping 674 matching lines @@
 }
 
 void HTMLMediaElement::setMuted(bool muted) {
   BLINK_MEDIA_LOG << "setMuted(" << (void*)this << ", " << boolString(muted)
                   << ")";
 
   if (m_muted == muted)
     return;
 
   bool wasAutoplayingMuted = isAutoplayingMuted();
-  bool wasPendingAutoplayMuted = m_autoplayVisibilityObserver && paused() &&
+  bool wasPendingAutoplayMuted = m_shouldAutoplayWhenVisible && 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);
     } else {
       m_autoplayUmaHelper->recordAutoplayUnmuteStatus(
           AutoplayUnmuteActionStatus::Success);
     }
   }
 
   // This is called after the volumechange event to make sure isAutoplayingMuted
   // returns the right value when webMediaPlayer receives the volume update.
   if (webMediaPlayer())
     webMediaPlayer()->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 (wasPendingAutoplayMuted) {
-    m_autoplayVisibilityObserver->stop();
-    m_autoplayVisibilityObserver = nullptr;
-  }
+  // start its playback once becomes visible.
+  if (wasPendingAutoplayMuted)
+    m_shouldAutoplayWhenVisible = false;
 }
 
 double HTMLMediaElement::effectiveMediaVolume() const {
   if (m_muted)
     return 0;
 
   return m_volume;
 }
 
 // The spec says to fire periodic timeupdate events (those sent while playing)
@@ skipping 1339 matching lines @@
   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->trace(m_viewportIntersectionObserver);
   visitor->template registerWeakMembers<HTMLMediaElement,
                                         &HTMLMediaElement::clearWeakMembers>(
       this);
   Supplementable<HTMLMediaElement>::trace(visitor);
   HTMLElement::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(HTMLMediaElement) {
   visitor->traceWrappers(m_videoTracks);
@@ skipping 203 matching lines @@
     DEFINE_STATIC_LOCAL(EnumerationHistogram, histogram,
                         ("Media.Controls.Show.Video", MediaControlsShowMax));
     return histogram;
   }
 
   DEFINE_STATIC_LOCAL(EnumerationHistogram, histogram,
                       ("Media.Controls.Show.Audio", MediaControlsShowMax));
   return histogram;
 }
 
-void HTMLMediaElement::onVisibilityChangedForAutoplay(bool isVisible) {
-  if (!isVisible)
+void HTMLMediaElement::onVideoViewportIntersectionChanged(
+    const WebRect& rootRect,
+    const WebRect& intersectRect) {
+  WebMediaPlayer::ViewportIntersectionInfo info;
+  info.rootRect = rootRect;
+  info.intersectRect = intersectRect;
+  if (m_webMediaPlayer)
+    m_webMediaPlayer->videoViewportIntersectionChanged(info);
+  m_currentViewportIntersection = info;
+
+  bool isVisible = !intersectRect.isEmpty();
+  m_autoplayUmaHelper->visibilityMaybeChangedforMutedVideo(isVisible);
+
+  if (!isVisible || !m_shouldAutoplayWhenVisible)
     return;
 
   if (shouldAutoplay()) {
     m_paused = false;
     scheduleEvent(EventTypeNames::play);
     scheduleNotifyPlaying();
     m_autoplaying = false;
 
     updatePlayState();
   }
-
-  // TODO(zqzhang): There's still flaky leak if onVisibilityChangedForAutoplay()
-  // is never called.  The leak comes from either ElementVisibilityObserver or
-  // IntersectionObserver. Should keep an eye on it.  See
-  // https://crbug.com/627539
-  m_autoplayVisibilityObserver->stop();
-  m_autoplayVisibilityObserver = nullptr;
+  m_shouldAutoplayWhenVisible = false;
 }
 
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor) {
   if (!ThreadHeap::isHeapObjectAlive(m_audioSourceNode)) {
     getAudioSourceProvider().setClient(nullptr);
     m_audioSourceNode = nullptr;
   }
 }
 
 void HTMLMediaElement::AudioSourceProviderImpl::wrap(
@@ skipping 91 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect()
     const {
   IntRect result;
   if (LayoutObject* object = m_element->layoutObject())
     result = object->absoluteBoundingBoxRect();
   return result;
 }
 
 }  // namespace blink