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 int32_t maxOffscreenDurationUmaMS = 3600000;

[Ilya Sherman, 2016/08/19 23:15:33]

nit: This constant value is a bit hard to parse -- I'd write it as 60 * 60 *
1000;

[Zhiqiang Zhang (Slow), 2016/08/22 09:40:24]

Done.

+const int32_t offscreenDurationUmaBucketCount = 50;
 
 } // 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 += 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();
     else
         NOTREACHED();
 }
 
+void AutoplayUmaHelper::handlePlayingEvent()
+{
+    maybeStartRecordingMutedVideoPlayMethodBecomeVisible();
+    maybeStartRecordingMutedVideoOffscreenDuration();
+
+    m_element->removeEventListener(EventTypeNames::playing, this, false);
+}
+
+void AutoplayUmaHelper::handlePauseEvent()
+{
+    maybeStopRecordingMutedVideoOffscreenDuration();
+}
+
 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();
 }
 
-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)
+{
+    if (!m_mutedVideoPlayMethodVisibilityObserver)
+        return;
+
+    DEFINE_STATIC_LOCAL(BooleanHistogram, histogram, ("Media.Video.Autoplay.Muted.PlayMethod.BecomesVisible"));
+
+    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 = static_cast<int64_t>(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()
+{
+    if (!m_mutedVideoOffscreenDurationVisibilityObserver)
+        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().

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

Now the time is stored as int64_t inside AutoplayUmaHelper, but it needs to be
bounded to int32_t when recording the UMA.

+    int32_t boundedTime = static_cast<int32_t>(std::min<int64_t>(m_mutedVideoAutoplayOffscreenDurationMS, std::numeric_limits<int32_t>::max()));

[Ilya Sherman, 2016/08/19 23:15:33]

Can you use base::saturated_cast?

[Zhiqiang Zhang (Slow), 2016/08/22 09:40:24]

I guess not. Using base:: is not allowed in WebKit/Source/core :(

+
+    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_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