Fix AutoplayUmaHelper when autoplay is initiated from multiple sources

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/Settings.h"
@@ skipping 11 matching lines @@
 
 }  // 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;
 
 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)));
+                       static_cast<int>(AutoplaySource::NumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(EnumerationHistogram, mutedVideoHistogram,
                       ("Media.Video.Autoplay.Muted",
-                       static_cast<int>(AutoplaySource::NumberOfSources)));
+                       static_cast<int>(AutoplaySource::NumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(EnumerationHistogram, audioHistogram,
                       ("Media.Audio.Autoplay",
-                       static_cast<int>(AutoplaySource::NumberOfSources)));
+                       static_cast<int>(AutoplaySource::NumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, blockedMutedVideoHistogram,
       ("Media.Video.Autoplay.Muted.Blocked", AutoplayBlockedReasonMax));
 
   // Autoplay already initiated
-  // TODO(zqzhang): how about having autoplay attribute and calling `play()` in
-  // the script?
-  if (hasSource())
+  if (m_sources.count(source))
     return;
 
-  m_source = source;
+  m_sources.insert(source);
 
   // Record the source.
   if (m_element->isHTMLVideoElement()) {
-    videoHistogram.count(static_cast<int>(m_source));
+    videoHistogram.count(static_cast<int>(source));
     if (m_element->muted())
-      mutedVideoHistogram.count(static_cast<int>(m_source));
+      mutedVideoHistogram.count(static_cast<int>(source));
   } else {
-    audioHistogram.count(static_cast<int>(m_source));
+    audioHistogram.count(static_cast<int>(source));
+  }
+
+  // Record dual source.
+  if (m_sources.size() ==
+      static_cast<size_t>(AutoplaySource::NumberOfSources)) {
+    if (m_element->isHTMLVideoElement()) {
+      videoHistogram.count(static_cast<int>(AutoplaySource::DualSource));
+      if (m_element->muted())
+        mutedVideoHistogram.count(static_cast<int>(AutoplaySource::DualSource));
+    } else {
+      audioHistogram.count(static_cast<int>(AutoplaySource::DualSource));
+    }
   }
 
   // Record the child frame and top-level frame URLs for autoplay muted videos
   // by attribute.
   if (m_element->isHTMLVideoElement() && m_element->muted()) {
-    if (source == AutoplaySource::Attribute) {
+    if (m_sources.size() ==
+        static_cast<size_t>(AutoplaySource::NumberOfSources)) {
+      Platform::current()->recordRapporURL(
+          "Media.Video.Autoplay.Muted.DualSource.Frame",
+          m_element->document().url());
+    } else if (source == AutoplaySource::Attribute) {
       Platform::current()->recordRapporURL(
           "Media.Video.Autoplay.Muted.Attribute.Frame",
           m_element->document().url());
     } else {
       DCHECK(source == AutoplaySource::Method);
       Platform::current()->recordRapporURL(
           "Media.Video.Autoplay.Muted.PlayMethod.Frame",
           m_element->document().url());
     }
   }
@@ skipping 163 matching lines @@
 void AutoplayUmaHelper::contextDestroyed(ExecutionContext*) {
   handleContextDestroyed();
 }
 
 void AutoplayUmaHelper::handleContextDestroyed() {
   maybeStopRecordingMutedVideoPlayMethodBecomeVisible(false);
   maybeStopRecordingMutedVideoOffscreenDuration();
 }
 
 void AutoplayUmaHelper::maybeStartRecordingMutedVideoPlayMethodBecomeVisible() {
-  if (m_source != AutoplaySource::Method || !m_element->isHTMLVideoElement() ||
-      !m_element->muted())
+  if (!m_sources.count(AutoplaySource::Method) ||
+      !m_element->isHTMLVideoElement() || !m_element->muted())
     return;
 
   m_mutedVideoPlayMethodVisibilityObserver = new ElementVisibilityObserver(
       m_element,
       WTF::bind(&AutoplayUmaHelper::
                     onVisibilityChangedForMutedVideoPlayMethodBecomeVisible,
                 wrapWeakPersistent(this)));
   m_mutedVideoPlayMethodVisibilityObserver->start();
   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;
   maybeUnregisterContextDestroyedObserver();
 }
 
 void AutoplayUmaHelper::maybeStartRecordingMutedVideoOffscreenDuration() {
-  if (!m_element->isHTMLVideoElement() || !m_element->muted())
+  if (!m_element->isHTMLVideoElement() || !m_element->muted() ||
+      !m_sources.count(AutoplaySource::Method))
     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::
@@ skipping 12 matching lines @@
     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::Method) {
-    DEFINE_STATIC_LOCAL(
-        CustomCountHistogram, durationHistogram,
-        ("Media.Video.Autoplay.Muted.PlayMethod.OffscreenDuration", 1,
-         maxOffscreenDurationUmaMS, offscreenDurationUmaBucketCount));
-    durationHistogram.count(boundedTime);
-  }
+  DCHECK(m_sources.count(AutoplaySource::Method));
+
+  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;
   maybeUnregisterMediaElementPauseListener();
   maybeUnregisterContextDestroyedObserver();
 }
 
 void AutoplayUmaHelper::maybeRecordUserPausedAutoplayingCrossOriginVideo() {
   recordCrossOriginAutoplayResult(CrossOriginAutoplayResult::UserPaused);
   maybeUnregisterMediaElementPauseListener();
@@ skipping 14 matching lines @@
 }
 
 bool AutoplayUmaHelper::shouldListenToContextDestroyed() const {
   return m_mutedVideoPlayMethodVisibilityObserver ||
          m_mutedVideoOffscreenDurationVisibilityObserver;
 }
 
 bool AutoplayUmaHelper::shouldRecordUserPausedAutoplayingCrossOriginVideo()
     const {
   return m_element->isInCrossOriginFrame() && m_element->isHTMLVideoElement() &&
-         m_source != AutoplaySource::NumberOfSources &&
+         !m_sources.empty() &&
          !m_recordedCrossOriginAutoplayResults.count(
              CrossOriginAutoplayResult::UserPaused);
 }
 
 DEFINE_TRACE(AutoplayUmaHelper) {
   EventListener::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   visitor->trace(m_element);
   visitor->trace(m_mutedVideoPlayMethodVisibilityObserver);
   visitor->trace(m_mutedVideoOffscreenDurationVisibilityObserver);
 }
 
 }  // namespace blink