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 446 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;
   }
 
   setHasCustomStyleCallbacks();
   addElementToDocumentMap(this, &document);
 
   UseCounter::count(document, UseCounter::HTMLMediaElement);
+
+  m_videoViewportRatioObserver = new ElementVisibilityObserver(
+      this, WTF::bind(&HTMLMediaElement::onVideoViewportRatioChanged,
+                      wrapWeakPersistent(this)));
+  m_videoViewportRatioObserver->start(
+      Vector<float>({std::numeric_limits<float>::min(), 0.85}));

[miu, 2016/11/05 02:47:47]

1. Where does 0.85 come from, and how do we change it? This puts logic into
Blink that really depends on our feature in Chromium code. We want to keep all
control/decision logic in the Chromium code.

2. Our Chromium code will want to know all ratios (including zero), because we
will want to "debounce" before deciding to commit to starting or stopping
remoting. Thus, I think you don't need the second
ElementVisibilityObserver::start(vector) method.

[xjz, 2016/11/09 02:24:28]

Done. Now is able to monitor every changes on video/viewport ratio.

 }
 
 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_videoViewportRatioObserver->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 1206 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_autoplayWhenVisible = true;
         } else {
           m_paused = false;
           invalidateCachedTime();
           scheduleEvent(EventTypeNames::play);
           scheduleNotifyPlaying();
           m_autoplaying = false;
         }
       }
     }
 
@@ skipping 602 matching lines @@
 
 void HTMLMediaElement::setMuted(bool muted) {
   BLINK_MEDIA_LOG << "setMuted(" << (void*)this << ", " << boolString(muted)
                   << ")";
 
   if (m_muted == muted)
     return;
 
   bool wasAutoplayingMuted =
       !paused() && m_muted && isLockedPendingUserGesture();
-  bool wasPendingAutoplayMuted = m_autoplayVisibilityObserver && paused() &&
-                                 m_muted && isLockedPendingUserGesture();
+  bool wasPendingAutoplayMuted = m_autoplayWhenVisible && paused() && m_muted &&

[miu, 2016/11/05 02:47:47]

Is the m_autoplayWhenVisible boolean necessary? Why can't this expression be:

  bool wasPendingAutoplayMuted = !isGestureNeededForPlayback() &&
isHTMLVideoElement() && RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
paused() && m_muted && isLockedPendingUserGesture();

(Perhaps you might have the previous author of these LOC look over this logic,
to be sure it is correct.)

[xjz, 2016/11/09 02:24:28]

As replied to the comment in .h file, I keeps the boolean to save a bunch of
checks, and also avoid the risk changing the original logic.

+                                 isLockedPendingUserGesture();
 
   if (UserGestureIndicator::processingUserGesture())
     unlockUserGesture();
 
   m_muted = muted;
   m_autoplayHelper->mutedChanged();
 
   updateVolume();
 
   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);
     }
   }
 
   // If an element was a candidate for autoplay muted but not visible, it will
   // have a visibility observer ready to start its playback.

[miu, 2016/11/05 02:47:46]

Please adjust comment.

[xjz, 2016/11/09 02:24:28]

Done.

   if (wasPendingAutoplayMuted) {
-    m_autoplayVisibilityObserver->stop();
-    m_autoplayVisibilityObserver = nullptr;
+    m_autoplayWhenVisible = false;
   }
 }
 
 void HTMLMediaElement::updateVolume() {
   if (webMediaPlayer())
     webMediaPlayer()->setVolume(effectiveMediaVolume());
 
   if (mediaControls())
     mediaControls()->updateVolume();
 }
@@ skipping 1336 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_videoViewportRatioObserver);
   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 205 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) {
+void HTMLMediaElement::onVideoViewportRatioChanged(bool isVisible) {
+  m_autoplayUmaHelper->onVisibilityChangedForMutedVideo(isVisible);
   if (!isVisible)
     return;
 
-  if (shouldAutoplay()) {
+  if (shouldAutoplay() && m_autoplayWhenVisible) {
     m_paused = false;
     invalidateCachedTime();
     scheduleEvent(EventTypeNames::play);
     scheduleNotifyPlaying();
     m_autoplaying = false;
 
     updatePlayState();
   }
+  m_autoplayWhenVisible = false;
 
-  // 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;
+  if (m_webMediaPlayer) {
+    m_webMediaPlayer->videoViewportRatioChanged(
+        m_videoViewportRatioObserver->ratio());
+  }
 }
 
 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