Monitor the intersection of video and viewport.

third_party/WebKit/Source/core/html/AutoplayUmaHelper.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/html/AutoplayUmaHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ElementVisibilityObserver.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalDOMWindow.h"
@@ skipping 12 matching lines @@
 }  // namespace
 
 AutoplayUmaHelper* AutoplayUmaHelper::create(HTMLMediaElement* element) {
   return new AutoplayUmaHelper(element);
 }
 
 AutoplayUmaHelper::AutoplayUmaHelper(HTMLMediaElement* element)
     : EventListener(CPPEventListenerType),
       m_source(AutoplaySource::NumberOfSources),
       m_element(element),
-      m_mutedVideoPlayMethodVisibilityObserver(nullptr),
       m_mutedVideoAutoplayOffscreenStartTimeMS(0),
       m_mutedVideoAutoplayOffscreenDurationMS(0),
-      m_isVisible(false),
-      m_mutedVideoOffscreenDurationVisibilityObserver(nullptr) {}
+      m_isVisible(false) {}
 
 AutoplayUmaHelper::~AutoplayUmaHelper() = default;
 
 bool AutoplayUmaHelper::operator==(const EventListener& other) const {
   return this == &other;
 }
 
 void AutoplayUmaHelper::onAutoplayInitiated(AutoplaySource source) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, videoHistogram,
                       ("Media.Video.Autoplay",
@@ skipping 61 matching lines @@
     return;
 
   if (oldDocument.domWindow())
     oldDocument.domWindow()->removeEventListener(EventTypeNames::unload, this,
                                                  false);
   if (m_element->document().domWindow())
     m_element->document().domWindow()->addEventListener(EventTypeNames::unload,
                                                         this, false);
 }
 
-void AutoplayUmaHelper::onVisibilityChangedForMutedVideoPlayMethodBecomeVisible(
-    bool isVisible) {
-  if (!isVisible || !m_mutedVideoPlayMethodVisibilityObserver)
-    return;
+void AutoplayUmaHelper::visibilityMightChangedforMutedVideo(bool isVisible) {
+  if (m_isObservingVisibilityOfMutedVideoOffscreenDuration && isVisible)

[miu, 2016/11/09 22:02:08]

Note: This method is going to be called from HTMLMediaElement repeatedly for the
same |isVisible| value. That never happened before. Therefore, I think you
should add to the top of this method:

  if (isVisible == m_isVisible)
    return;
  m_isVisible = isVisible;

...and update the code in the last if-statement of this method: It doesn't need
the same check, and doesn't need to assign to m_isVisible.

[xjz, 2016/11/11 01:07:29]

Done.

+    maybeStopRecordingMutedVideoPlayMethodBecomeVisible(true);
 
-  maybeStopRecordingMutedVideoPlayMethodBecomeVisible(true);
-}
-
-void AutoplayUmaHelper::onVisibilityChangedForMutedVideoOffscreenDuration(
-    bool isVisible) {
-  if (isVisible == m_isVisible)
-    return;
-
-  if (isVisible)
-    m_mutedVideoAutoplayOffscreenDurationMS +=
-        static_cast<int64_t>(monotonicallyIncreasingTimeMS()) -
-        m_mutedVideoAutoplayOffscreenStartTimeMS;
-  else
-    m_mutedVideoAutoplayOffscreenStartTimeMS =
-        static_cast<int64_t>(monotonicallyIncreasingTimeMS());
-
-  m_isVisible = isVisible;
+  if (m_isObservingVisibilityOfMutedVideoOffscreenDuration &&
+      isVisible != m_isVisible) {
+    if (isVisible) {
+      m_mutedVideoAutoplayOffscreenDurationMS +=
+          static_cast<int64_t>(monotonicallyIncreasingTimeMS()) -
+          m_mutedVideoAutoplayOffscreenStartTimeMS;
+    } else {
+      m_mutedVideoAutoplayOffscreenStartTimeMS =
+          static_cast<int64_t>(monotonicallyIncreasingTimeMS());
+    }
+    m_isVisible = isVisible;
+  }
 }
 
 void AutoplayUmaHelper::handleEvent(ExecutionContext* executionContext,
                                     Event* event) {
   if (event->type() == EventTypeNames::playing)
     handlePlayingEvent();
   else if (event->type() == EventTypeNames::pause)
     handlePauseEvent();
   else if (event->type() == EventTypeNames::unload)
     handleUnloadEvent();
@@ skipping 15 matching lines @@
 void AutoplayUmaHelper::handleUnloadEvent() {
   maybeStopRecordingMutedVideoPlayMethodBecomeVisible(false);
   maybeStopRecordingMutedVideoOffscreenDuration();
 }
 
 void AutoplayUmaHelper::maybeStartRecordingMutedVideoPlayMethodBecomeVisible() {
   if (m_source != AutoplaySource::Method || !m_element->isHTMLVideoElement() ||
       !m_element->muted())
     return;
 
-  m_mutedVideoPlayMethodVisibilityObserver = new ElementVisibilityObserver(
-      m_element,
-      WTF::bind(&AutoplayUmaHelper::
-                    onVisibilityChangedForMutedVideoPlayMethodBecomeVisible,
-                wrapWeakPersistent(this)));
-  m_mutedVideoPlayMethodVisibilityObserver->start();
+  m_isObservingVisibilityOfMutedAutoplayVideo = true;
   if (m_element->document().domWindow())
     m_element->document().domWindow()->addEventListener(EventTypeNames::unload,
                                                         this, false);
 }
 
 void AutoplayUmaHelper::maybeStopRecordingMutedVideoPlayMethodBecomeVisible(
     bool visible) {
-  if (!m_mutedVideoPlayMethodVisibilityObserver)
+  if (!m_isObservingVisibilityOfMutedAutoplayVideo)
     return;
 
   DEFINE_STATIC_LOCAL(BooleanHistogram, histogram,
                       ("Media.Video.Autoplay.Muted.PlayMethod.BecomesVisible"));
 
   histogram.count(visible);
-  m_mutedVideoPlayMethodVisibilityObserver->stop();
-  m_mutedVideoPlayMethodVisibilityObserver = nullptr;
+  m_isObservingVisibilityOfMutedAutoplayVideo = false;
   maybeUnregisterUnloadListener();
 }
 
 void AutoplayUmaHelper::maybeStartRecordingMutedVideoOffscreenDuration() {
   if (!m_element->isHTMLVideoElement() || !m_element->muted())
     return;
 
   // Start recording muted video playing offscreen duration.
   m_mutedVideoAutoplayOffscreenStartTimeMS =
       static_cast<int64_t>(monotonicallyIncreasingTimeMS());
   m_isVisible = false;
-  m_mutedVideoOffscreenDurationVisibilityObserver =
-      new ElementVisibilityObserver(
-          m_element,
-          WTF::bind(&AutoplayUmaHelper::
-                        onVisibilityChangedForMutedVideoOffscreenDuration,
-                    wrapWeakPersistent(this)));
-  m_mutedVideoOffscreenDurationVisibilityObserver->start();
+  m_isObservingVisibilityOfMutedVideoOffscreenDuration = true;
   m_element->addEventListener(EventTypeNames::pause, this, false);
   if (m_element->document().domWindow())
     m_element->document().domWindow()->addEventListener(EventTypeNames::unload,
                                                         this, false);
 }
 
 void AutoplayUmaHelper::maybeStopRecordingMutedVideoOffscreenDuration() {
-  if (!m_mutedVideoOffscreenDurationVisibilityObserver)
+  if (!m_isObservingVisibilityOfMutedVideoOffscreenDuration)
     return;
 
   if (!m_isVisible)
     m_mutedVideoAutoplayOffscreenDurationMS +=
         static_cast<int64_t>(monotonicallyIncreasingTimeMS()) -
         m_mutedVideoAutoplayOffscreenStartTimeMS;
 
   // Since histograms uses int32_t, the duration needs to be limited to
   // std::numeric_limits<int32_t>::max().
   int32_t boundedTime = static_cast<int32_t>(
       std::min<int64_t>(m_mutedVideoAutoplayOffscreenDurationMS,
                         std::numeric_limits<int32_t>::max()));
 
   if (m_source == AutoplaySource::Attribute) {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, durationHistogram,
         ("Media.Video.Autoplay.Muted.Attribute.OffscreenDuration", 1,
          maxOffscreenDurationUmaMS, offscreenDurationUmaBucketCount));
     durationHistogram.count(boundedTime);
   } else {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, durationHistogram,
         ("Media.Video.Autoplay.Muted.PlayMethod.OffscreenDuration", 1,
          maxOffscreenDurationUmaMS, offscreenDurationUmaBucketCount));
     durationHistogram.count(boundedTime);
   }
-  m_mutedVideoOffscreenDurationVisibilityObserver->stop();
-  m_mutedVideoOffscreenDurationVisibilityObserver = nullptr;
+  m_isObservingVisibilityOfMutedVideoOffscreenDuration = false;
   m_mutedVideoAutoplayOffscreenDurationMS = 0;
   m_element->removeEventListener(EventTypeNames::pause, this, false);
   maybeUnregisterUnloadListener();
 }
 
 void AutoplayUmaHelper::maybeUnregisterUnloadListener() {
   if (!shouldListenToUnloadEvent() && m_element->document().domWindow())
     m_element->document().domWindow()->removeEventListener(
         EventTypeNames::unload, this, false);
 }
 
 bool AutoplayUmaHelper::shouldListenToUnloadEvent() const {
-  return m_mutedVideoPlayMethodVisibilityObserver ||
-         m_mutedVideoOffscreenDurationVisibilityObserver;
+  return m_isObservingVisibilityOfMutedAutoplayVideo ||
+         m_isObservingVisibilityOfMutedVideoOffscreenDuration;
 }
 
 DEFINE_TRACE(AutoplayUmaHelper) {
   EventListener::trace(visitor);
   visitor->trace(m_element);
-  visitor->trace(m_mutedVideoPlayMethodVisibilityObserver);
-  visitor->trace(m_mutedVideoOffscreenDurationVisibilityObserver);
 }
 
 }  // namespace blink