Let AutoplayUmaHelper listen to visibilitychange instead of unload

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/frame/Settings.h"
 #include "core/html/HTMLMediaElement.h"
 #include "platform/Histogram.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
 const int32_t maxOffscreenDurationUmaMS = 60 * 60 * 1000;
 const int32_t offscreenDurationUmaBucketCount = 50;
 
 }  // namespace
 
 AutoplayUmaHelper* AutoplayUmaHelper::create(HTMLMediaElement* element) {
   return new AutoplayUmaHelper(element);
 }
 
 AutoplayUmaHelper::AutoplayUmaHelper(HTMLMediaElement* element)
     : EventListener(CPPEventListenerType),
+      ContextLifecycleObserver(nullptr),
       m_source(AutoplaySource::NumberOfSources),
       m_element(element),
       m_mutedVideoPlayMethodVisibilityObserver(nullptr),
       m_mutedVideoAutoplayOffscreenStartTimeMS(0),
       m_mutedVideoAutoplayOffscreenDurationMS(0),
       m_isVisible(false),
       m_mutedVideoOffscreenDurationVisibilityObserver(nullptr) {}
 
 AutoplayUmaHelper::~AutoplayUmaHelper() = default;
 
@@ skipping 57 matching lines @@
     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 (!shouldListenToUnloadEvent())
+  if (!shouldListenToContextDestroyed())
     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);
+  setContext(&m_element->document());
 }
 
 void AutoplayUmaHelper::onVisibilityChangedForMutedVideoPlayMethodBecomeVisible(
     bool isVisible) {
   if (!isVisible || !m_mutedVideoPlayMethodVisibilityObserver)
     return;
 
   maybeStopRecordingMutedVideoPlayMethodBecomeVisible(true);
 }
 
@@ skipping 12 matching lines @@
 
   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() {
+void AutoplayUmaHelper::contextDestroyed() {
+  handleContextDestroyed();
+}
+
+void AutoplayUmaHelper::handleContextDestroyed() {
   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();
-  if (m_element->document().domWindow())
-    m_element->document().domWindow()->addEventListener(EventTypeNames::unload,
-                                                        this, false);
+  setContext(&m_element->document());
 }
 
 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();
+  maybeUnregisterContextDestroyedObserver();
 }
 
 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);
-  if (m_element->document().domWindow())
-    m_element->document().domWindow()->addEventListener(EventTypeNames::unload,
-                                                        this, false);
+  setContext(&m_element->document());
 }
 
 void AutoplayUmaHelper::maybeStopRecordingMutedVideoOffscreenDuration() {
   if (!m_mutedVideoOffscreenDurationVisibilityObserver)
     return;
 
   if (!m_isVisible)
     m_mutedVideoAutoplayOffscreenDurationMS +=
         static_cast<int64_t>(monotonicallyIncreasingTimeMS()) -
         m_mutedVideoAutoplayOffscreenStartTimeMS;
@@ skipping 14 matching lines @@
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, durationHistogram,
         ("Media.Video.Autoplay.Muted.PlayMethod.OffscreenDuration", 1,
          maxOffscreenDurationUmaMS, offscreenDurationUmaBucketCount));
     durationHistogram.count(boundedTime);
   }
   m_mutedVideoOffscreenDurationVisibilityObserver->stop();
   m_mutedVideoOffscreenDurationVisibilityObserver = nullptr;
   m_mutedVideoAutoplayOffscreenDurationMS = 0;
   m_element->removeEventListener(EventTypeNames::pause, this, false);
-  maybeUnregisterUnloadListener();
+  maybeUnregisterContextDestroyedObserver();
 }
 
-void AutoplayUmaHelper::maybeUnregisterUnloadListener() {
-  if (!shouldListenToUnloadEvent() && m_element->document().domWindow())
-    m_element->document().domWindow()->removeEventListener(
-        EventTypeNames::unload, this, false);
+void AutoplayUmaHelper::maybeUnregisterContextDestroyedObserver() {
+  if (!shouldListenToContextDestroyed()) {
+    setContext(nullptr);
+  }
 }
 
-bool AutoplayUmaHelper::shouldListenToUnloadEvent() const {
+bool AutoplayUmaHelper::shouldListenToContextDestroyed() const {
   return m_mutedVideoPlayMethodVisibilityObserver ||
          m_mutedVideoOffscreenDurationVisibilityObserver;
 }
 
 DEFINE_TRACE(AutoplayUmaHelper) {
   EventListener::trace(visitor);
+  ContextLifecycleObserver::trace(visitor);
   visitor->trace(m_element);
   visitor->trace(m_mutedVideoPlayMethodVisibilityObserver);
   visitor->trace(m_mutedVideoOffscreenDurationVisibilityObserver);
 }
 
 }  // namespace blink