Remove Media.UnderflowCount, add Media.UnderflowDuration for MSE.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 216 matching lines @@
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
       surface_manager_(params.surface_manager()),
       overlay_surface_id_(SurfaceManager::kNoSurfaceID),
       suppress_destruction_errors_(false),
       suspend_enabled_(params.allow_suspend()),
       use_fallback_path_(false),
       is_encrypted_(false),
-      underflow_count_(0),
       preroll_attempt_pending_(false),
       observer_(params.media_observer()),
       max_keyframe_distance_to_disable_background_video_(
           params.max_keyframe_distance_to_disable_background_video()),
       enable_instant_source_buffer_gc_(
           params.enable_instant_source_buffer_gc()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
   DCHECK(delegate_);
@@ skipping 856 matching lines @@
 #else
     paused_time_ = pipeline_.GetMediaTime();
 #endif
   } else {
     DCHECK(watch_time_reporter_);
     watch_time_reporter_->OnPlaying();
   }
   if (time_updated)
     should_notify_time_changed_ = true;
 
-  // Reset underflow count upon seek; this prevents looping videos and user
-  // actions from artificially inflating the underflow count.
-  underflow_count_ = 0;
+  // Reset underflow duration upon seek; this prevents looping videos and user
+  // actions from artificially inflating the duration.
+  underflow_timer_.reset();
 
   // Background video optimizations are delayed when shown/hidden if pipeline
   // is seeking.
   UpdateBackgroundVideoOptimizationState();
 }
 
 void WebMediaPlayerImpl::OnPipelineSuspended() {
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
@@ skipping 150 matching lines @@
 
   // Ignore buffering state changes until we've completed all outstanding
   // operations.
   if (!pipeline_controller_.IsStable())
     return;
 
   media_log_->AddEvent(media_log_->CreateBufferingStateChangedEvent(
       "pipeline_buffering_state", state));
 
   if (state == BUFFERING_HAVE_ENOUGH) {
-    if (data_source_ &&
-        highest_ready_state_ < WebMediaPlayer::ReadyStateHaveEnoughData) {
-      DCHECK_EQ(underflow_count_, 0);
-      // Record a zero value for underflow histograms so that the histogram
+    if (highest_ready_state_ < WebMediaPlayer::ReadyStateHaveEnoughData) {
+      // Record a zero value for underflow histogram so that the histogram
       // includes playbacks which never encounter an underflow event.
-      UMA_HISTOGRAM_COUNTS_100("Media.UnderflowCount", 0);
-      UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", base::TimeDelta());
+      RecordUnderflowDuration(base::TimeDelta());
     }
 
     // TODO(chcunningham): Monitor playback position vs buffered. Potentially
     // transition to HAVE_FUTURE_DATA here if not enough is buffered.
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
     // Let the DataSource know we have enough data. It may use this information
     // to release unused network connections.
     if (data_source_)
       data_source_->OnBufferingHaveEnough(false);
 
     // Blink expects a timeChanged() in response to a seek().
     if (should_notify_time_changed_) {
       should_notify_time_changed_ = false;
       client_->timeChanged();
     }
 
     // Once we have enough, start reporting the total memory usage. We'll also
     // report once playback starts.
     ReportMemoryUsage();
 
-    // Report the amount of time it took to leave the underflow state. Don't
-    // bother to report this for MSE playbacks since it's out of our control.
-    if (underflow_timer_ && data_source_) {
-      UMA_HISTOGRAM_TIMES("Media.UnderflowDuration",
-                          underflow_timer_->Elapsed());
+    // Report the amount of time it took to leave the underflow state.
+    if (underflow_timer_) {
+      RecordUnderflowDuration(underflow_timer_->Elapsed());
       underflow_timer_.reset();
     }
   } else {
     // Buffering has underflowed.
     DCHECK_EQ(state, BUFFERING_HAVE_NOTHING);
 
     // Report the number of times we've entered the underflow state. Only report
     // for src= playback since for MSE it's out of our control. Ensure we only
     // report the value when transitioning from HAVE_ENOUGH to HAVE_NOTHING.
     if (data_source_ &&
         ready_state_ == WebMediaPlayer::ReadyStateHaveEnoughData) {
-      UMA_HISTOGRAM_COUNTS_100("Media.UnderflowCount", ++underflow_count_);
       underflow_timer_.reset(new base::ElapsedTimer());
     }
 
     // It shouldn't be possible to underflow if we've not advanced past
     // HAVE_CURRENT_DATA.
     DCHECK_GT(highest_ready_state_, WebMediaPlayer::ReadyStateHaveCurrentData);
     SetReadyState(WebMediaPlayer::ReadyStateHaveCurrentData);
   }
 
   UpdatePlayState();
@@ skipping 951 matching lines @@
                         time_to_first_frame);
   }
 }
 
 void WebMediaPlayerImpl::SwitchRenderer(bool disable_pipeline_auto_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   disable_pipeline_auto_suspend_ = disable_pipeline_auto_suspend;
   ScheduleRestart();
 }
 
+void WebMediaPlayerImpl::RecordUnderflowDuration(base::TimeDelta duration) {
+  DCHECK(data_source_ || chunk_demuxer_);
+  if (data_source_)
+    UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", duration);
+  else
+    UMA_HISTOGRAM_TIMES("Media.UnderflowDuration.MSE", duration);
+}
+
 }  // namespace media