Autoplay time metric

third_party/WebKit/Source/core/html/media/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/media/AutoplayUmaHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ElementVisibilityObserver.h"
 #include "core/events/Event.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/media/AutoplayPolicy.h"
 #include "platform/Histogram.h"
 #include "platform/wtf/CurrentTime.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 namespace {
 
 const int32_t kMaxOffscreenDurationUmaMS = 60 * 60 * 1000;
 const int32_t kOffscreenDurationUmaBucketCount = 50;
+const int32_t kMaxWaitTimeUmaMS = 30 * 1000;
+const int32_t kWaitTimeBucketCount = 50;
 
 }  // namespace
 
 AutoplayUmaHelper* AutoplayUmaHelper::Create(HTMLMediaElement* element) {
   return new AutoplayUmaHelper(element);
 }
 
 AutoplayUmaHelper::AutoplayUmaHelper(HTMLMediaElement* element)
     : EventListener(kCPPEventListenerType),
       ContextLifecycleObserver(nullptr),
       element_(element),
       muted_video_play_method_visibility_observer_(nullptr),
       muted_video_autoplay_offscreen_start_time_ms_(0),
       muted_video_autoplay_offscreen_duration_ms_(0),
       is_visible_(false),
-      muted_video_offscreen_duration_visibility_observer_(nullptr) {}
+      muted_video_offscreen_duration_visibility_observer_(nullptr),
+      load_start_time_ms_(0.0) {}
 
 AutoplayUmaHelper::~AutoplayUmaHelper() = default;
 
 bool AutoplayUmaHelper::operator==(const EventListener& other) const {
   return this == &other;
 }
 
+void AutoplayUmaHelper::OnLoadStarted() {

[DaleCurtis, 2017/05/02 21:05:28]

Probably should take the type. We only care about src= and
MSE/data/blob/MediaStream will slant values towards zero.

[hubbe, 2017/05/02 22:33:26]

Done.

+  load_start_time_ms_ = MonotonicallyIncreasingTimeMS();
+}
+
 void AutoplayUmaHelper::OnAutoplayInitiated(AutoplaySource source) {
+  int32_t autoplay_wait_time_ms = -1;
+  if (load_start_time_ms_ != 0.0) {
+    autoplay_wait_time_ms = static_cast<int32_t>(
+        std::min<int64_t>(MonotonicallyIncreasingTimeMS() - load_start_time_ms_,

[DaleCurtis, 2017/05/02 21:05:28]

Clamp to kMaxWaitTimeUmaMS?

[hubbe, 2017/05/02 22:33:26]

Doesn't the histogram already do that?

[hubbe, 2017/05/03 20:37:24]

Checked, it does, here:
https://cs.chromium.org/chromium/src/base/metrics/histogram.cc?rcl=8b47351be5...

+                          std::numeric_limits<int32_t>::max()));
+  }
   DEFINE_STATIC_LOCAL(EnumerationHistogram, video_histogram,
                       ("Media.Video.Autoplay",
                        static_cast<int>(AutoplaySource::kNumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(EnumerationHistogram, muted_video_histogram,
                       ("Media.Video.Autoplay.Muted",
                        static_cast<int>(AutoplaySource::kNumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(EnumerationHistogram, audio_histogram,
                       ("Media.Audio.Autoplay",
                        static_cast<int>(AutoplaySource::kNumberOfUmaSources)));
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, blocked_muted_video_histogram,
       ("Media.Video.Autoplay.Muted.Blocked", kAutoplayBlockedReasonMax));
 
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, wait_time_video_attrib_histogram,

[DaleCurtis, 2017/05/02 21:05:28]

I don't think we really care about the difference between attribute or play
method, do we?

[Zhiqiang Zhang (Slow), 2017/05/02 21:21:22]

I think the experiment would only affect autoplay by play() method. For
attribute, autoplay starts as long as the readyState changes to
HAVE_ENOUGH_DATA, which seems independent with canplaythrough.

If you think the different doesn't matter, I'm OK with it.

[DaleCurtis, 2017/05/02 21:36:38]

Ah, I didn't realize the behavior was different. Having both values seems useful
in that case then, so we can compare what autoplay does vs what play() does.

[hubbe, 2017/05/02 22:33:26]

The thing we're changing actually changes the ready state to HAVE_FUTURE_DATA
until we think we can play through or until we stop loading because our buffers
are full. At that time we change to HAVE_ENOUGH_DATA and fire canplaythrough, so
autoplay will be affected.  I still want to break out play() from
canplaythrough, because the javascript code may or may not wait for
canplaythrough, while autoplay is guaranteed to do it.  I suspect that the
play() data will be swamped by other random javascript behaviors while the
autoplay data will cleanly show what my change is doing.

+                      ("Media.Video.Autoplay.Video.Attribute.WaitTimeMS", 1,
+                       kMaxWaitTimeUmaMS, kWaitTimeBucketCount));
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, wait_time_audio_attrib_histogram,
+                      ("Media.Video.Autoplay.Audio.Attribute.WaitTimeMS", 1,
+                       kMaxWaitTimeUmaMS, kWaitTimeBucketCount));
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, wait_time_video_play_histogram,
+                      ("Media.Video.Autoplay.Video.PlayMethod.WaitTimeMS", 1,
+                       kMaxWaitTimeUmaMS, kWaitTimeBucketCount));
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, wait_time_audio_play_histogram,
+                      ("Media.Video.Autoplay.Audio.PlayMethod.WaitTimeMS", 1,
+                       kMaxWaitTimeUmaMS, kWaitTimeBucketCount));
+
   // Autoplay already initiated
   if (sources_.count(source))
     return;
 
   sources_.insert(source);
 
   // Record the source.
   if (element_->IsHTMLVideoElement()) {
     video_histogram.Count(static_cast<int>(source));
     if (element_->muted())
       muted_video_histogram.Count(static_cast<int>(source));
+    if (autoplay_wait_time_ms >= 0) {
+      if (source == AutoplaySource::kAttribute) {
+        wait_time_video_attrib_histogram.Count(autoplay_wait_time_ms);
+      } else if (source == AutoplaySource::kMethod) {
+        wait_time_video_play_histogram.Count(autoplay_wait_time_ms);
+      }
+    }
   } else {
     audio_histogram.Count(static_cast<int>(source));
+    if (autoplay_wait_time_ms >= 0) {
+      if (source == AutoplaySource::kAttribute) {
+        wait_time_audio_attrib_histogram.Count(autoplay_wait_time_ms);
+      } else if (source == AutoplaySource::kMethod) {
+        wait_time_audio_play_histogram.Count(autoplay_wait_time_ms);
+      }
+    }
   }
 
   // Record dual source.
   if (sources_.size() ==
       static_cast<size_t>(AutoplaySource::kNumberOfSources)) {
     if (element_->IsHTMLVideoElement()) {
       video_histogram.Count(static_cast<int>(AutoplaySource::kDualSource));
       if (element_->muted())
         muted_video_histogram.Count(
             static_cast<int>(AutoplaySource::kDualSource));
@@ skipping 315 matching lines @@
 
 DEFINE_TRACE(AutoplayUmaHelper) {
   EventListener::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
   visitor->Trace(element_);
   visitor->Trace(muted_video_play_method_visibility_observer_);
   visitor->Trace(muted_video_offscreen_duration_visibility_observer_);
 }
 
 }  // namespace blink