Stop over-counting media decoder codec config src= UMAs

This change makes it more clear when exactly code that records
{Audio,Video}DecoderConfig UMA stats is to be done. Previously, it was
possible to record src= decoder config stats accidentally if using the
non-trivial config constructors. This at least included MSE and pepper shim
code paths, leading to double-counting configs in various cases
accidentally. There was also incorrect usage of Initialize()'s
|record_stats| parameter in at least some MSE code paths.

src= playback decoder config stats recording is now extracted
out of the decoder configs and AVStream converters and moved to
FFmpegDemuxer.

Known cases where we were incorrectly recording a src= codec config:
* MSE WebM audio initialization segment parsing
* MSE WebM video initialization segment parsing
* MSE MP2TS h264 es, mpeg1audio es, and adts es parsing
* DecryptingAudioDecoderTests (probably no impact of this)

BUG=522216
R=dalecurtis@chromium.org

Review URL: https://codereview.chromium.org/1293853006

Cr-Commit-Position: refs/heads/master@{#344872}

19 files changed, 132 insertions, 136 deletions

diff --git a/media/base/audio_decoder_config.cc b/media/base/audio_decoder_config.cc
index 780bada..6dc5b2f 100644
--- a/media/base/audio_decoder_config.cc
+++ b/media/base/audio_decoder_config.cc
@@ -5,8 +5,6 @@
 #include "media/base/audio_decoder_config.h"
 
 #include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "media/audio/sample_rates.h"
 #include "media/base/limits.h"
 
 namespace media {
@@ -30,8 +28,7 @@ AudioDecoderConfig::AudioDecoderConfig(AudioCodec codec,
                                        size_t extra_data_size,
                                        bool is_encrypted) {
   Initialize(codec, sample_format, channel_layout, samples_per_second,
-             extra_data, extra_data_size, is_encrypted, true,
-             base::TimeDelta(), 0);
+             extra_data, extra_data_size, is_encrypted, base::TimeDelta(), 0);
 }
 
 void AudioDecoderConfig::Initialize(AudioCodec codec,
@@ -41,27 +38,10 @@ void AudioDecoderConfig::Initialize(AudioCodec codec,
                                     const uint8* extra_data,
                                     size_t extra_data_size,
                                     bool is_encrypted,
-                                    bool record_stats,
                                     base::TimeDelta seek_preroll,
                                     int codec_delay) {
   CHECK((extra_data_size != 0) == (extra_data != NULL));
 
-  if (record_stats) {
-    UMA_HISTOGRAM_ENUMERATION("Media.AudioCodec", codec, kAudioCodecMax + 1);
-    UMA_HISTOGRAM_ENUMERATION("Media.AudioSampleFormat", sample_format,
-                              kSampleFormatMax + 1);
-    UMA_HISTOGRAM_ENUMERATION("Media.AudioChannelLayout", channel_layout,
-                              CHANNEL_LAYOUT_MAX + 1);
-    AudioSampleRate asr;
-    if (ToAudioSampleRate(samples_per_second, &asr)) {
-      UMA_HISTOGRAM_ENUMERATION("Media.AudioSamplesPerSecond", asr,
-                                kAudioSampleRateMax + 1);
-    } else {
-      UMA_HISTOGRAM_COUNTS(
-          "Media.AudioSamplesPerSecondUnexpected", samples_per_second);
-    }
-  }
-
   codec_ = codec;
   channel_layout_ = channel_layout;
   samples_per_second_ = samples_per_second;
diff --git a/media/base/audio_decoder_config.h b/media/base/audio_decoder_config.h
index 9b2fe96..c9c8593 100644
--- a/media/base/audio_decoder_config.h
+++ b/media/base/audio_decoder_config.h
@@ -65,10 +65,13 @@ class MEDIA_EXPORT AudioDecoderConfig {
   ~AudioDecoderConfig();
 
   // Resets the internal state of this object.  |codec_delay| is in frames.
-  void Initialize(AudioCodec codec, SampleFormat sample_format,
-                  ChannelLayout channel_layout, int samples_per_second,
-                  const uint8* extra_data, size_t extra_data_size,
-                  bool is_encrypted, bool record_stats,
+  void Initialize(AudioCodec codec,
+                  SampleFormat sample_format,
+                  ChannelLayout channel_layout,
+                  int samples_per_second,
+                  const uint8* extra_data,
+                  size_t extra_data_size,
+                  bool is_encrypted,
                   base::TimeDelta seek_preroll,
                   int codec_delay);
 
diff --git a/media/base/fake_demuxer_stream.cc b/media/base/fake_demuxer_stream.cc
index 843e50a..f2d5f0a 100644
--- a/media/base/fake_demuxer_stream.cc
+++ b/media/base/fake_demuxer_stream.cc
@@ -142,10 +142,10 @@ void FakeDemuxerStream::SeekToStart() {
 
 void FakeDemuxerStream::UpdateVideoDecoderConfig() {
   const gfx::Rect kVisibleRect(kStartWidth, kStartHeight);
-  video_decoder_config_.Initialize(
-      kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, PIXEL_FORMAT_YV12,
-      COLOR_SPACE_UNSPECIFIED, next_coded_size_, kVisibleRect, next_coded_size_,
-      NULL, 0, is_encrypted_, false);
+  video_decoder_config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
+                                   PIXEL_FORMAT_YV12, COLOR_SPACE_UNSPECIFIED,
+                                   next_coded_size_, kVisibleRect,
+                                   next_coded_size_, NULL, 0, is_encrypted_);
   next_coded_size_.Enlarge(kWidthDelta, kHeightDelta);
 }
 
diff --git a/media/base/video_decoder_config.cc b/media/base/video_decoder_config.cc
index 0ad2f62..501bf4d 100644
--- a/media/base/video_decoder_config.cc
+++ b/media/base/video_decoder_config.cc
@@ -5,7 +5,6 @@
 #include "media/base/video_decoder_config.h"
 
 #include "base/logging.h"
-#include "base/metrics/histogram.h"
 #include "media/base/video_frame.h"
 
 namespace media {
@@ -54,33 +53,11 @@ VideoDecoderConfig::VideoDecoderConfig(VideoCodec codec,
                                        size_t extra_data_size,
                                        bool is_encrypted) {
   Initialize(codec, profile, format, color_space, coded_size, visible_rect,
-             natural_size, extra_data, extra_data_size, is_encrypted, true);
+             natural_size, extra_data, extra_data_size, is_encrypted);
 }
 
 VideoDecoderConfig::~VideoDecoderConfig() {}
 
-// Some videos just want to watch the world burn, with a height of 0; cap the
-// "infinite" aspect ratio resulting.
-static const int kInfiniteRatio = 99999;
-
-// Common aspect ratios (multiplied by 100 and truncated) used for histogramming
-// video sizes.  These were taken on 20111103 from
-// http://wikipedia.org/wiki/Aspect_ratio_(image)#Previous_and_currently_used_aspect_ratios
-static const int kCommonAspectRatios100[] = {
-  100, 115, 133, 137, 143, 150, 155, 160, 166, 175, 177, 185, 200, 210, 220,
-  221, 235, 237, 240, 255, 259, 266, 276, 293, 400, 1200, kInfiniteRatio,
-};
-
-template<class T>  // T has int width() & height() methods.
-static void UmaHistogramAspectRatio(const char* name, const T& size) {
-  UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-      name,
-      // Intentionally use integer division to truncate the result.
-      size.height() ? (size.width() * 100) / size.height() : kInfiniteRatio,
-      base::CustomHistogram::ArrayToCustomRanges(
-          kCommonAspectRatios100, arraysize(kCommonAspectRatios100)));
-}
-
 void VideoDecoderConfig::Initialize(VideoCodec codec,
                                     VideoCodecProfile profile,
                                     VideoPixelFormat format,
@@ -90,27 +67,9 @@ void VideoDecoderConfig::Initialize(VideoCodec codec,
                                     const gfx::Size& natural_size,
                                     const uint8* extra_data,
                                     size_t extra_data_size,
-                                    bool is_encrypted,
-                                    bool record_stats) {
+                                    bool is_encrypted) {
   CHECK((extra_data_size != 0) == (extra_data != NULL));
 
-  if (record_stats) {
-    UMA_HISTOGRAM_ENUMERATION("Media.VideoCodec", codec, kVideoCodecMax + 1);
-    // Drop UNKNOWN because U_H_E() uses one bucket for all values less than 1.
-    if (profile >= 0) {
-      UMA_HISTOGRAM_ENUMERATION("Media.VideoCodecProfile", profile,
-                                VIDEO_CODEC_PROFILE_MAX + 1);
-    }
-    UMA_HISTOGRAM_COUNTS_10000("Media.VideoCodedWidth", coded_size.width());
-    UmaHistogramAspectRatio("Media.VideoCodedAspectRatio", coded_size);
-    UMA_HISTOGRAM_COUNTS_10000("Media.VideoVisibleWidth", visible_rect.width());
-    UmaHistogramAspectRatio("Media.VideoVisibleAspectRatio", visible_rect);
-    UMA_HISTOGRAM_ENUMERATION("Media.VideoFramePixelFormat", format,
-                              PIXEL_FORMAT_MAX + 1);
-    UMA_HISTOGRAM_ENUMERATION("Media.VideoFrameColorSpace", color_space,
-                              COLOR_SPACE_MAX + 1);
-  }
-
   codec_ = codec;
   profile_ = profile;
   format_ = format;
diff --git a/media/base/video_decoder_config.h b/media/base/video_decoder_config.h
index 4a227c3..91ead43 100644
--- a/media/base/video_decoder_config.h
+++ b/media/base/video_decoder_config.h
@@ -101,8 +101,7 @@ class MEDIA_EXPORT VideoDecoderConfig {
                   const gfx::Size& natural_size,
                   const uint8* extra_data,
                   size_t extra_data_size,
-                  bool is_encrypted,
-                  bool record_stats);
+                  bool is_encrypted);
 
   // Returns true if this object has appropriate configuration values, false
   // otherwise.
diff --git a/media/ffmpeg/ffmpeg_common.cc b/media/ffmpeg/ffmpeg_common.cc
index 8550712..5e95d45 100644
--- a/media/ffmpeg/ffmpeg_common.cc
+++ b/media/ffmpeg/ffmpeg_common.cc
@@ -276,11 +276,9 @@ static AVSampleFormat SampleFormatToAVSampleFormat(SampleFormat sample_format) {
   return AV_SAMPLE_FMT_NONE;
 }
 
-void AVCodecContextToAudioDecoderConfig(
-    const AVCodecContext* codec_context,
-    bool is_encrypted,
-    AudioDecoderConfig* config,
-    bool record_stats) {
+void AVCodecContextToAudioDecoderConfig(const AVCodecContext* codec_context,
+                                        bool is_encrypted,
+                                        AudioDecoderConfig* config) {
   DCHECK_EQ(codec_context->codec_type, AVMEDIA_TYPE_AUDIO);
 
   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
@@ -319,25 +317,22 @@ void AVCodecContextToAudioDecoderConfig(
                      codec_context->extradata,
                      codec_context->extradata_size,
                      is_encrypted,
-                     record_stats,
                      seek_preroll,
                      codec_context->delay);
+
   if (codec != kCodecOpus) {
     DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
               config->bits_per_channel());
   }
 }
 
-void AVStreamToAudioDecoderConfig(
-    const AVStream* stream,
-    AudioDecoderConfig* config,
-    bool record_stats) {
+void AVStreamToAudioDecoderConfig(const AVStream* stream,
+                                  AudioDecoderConfig* config) {
   bool is_encrypted = false;
   AVDictionaryEntry* key = av_dict_get(stream->metadata, "enc_key_id", NULL, 0);
   if (key)
     is_encrypted = true;
-  return AVCodecContextToAudioDecoderConfig(
-      stream->codec, is_encrypted, config, record_stats);
+  AVCodecContextToAudioDecoderConfig(stream->codec, is_encrypted, config);
 }
 
 void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
@@ -368,10 +363,8 @@ void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
   }
 }
 
-void AVStreamToVideoDecoderConfig(
-    const AVStream* stream,
-    VideoDecoderConfig* config,
-    bool record_stats) {
+void AVStreamToVideoDecoderConfig(const AVStream* stream,
+                                  VideoDecoderConfig* config) {
   gfx::Size coded_size(stream->codec->coded_width, stream->codec->coded_height);
 
   // TODO(vrk): This assumes decoded frame data starts at (0, 0), which is true
@@ -406,15 +399,6 @@ void AVStreamToVideoDecoderConfig(
   gfx::Size natural_size = GetNaturalSize(
       visible_rect.size(), aspect_ratio.num, aspect_ratio.den);
 
-  if (record_stats) {
-    // Note the PRESUBMIT_IGNORE_UMA_MAX below, this silences the PRESUBMIT.py
-    // check for uma enum max usage, since we're abusing
-    // UMA_HISTOGRAM_ENUMERATION to report a discrete value.
-    UMA_HISTOGRAM_ENUMERATION("Media.VideoColorRange",
-                              stream->codec->color_range,
-                              AVCOL_RANGE_NB);  // PRESUBMIT_IGNORE_UMA_MAX
-  }
-
   VideoPixelFormat format =
       AVPixelFormatToVideoPixelFormat(stream->codec->pix_fmt);
   // The format and coded size may be unknown if FFmpeg is compiled without
@@ -462,7 +446,7 @@ void AVStreamToVideoDecoderConfig(
 
   config->Initialize(codec, profile, format, color_space, coded_size,
                      visible_rect, natural_size, stream->codec->extradata,
-                     stream->codec->extradata_size, is_encrypted, record_stats);
+                     stream->codec->extradata_size, is_encrypted);
 }
 
 void VideoDecoderConfigToAVCodecContext(
diff --git a/media/ffmpeg/ffmpeg_common.h b/media/ffmpeg/ffmpeg_common.h
index a4dbcf3..90bf436 100644
--- a/media/ffmpeg/ffmpeg_common.h
+++ b/media/ffmpeg/ffmpeg_common.h
@@ -85,18 +85,14 @@ MEDIA_EXPORT base::TimeDelta ConvertFromTimeBase(const AVRational& time_base,
 MEDIA_EXPORT int64 ConvertToTimeBase(const AVRational& time_base,
                                      const base::TimeDelta& timestamp);
 
-void AVStreamToAudioDecoderConfig(
-    const AVStream* stream,
-    AudioDecoderConfig* config,
-    bool record_stats);
+void AVStreamToAudioDecoderConfig(const AVStream* stream,
+                                  AudioDecoderConfig* config);
 void AudioDecoderConfigToAVCodecContext(
     const AudioDecoderConfig& config,
     AVCodecContext* codec_context);
 
-void AVStreamToVideoDecoderConfig(
-    const AVStream* stream,
-    VideoDecoderConfig* config,
-    bool record_stats);
+void AVStreamToVideoDecoderConfig(const AVStream* stream,
+                                  VideoDecoderConfig* config);
 void VideoDecoderConfigToAVCodecContext(
     const VideoDecoderConfig& config,
     AVCodecContext* codec_context);
@@ -104,8 +100,7 @@ void VideoDecoderConfigToAVCodecContext(
 MEDIA_EXPORT void AVCodecContextToAudioDecoderConfig(
     const AVCodecContext* codec_context,
     bool is_encrypted,
-    AudioDecoderConfig* config,
-    bool record_stats);
+    AudioDecoderConfig* config);
 
 // Converts FFmpeg's channel layout to chrome's ChannelLayout.  |channels| can
 // be used when FFmpeg's channel layout is not informative in order to make a
diff --git a/media/ffmpeg/ffmpeg_common_unittest.cc b/media/ffmpeg/ffmpeg_common_unittest.cc
index b8cf99f..3ac224e 100644
--- a/media/ffmpeg/ffmpeg_common_unittest.cc
+++ b/media/ffmpeg/ffmpeg_common_unittest.cc
@@ -405,7 +405,7 @@ TEST_F(FFmpegCommonTest, OpusAudioDecoderConfig) {
   context.sample_rate = 44100;
 
   AudioDecoderConfig decoder_config;
-  AVCodecContextToAudioDecoderConfig(&context, false, &decoder_config, false);
+  AVCodecContextToAudioDecoderConfig(&context, false, &decoder_config);
   EXPECT_EQ(48000, decoder_config.samples_per_second());
 }
 
diff --git a/media/filters/audio_decoder_unittest.cc b/media/filters/audio_decoder_unittest.cc
index d428107..58df1fc 100644
--- a/media/filters/audio_decoder_unittest.cc
+++ b/media/filters/audio_decoder_unittest.cc
@@ -150,8 +150,8 @@ class AudioDecoderTest : public testing::TestWithParam<DecoderTestData> {
     ASSERT_TRUE(reader_->SeekForTesting(start_timestamp_));
 
     AudioDecoderConfig config;
-    AVCodecContextToAudioDecoderConfig(
-        reader_->codec_context_for_testing(), false, &config, false);
+    AVCodecContextToAudioDecoderConfig(reader_->codec_context_for_testing(),
+                                       false, &config);
 
     EXPECT_EQ(GetParam().codec, config.codec());
     EXPECT_EQ(GetParam().samples_per_second, config.samples_per_second());
@@ -381,7 +381,6 @@ TEST_P(OpusAudioDecoderBehavioralTest, InitializeWithNoCodecDelay) {
                             kOpusExtraData,
                             arraysize(kOpusExtraData),
                             false,
-                            false,
                             base::TimeDelta::FromMilliseconds(80),
                             0);
   InitializeDecoder(decoder_config);
@@ -398,7 +397,6 @@ TEST_P(OpusAudioDecoderBehavioralTest, InitializeWithBadCodecDelay) {
       kOpusExtraData,
       arraysize(kOpusExtraData),
       false,
-      false,
       base::TimeDelta::FromMilliseconds(80),
       // Use a different codec delay than in the extradata.
       100);
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index a54eb0c..59d7a3e 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -118,7 +118,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32,
-                       CHANNEL_LAYOUT_STEREO, kSampleRate, NULL, 0, true, true,
+                       CHANNEL_LAYOUT_STEREO, kSampleRate, NULL, 0, true,
                        base::TimeDelta(), 0);
     InitializeAndExpectResult(config_, true);
   }
diff --git a/media/filters/decrypting_demuxer_stream.cc b/media/filters/decrypting_demuxer_stream.cc
index 54734fa..ff98122 100644
--- a/media/filters/decrypting_demuxer_stream.cc
+++ b/media/filters/decrypting_demuxer_stream.cc
@@ -387,7 +387,6 @@ void DecryptingDemuxerStream::InitializeDecoderConfig() {
                                input_audio_config.extra_data(),
                                input_audio_config.extra_data_size(),
                                false,  // Output audio is not encrypted.
-                               false,
                                input_audio_config.seek_preroll(),
                                input_audio_config.codec_delay());
       break;
@@ -402,8 +401,7 @@ void DecryptingDemuxerStream::InitializeDecoderConfig() {
           input_video_config.coded_size(), input_video_config.visible_rect(),
           input_video_config.natural_size(), input_video_config.extra_data(),
           input_video_config.extra_data_size(),
-          false,  // Output video is not encrypted.
-          false);
+          false);  // Output video is not encrypted.
       break;
     }
 
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index fbc16f5..c64e102 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -10,6 +10,7 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ -19,6 +20,7 @@
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "media/audio/sample_rates.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
@@ -80,6 +82,79 @@ static base::TimeDelta ExtractStartTime(AVStream* stream,
   return start_time;
 }
 
+// Some videos just want to watch the world burn, with a height of 0; cap the
+// "infinite" aspect ratio resulting.
+const int kInfiniteRatio = 99999;
+
+// Common aspect ratios (multiplied by 100 and truncated) used for histogramming
+// video sizes.  These were taken on 20111103 from
+// http://wikipedia.org/wiki/Aspect_ratio_(image)#Previous_and_currently_used_aspect_ratios
+const int kCommonAspectRatios100[] = {
+    100, 115, 133, 137, 143, 150, 155, 160,  166,
+    175, 177, 185, 200, 210, 220, 221, 235,  237,
+    240, 255, 259, 266, 276, 293, 400, 1200, kInfiniteRatio,
+};
+
+template <class T>  // T has int width() & height() methods.
+static void UmaHistogramAspectRatio(const char* name, const T& size) {
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION(
+      name,
+      // Intentionally use integer division to truncate the result.
+      size.height() ? (size.width() * 100) / size.height() : kInfiniteRatio,
+      base::CustomHistogram::ArrayToCustomRanges(
+          kCommonAspectRatios100, arraysize(kCommonAspectRatios100)));
+}
+
+// Record audio decoder config UMA stats corresponding to a src= playback.
+static void RecordAudioCodecStats(const AudioDecoderConfig& audio_config) {
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioCodec", audio_config.codec(),
+                            kAudioCodecMax + 1);
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioSampleFormat",
+                            audio_config.sample_format(), kSampleFormatMax + 1);
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioChannelLayout",
+                            audio_config.channel_layout(),
+                            CHANNEL_LAYOUT_MAX + 1);
+  AudioSampleRate asr;
+  if (ToAudioSampleRate(audio_config.samples_per_second(), &asr)) {
+    UMA_HISTOGRAM_ENUMERATION("Media.AudioSamplesPerSecond", asr,
+                              kAudioSampleRateMax + 1);
+  } else {
+    UMA_HISTOGRAM_COUNTS("Media.AudioSamplesPerSecondUnexpected",
+                         audio_config.samples_per_second());
+  }
+}
+
+// Record video decoder config UMA stats corresponding to a src= playback.
+static void RecordVideoCodecStats(const VideoDecoderConfig& video_config,
+                                  AVColorRange color_range) {
+  UMA_HISTOGRAM_ENUMERATION("Media.VideoCodec", video_config.codec(),
+                            kVideoCodecMax + 1);
+
+  // Drop UNKNOWN because U_H_E() uses one bucket for all values less than 1.
+  if (video_config.profile() >= 0) {
+    UMA_HISTOGRAM_ENUMERATION("Media.VideoCodecProfile", video_config.profile(),
+                              VIDEO_CODEC_PROFILE_MAX + 1);
+  }
+  UMA_HISTOGRAM_COUNTS_10000("Media.VideoCodedWidth",
+                             video_config.coded_size().width());
+  UmaHistogramAspectRatio("Media.VideoCodedAspectRatio",
+                          video_config.coded_size());
+  UMA_HISTOGRAM_COUNTS_10000("Media.VideoVisibleWidth",
+                             video_config.visible_rect().width());
+  UmaHistogramAspectRatio("Media.VideoVisibleAspectRatio",
+                          video_config.visible_rect());
+  UMA_HISTOGRAM_ENUMERATION("Media.VideoFramePixelFormat",
+                            video_config.format(), PIXEL_FORMAT_MAX + 1);
+  UMA_HISTOGRAM_ENUMERATION("Media.VideoFrameColorSpace",
+                            video_config.color_space(), COLOR_SPACE_MAX + 1);
+
+  // Note the PRESUBMIT_IGNORE_UMA_MAX below, this silences the PRESUBMIT.py
+  // check for uma enum max usage, since we're abusing
+  // UMA_HISTOGRAM_ENUMERATION to report a discrete value.
+  UMA_HISTOGRAM_ENUMERATION("Media.VideoColorRange", color_range,
+                            AVCOL_RANGE_NB);  // PRESUBMIT_IGNORE_UMA_MAX
+}
+
 //
 // FFmpegDemuxerStream
 //
@@ -105,12 +180,12 @@ FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
-      AVStreamToAudioDecoderConfig(stream, &audio_config_, true);
+      AVStreamToAudioDecoderConfig(stream, &audio_config_);
       is_encrypted = audio_config_.is_encrypted();
       break;
     case AVMEDIA_TYPE_VIDEO:
       type_ = VIDEO;
-      AVStreamToVideoDecoderConfig(stream, &video_config_, true);
+      AVStreamToVideoDecoderConfig(stream, &video_config_);
       is_encrypted = video_config_.is_encrypted();
 
       rotation_entry = av_dict_get(stream->metadata, "rotate", NULL, 0);
@@ -912,7 +987,7 @@ void FFmpegDemuxer::OnFindStreamInfoDone(const PipelineStatusCB& status_cb,
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // channel layout and sample format are valid.
-      AVStreamToAudioDecoderConfig(stream, &audio_config, false);
+      AVStreamToAudioDecoderConfig(stream, &audio_config);
       if (!audio_config.IsValidConfig())
         continue;
       audio_stream = stream;
@@ -925,7 +1000,7 @@ void FFmpegDemuxer::OnFindStreamInfoDone(const PipelineStatusCB& status_cb,
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // frame size and visible size are valid.
-      AVStreamToVideoDecoderConfig(stream, &video_config, false);
+      AVStreamToVideoDecoderConfig(stream, &video_config);
 
       if (!video_config.IsValidConfig())
         continue;
@@ -939,6 +1014,16 @@ void FFmpegDemuxer::OnFindStreamInfoDone(const PipelineStatusCB& status_cb,
     }
 
     streams_[i] = new FFmpegDemuxerStream(this, stream);
+
+    // Record audio or video src= playback UMA stats for the stream's decoder
+    // config.
+    if (codec_type == AVMEDIA_TYPE_AUDIO) {
+      RecordAudioCodecStats(streams_[i]->audio_decoder_config());
+    } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
+      RecordVideoCodecStats(streams_[i]->video_decoder_config(),
+                            stream->codec->color_range);
+    }
+
     max_duration = std::max(max_duration, streams_[i]->duration());
 
     const base::TimeDelta start_time =
diff --git a/media/filters/source_buffer_stream_unittest.cc b/media/filters/source_buffer_stream_unittest.cc
index 8f51876..2173610 100644
--- a/media/filters/source_buffer_stream_unittest.cc
+++ b/media/filters/source_buffer_stream_unittest.cc
@@ -108,7 +108,6 @@ class SourceBufferStreamTest : public testing::Test {
                              NULL,
                              0,
                              false,
-                             false,
                              base::TimeDelta(),
                              0);
     stream_.reset(new SourceBufferStream(audio_config_, media_log_, true));
@@ -4089,7 +4088,7 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoMillisecondSplices) {
 
   video_config_ = TestVideoConfig::Invalid();
   audio_config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32,
-                           CHANNEL_LAYOUT_STEREO, 4000, NULL, 0, false, false,
+                           CHANNEL_LAYOUT_STEREO, 4000, NULL, 0, false,
                            base::TimeDelta(), 0);
   stream_.reset(new SourceBufferStream(audio_config_, media_log_, true));
   // Equivalent to 0.5ms per frame.
diff --git a/media/formats/mp4/mp4_stream_parser.cc b/media/formats/mp4/mp4_stream_parser.cc
index 0c64e35..1f0dfa9 100644
--- a/media/formats/mp4/mp4_stream_parser.cc
+++ b/media/formats/mp4/mp4_stream_parser.cc
@@ -268,8 +268,7 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
       audio_config.Initialize(
           codec, sample_format, channel_layout, sample_per_second,
           extra_data.size() ? &extra_data[0] : NULL, extra_data.size(),
-          is_audio_track_encrypted_, false, base::TimeDelta(),
-          0);
+          is_audio_track_encrypted_, base::TimeDelta(), 0);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
@@ -312,7 +311,7 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
                               natural_size,
                               // No decoder-specific buffer needed for AVC;
                               // SPS/PPS are embedded in the video stream
-                              NULL, 0, is_video_track_encrypted_, false);
+                              NULL, 0, is_video_track_encrypted_);
       has_video_ = true;
       video_track_id_ = track->header.track_id;
     }
diff --git a/media/formats/mpeg/mpeg_audio_stream_parser_base.cc b/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
index c79724d..6cab655 100644
--- a/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
+++ b/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
@@ -209,7 +209,6 @@ int MPEGAudioStreamParserBase::ParseFrame(const uint8* data,
                        NULL,
                        0,
                        false,
-                       false,
                        base::TimeDelta(),
                        codec_delay_);
 
diff --git a/media/formats/webm/webm_audio_client.cc b/media/formats/webm/webm_audio_client.cc
index 90ac4a8..bde7233 100644
--- a/media/formats/webm/webm_audio_client.cc
+++ b/media/formats/webm/webm_audio_client.cc
@@ -90,7 +90,6 @@ bool WebMAudioClient::InitializeConfig(
       extra_data,
       extra_data_size,
       is_encrypted,
-      true,
       base::TimeDelta::FromMicroseconds(
           (seek_preroll != -1 ? seek_preroll : 0) / 1000),
       codec_delay_in_frames);
diff --git a/media/formats/webm/webm_video_client.cc b/media/formats/webm/webm_video_client.cc
index ef8bc0f..2d3f43b 100644
--- a/media/formats/webm/webm_video_client.cc
+++ b/media/formats/webm/webm_video_client.cc
@@ -97,7 +97,7 @@ bool WebMVideoClient::InitializeConfig(
 
   config->Initialize(video_codec, profile, format, COLOR_SPACE_HD_REC709,
                      coded_size, visible_rect, natural_size, extra_data,
-                     extra_data_size, is_encrypted, true);
+                     extra_data_size, is_encrypted);
   return config->IsValidConfig();
 }
 
diff --git a/media/mojo/services/media_type_converters.cc b/media/mojo/services/media_type_converters.cc
index a77adb6..e228f25 100644
--- a/media/mojo/services/media_type_converters.cc
+++ b/media/mojo/services/media_type_converters.cc
@@ -437,7 +437,6 @@ TypeConverter<media::AudioDecoderConfig,
       input->extra_data.size() ? &input->extra_data.front() : NULL,
       input->extra_data.size(),
       input->is_encrypted,
-      false,
       base::TimeDelta::FromMicroseconds(input->seek_preroll_usec),
       input->codec_delay);
   return config;
@@ -482,7 +481,7 @@ TypeConverter<media::VideoDecoderConfig,
       input->coded_size.To<gfx::Size>(), input->visible_rect.To<gfx::Rect>(),
       input->natural_size.To<gfx::Size>(),
       input->extra_data.size() ? &input->extra_data.front() : NULL,
-      input->extra_data.size(), input->is_encrypted, false);
+      input->extra_data.size(), input->is_encrypted);
   return config;
 }
 
diff --git a/media/mojo/services/media_type_converters_unittest.cc b/media/mojo/services/media_type_converters_unittest.cc
index 5ca24c2..54cd665 100644
--- a/media/mojo/services/media_type_converters_unittest.cc
+++ b/media/mojo/services/media_type_converters_unittest.cc
@@ -126,7 +126,7 @@ TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_Normal) {
   AudioDecoderConfig config;
   config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
                     reinterpret_cast<const uint8*>(&kExtraData), kExtraDataSize,
-                    false, false, base::TimeDelta(), 0);
+                    false, base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
   AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
@@ -136,7 +136,7 @@ TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_Normal) {
 TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_NullExtraData) {
   AudioDecoderConfig config;
   config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
-                    NULL, 0, false, false, base::TimeDelta(), 0);
+                    NULL, 0, false, base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
   AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
@@ -148,7 +148,7 @@ TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_Encrypted) {
   config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
                     NULL, 0,
                     true,  // Is encrypted.
-                    false, base::TimeDelta(), 0);
+                    base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
   AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());