Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/media_statistics.cc

+#include "media/base/android/media_statistics.h"
+
+#include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
+#include "media/base/android/demuxer_stream_player_params.h"
+
+namespace media {
+
+namespace {
+
+// Minimum duration to report.
+const int kMinDurationInSeconds = 2;
+
+// Maximum duration to report.
+const int kMaxDurationInSeconds = 3600;
+
+// Number of slots in the histogram for duration.
+const int kNumDurationSlots = 1800;

[Ilya Sherman, 2015/09/30 04:20:03]

nit: Please leave a blank line after this one, for consistency with line 10.

[Ilya Sherman, 2015/09/30 04:20:03]

Sorry, 1800 buckets is far too many for a histogram.  The typical number is 50. 
If you'd like to use more, could you please help me understand why -- i.e. what
you're trying to measure, that the standard number of buckets is insufficient
for?

[Tima Vaisburd, 2015/09/30 18:50:09]

Done.

[Tima Vaisburd, 2015/09/30 18:50:09]

Sorry, it was my bad thinking. Changed to 60 instead of standard 50, one slot
per minute.

+}
+
+void FrameStatistics::AddFrame() {
+  ++total;
+}
+
+void FrameStatistics::AddLateFrame(base::TimeDelta delay) {
+  // Do not collect the late frame if this is the first frame after start.
+  // This simplifies the MediaSourcePlayer case.
+  if (total == 1)
+    return;
+
+  DVLOG(1) << stream_type << " " << __FUNCTION__ << " delay:" << delay
+           << " total:" << total;
+  ++late;
+}
+
+MediaStatistics::MediaStatistics()
+    : audio_frames_(DemuxerStream::AUDIO),
+      video_frames_(DemuxerStream::VIDEO),
+      num_starvations_(0) {
+}
+
+MediaStatistics::~MediaStatistics() {}
+
+void MediaStatistics::Start() {
+  DVLOG(1) << "MediaStatistics::" << __FUNCTION__;

[xhwang, 2015/09/30 21:02:57]

nit: class name not necessary in the log..

[Tima Vaisburd, 2015/10/01 20:05:15]

Removed everywhere in this class.

+
+  Clear();
+  start_time_ = base::TimeTicks::Now();
+}
+
+void MediaStatistics::AddStarvation() {
+  DVLOG(1) << "MediaStatistics::" << __FUNCTION__;
+  ++num_starvations_;
+}
+
+void MediaStatistics::StopAndReport() {
+  DVLOG(1) << "MediaStatistics::" << __FUNCTION__;
+
+  if (start_time_.is_null())
+    return;  // skip if there was no prior Start().
+
+  base::TimeDelta duration = base::TimeTicks::Now() - start_time_;

[qinmin, 2015/09/29 23:47:44]

The duration is calculated from system time. Should we use the playback duration
instead?

[Tima Vaisburd, 2015/10/01 20:05:15]

Done.

+
+  // Reset start time.
+  start_time_ = base::TimeTicks();
+
+  if (duration < base::TimeDelta::FromSeconds(kMinDurationInSeconds))
+    return;  // duration is too short.
+
+  if (duration > base::TimeDelta::FromSeconds(kMaxDurationInSeconds))
+    return;  // duration is too long.
+
+  Report(duration);
+}
+
+void MediaStatistics::Clear() {
+  audio_frames_.Clear();
+  video_frames_.Clear();
+  num_starvations_ = 0;
+}
+
+void MediaStatistics::Report(base::TimeDelta duration) {
+  DVLOG(1) << "MediaStatistics::" << __FUNCTION__ << " duration:" << duration
+           << " audio frames:"
+           << audio_frames_.late << "/" << audio_frames_.total
+           << " video frames:"
+           << video_frames_.late << "/" << video_frames_.total;
+
+  UMA_HISTOGRAM_CUSTOM_TIMES(
+      "Media.MSE.Duration", duration,
+      base::TimeDelta::FromSeconds(kMinDurationInSeconds),
+      base::TimeDelta::FromSeconds(kMaxDurationInSeconds), kNumDurationSlots);
+
+  // Number of late frames per one million frames.
+
+  if (audio_frames_.total) {
+    UMA_HISTOGRAM_COUNTS("Media.MSE.LateAudioFrames",
+                         1000000 * audio_frames_.late / audio_frames_.total);
+  }
+
+  if (video_frames_.total) {
+    UMA_HISTOGRAM_COUNTS("Media.MSE.LateVideoFrames",
+                         1000000 * video_frames_.late / video_frames_.total);

[xhwang, 2015/09/30 21:02:57]

hmm, I wonder why we report frames per milliion frames? Can't we just report
this as a percentage?

[Tima Vaisburd, 2015/10/01 20:05:15]

We expect these values to be less than 1%, so parts per million seem more
appropriate here. I modified the code though and changed the upper limit from
10^6 to 10^4

+  }
+
+  // Number of starvations per one million frames.
+
+  uint32_t total_frames =
+      audio_frames_.total ? audio_frames_.total : video_frames_.total;
+  if (total_frames) {
+    UMA_HISTOGRAM_COUNTS("Media.MSE.Starvations",
+                         1000000 * num_starvations_ / total_frames);
+  }
+}
+
+}  // namespace media