Record the offscreen playing duration of autoplaying muted videos

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"
 #include "core/html/HTMLMediaElement.h"
 #include "platform/Histogram.h"
+#include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
-void recordVideoAutoplayMutedPlayMethodBecomesVisibleUma(bool visible)
-{
-    DEFINE_STATIC_LOCAL(BooleanHistogram, histogram, ("Media.Video.Autoplay.Muted.PlayMethod.BecomesVisible"));
-    histogram.count(visible);
-}
+const double maxUmaDurationMS = 1e6;
+const double umaBucketCount = 20;

[Ilya Sherman, 2016/08/18 19:45:03]

How did you choose this bucket count?  If 20 buckets is truly sufficient, then
that's great!  I just want to make sure that you thought about the granularity
needed, and chose the bucket count accordingly.

I think it's probably worth documenting this variable, and likely also giving it
a slightly more specific name, to clarify which histograms it's intended to be
used with.

[Ilya Sherman, 2016/08/18 19:45:03]

Hmm, why are these variables of type double rather than int?

[mlamouri (slow - plz ping), 2016/08/19 10:00:08]

Maybe reuse
https://cs.chromium.org/chromium/src/base/metrics/histogram_macros.h?rcl=1471...
?

I wonder if it would make sense to have something like that in
platform/Histogram.h

[Zhiqiang Zhang (Slow), 2016/08/19 10:50:49]

Sorry, using int32_t now.

[Zhiqiang Zhang (Slow), 2016/08/19 10:50:49]

Using 50 as Mounir suggested, which is used by many duration-related UMAs.
Also using 1 hour as the maximum time.

 
 } // namespace
 
 AutoplayUmaHelper* AutoplayUmaHelper::create(HTMLMediaElement* element)
 {
     return new AutoplayUmaHelper(element);
 }
 
 AutoplayUmaHelper::AutoplayUmaHelper(HTMLMediaElement* element)
     : EventListener(CPPEventListenerType)
     , m_source(AutoplaySource::NumberOfSources)
     , m_element(element)
-    , m_videoMutedPlayMethodVisibilityObserver(nullptr) { }
+    , m_mutedVideoPlayMethodVisibilityObserver(nullptr)
+    , m_mutedVideoAutoplayOffscreenStartTimeMS(0)
+    , m_mutedVideoAutoplayOffscreenDurationMS(0)
+    , m_isVisible(false)
+    , m_mutedVideoOffscreenDurationVisibilityObserver(nullptr) { }
 
 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", static_cast<int>(AutoplaySource::NumberOfSources)));
     DEFINE_STATIC_LOCAL(EnumerationHistogram, mutedVideoHistogram, ("Media.Video.Autoplay.Muted", static_cast<int>(AutoplaySource::NumberOfSources)));
     DEFINE_STATIC_LOCAL(EnumerationHistogram, audioHistogram, ("Media.Audio.Autoplay", static_cast<int>(AutoplaySource::NumberOfSources)));
 
+    // Autoplay already initiated
+    // TODO(zqzhang): how about having autoplay attribute and calling `play()` in the script?
+    if (m_source != AutoplaySource::NumberOfSources)
+        return;
+
     m_source = source;
 
     if (m_element->isHTMLVideoElement()) {
         videoHistogram.count(static_cast<int>(m_source));
         if (m_element->muted())
             mutedVideoHistogram.count(static_cast<int>(m_source));
     } else {
         audioHistogram.count(static_cast<int>(m_source));
     }
 
-    if (m_source == AutoplaySource::Method && m_element->isHTMLVideoElement() && m_element->muted())
-        m_element->addEventListener(EventTypeNames::playing, this, false);
+    m_element->addEventListener(EventTypeNames::playing, this, false);
 }
 
 void AutoplayUmaHelper::recordAutoplayUnmuteStatus(AutoplayUnmuteActionStatus status)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, autoplayUnmuteHistogram, ("Media.Video.Autoplay.Muted.UnmuteAction", static_cast<int>(AutoplayUnmuteActionStatus::NumberOfStatus)));
 
     autoplayUnmuteHistogram.count(static_cast<int>(status));
 }
 
 void AutoplayUmaHelper::didMoveToNewDocument(Document& oldDocument)
 {
-    if (!m_videoMutedPlayMethodVisibilityObserver)
+    if (!shouldListenToUnloadEvent())
         return;
 
     if (oldDocument.domWindow())
         oldDocument.domWindow()->removeEventListener(EventTypeNames::unload, this, false);
     if (m_element && m_element->document().domWindow())
         m_element->document().domWindow()->addEventListener(EventTypeNames::unload, this, false);
 }
 
-void AutoplayUmaHelper::onVisibilityChangedForVideoMutedPlayMethod(bool isVisible)
+void AutoplayUmaHelper::onVisibilityChangedForMutedVideoPlayMethodBecomeVisible(bool isVisible)
 {
-    if (!isVisible || !m_videoMutedPlayMethodVisibilityObserver)
+    if (!isVisible || !m_mutedVideoPlayMethodVisibilityObserver)
         return;
 
-    recordVideoAutoplayMutedPlayMethodBecomesVisibleUma(true);
-    m_videoMutedPlayMethodVisibilityObserver->stop();
-    m_videoMutedPlayMethodVisibilityObserver = nullptr;
-    if (m_element && m_element->document().domWindow())
-        m_element->document().domWindow()->removeEventListener(EventTypeNames::unload, this, false);
+    maybeStopRecordingMutedVideoPlayMethodBecomeVisible(true);
+}
+
+void AutoplayUmaHelper::onVisibilityChangedForMutedVideoOffscreenDuration(bool isVisible)
+{
+    if (isVisible == m_isVisible)
+        return;
+
+    if (isVisible)
+        m_mutedVideoAutoplayOffscreenDurationMS += monotonicallyIncreasingTimeMS() - m_mutedVideoAutoplayOffscreenStartTimeMS;
+    else
+        m_mutedVideoAutoplayOffscreenStartTimeMS = 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();
     else
         NOTREACHED();
 }
 
+void AutoplayUmaHelper::handlePlayingEvent()
+{
+    maybeStartRecordingMutedVideoPlayMethodBecomeVisible();
+    maybeStartRecordingMutedVideoOffscreenDuration();
+
+    m_element->removeEventListener(EventTypeNames::playing, this, false);
+}
+
+void AutoplayUmaHelper::handlePauseEvent()
+{
+    maybeStopRecordingMutedVideoOffscreenDuration(false);
+}
+
 void AutoplayUmaHelper::handleUnloadEvent()
 {
-    if (m_videoMutedPlayMethodVisibilityObserver) {
-        recordVideoAutoplayMutedPlayMethodBecomesVisibleUma(false);
-        m_videoMutedPlayMethodVisibilityObserver->stop();
-        m_videoMutedPlayMethodVisibilityObserver = nullptr;
-        m_element->document().domWindow()->removeEventListener(EventTypeNames::unload, this, false);
-    }
+    maybeStopRecordingMutedVideoPlayMethodBecomeVisible(false);
+    maybeStopRecordingMutedVideoOffscreenDuration(true);
 }
 
-void AutoplayUmaHelper::handlePlayingEvent()
+void AutoplayUmaHelper::maybeStartRecordingMutedVideoPlayMethodBecomeVisible()
 {
-    if (m_source == AutoplaySource::Method && m_element->isHTMLVideoElement() && m_element->muted()) {
-        if (!m_videoMutedPlayMethodVisibilityObserver) {
-            m_videoMutedPlayMethodVisibilityObserver = new ElementVisibilityObserver(m_element, WTF::bind(&AutoplayUmaHelper::onVisibilityChangedForVideoMutedPlayMethod, wrapWeakPersistent(this)));
-            m_videoMutedPlayMethodVisibilityObserver->start();
-            m_element->document().domWindow()->addEventListener(EventTypeNames::unload, this, false);
-        }
+    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_element->document().domWindow()->addEventListener(EventTypeNames::unload, this, false);
+}
+
+void AutoplayUmaHelper::maybeStopRecordingMutedVideoPlayMethodBecomeVisible(bool visible)
+{
+    DEFINE_STATIC_LOCAL(BooleanHistogram, histogram, ("Media.Video.Autoplay.Muted.PlayMethod.BecomesVisible"));

[mlamouri (slow - plz ping), 2016/08/19 10:00:08]

nit: move after the early return?

[Zhiqiang Zhang (Slow), 2016/08/19 10:50:49]

Done.

+
+    if (!m_mutedVideoPlayMethodVisibilityObserver)
+        return;
+
+    histogram.count(visible);
+    m_mutedVideoPlayMethodVisibilityObserver->stop();
+    m_mutedVideoPlayMethodVisibilityObserver = nullptr;
+    maybeUnregisterUnloadListener();
+}
+
+void AutoplayUmaHelper::maybeStartRecordingMutedVideoOffscreenDuration()
+{
+    if (!m_element->isHTMLVideoElement() || !m_element->muted())
+        return;
+
+    // Start recording muted video playing offscreen duration.
+    m_mutedVideoAutoplayOffscreenStartTimeMS = monotonicallyIncreasingTimeMS();
+    m_isVisible = false;
+    m_mutedVideoOffscreenDurationVisibilityObserver = new ElementVisibilityObserver(m_element, WTF::bind(&AutoplayUmaHelper::onVisibilityChangedForMutedVideoOffscreenDuration, wrapWeakPersistent(this)));
+    m_mutedVideoOffscreenDurationVisibilityObserver->start();
+    m_element->addEventListener(EventTypeNames::pause, this, false);
+    m_element->document().domWindow()->addEventListener(EventTypeNames::unload, this, false);
+}
+
+void AutoplayUmaHelper::maybeStopRecordingMutedVideoOffscreenDuration(bool isInfinite)

[mlamouri (slow - plz ping), 2016/08/19 10:00:08]

I don't think you still need `isInfinite` here, do you?

[Zhiqiang Zhang (Slow), 2016/08/19 10:50:49]

Done.

+{
+    if (!m_mutedVideoOffscreenDurationVisibilityObserver)
+        return;
+
+    if (!m_isVisible)
+        m_mutedVideoAutoplayOffscreenDurationMS += monotonicallyIncreasingTimeMS() - m_mutedVideoAutoplayOffscreenStartTimeMS;
+
+    if (m_source == AutoplaySource::Attribute) {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, durationHistogram, ("Media.Video.Autoplay.Muted.Attribute.OffscreenDuration", 1, maxUmaDurationMS, umaBucketCount));
+        durationHistogram.count(static_cast<int32_t>(m_mutedVideoAutoplayOffscreenDurationMS));
+    } else {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, durationHistogram, ("Media.Video.Autoplay.Muted.PlayMethod.OffscreenDuration", 1, maxUmaDurationMS, umaBucketCount));
+        durationHistogram.count(static_cast<int32_t>(m_mutedVideoAutoplayOffscreenDurationMS));
     }
-    m_element->removeEventListener(EventTypeNames::playing, this, false);
+    m_mutedVideoOffscreenDurationVisibilityObserver->stop();
+    m_mutedVideoOffscreenDurationVisibilityObserver = nullptr;
+    m_mutedVideoAutoplayOffscreenDurationMS = 0;
+    m_element->removeEventListener(EventTypeNames::pause, this, false);
+    maybeUnregisterUnloadListener();
+}
+
+void AutoplayUmaHelper::maybeUnregisterUnloadListener()
+{
+    if (!shouldListenToUnloadEvent() && m_element && m_element->document().domWindow())
+        m_element->document().domWindow()->removeEventListener(EventTypeNames::unload, this, false);
+}
+
+bool AutoplayUmaHelper::shouldListenToUnloadEvent() const
+{
+    return m_mutedVideoPlayMethodVisibilityObserver || m_mutedVideoOffscreenDurationVisibilityObserver;
 }
 
 DEFINE_TRACE(AutoplayUmaHelper)
 {
     EventListener::trace(visitor);
     visitor->trace(m_element);
-    visitor->trace(m_videoMutedPlayMethodVisibilityObserver);
+    visitor->trace(m_mutedVideoPlayMethodVisibilityObserver);
+    visitor->trace(m_mutedVideoOffscreenDurationVisibilityObserver);
 }
 
 } // namespace blink