MSE: Chromium implementation support for SourceBuffer.changeType

Adds ability for ChunkDemuxer and SourceBufferState to indicate whether
a changeType request's type can be satisfied (using successful
construction of an associated StreamParser as the condition), and to
effect changeType by resetting the SourceBufferState's StreamParser.

SourceBufferState's state machine is expanded to allow for enforcing
at-most-one invocation of it's |init_cb_|, while continuing to require
that a newly constructed StreamParser first successfully handle an
initialization segment.

Since this CL does not relax the existing codec-strictness of
StreamParserFactory (and, by extension, MediaSource.addSourceBuffer), it
uses the same strictness for CanChangeType.  Any relaxation can be done
in later CLs.

Also, since such codec strictness is still in place, SourceBufferStream
codec changes (more than just existing support for same-codec config
changes) are allowed only when handling the first initialization segment
following a changeType request, and only if the SourceBuffer had
previously handled an initialization segment.

Later CLs will include changeType pipeline integration tests, Blink API
experimental support for changeType, and changeType web-platform-tests.

BUG=605134

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I57e6ef175c9e06ca59db03f8c07ebd6070504af4
Reviewed-on: https://chromium-review.googlesource.com/1110483
Commit-Queue: Matthew Wolenetz <wolenetz@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569492}

media/filters/chunk_demuxer.cc

@@ -52,6 +52,34 @@ using base::TimeDelta;
     }                                                                   \
   }
 
+namespace {
+
+// Helper to attempt construction of a StreamParser specific to |type| and
+// |codecs|.
+// TODO(wolenetz): Consider relocating this to StreamParserFactory in
+// conjunction with updating StreamParserFactory's isTypeSupported() to also
+// parse codecs, rather than require preparsed vector.
+std::unique_ptr<media::StreamParser> CreateParserForTypeAndCodecs(
+    const std::string& type,
+    const std::string& codecs,
+    media::MediaLog* media_log) {
+  std::vector<std::string> parsed_codec_ids;
+  media::SplitCodecsToVector(codecs, &parsed_codec_ids, false);
+  return media::StreamParserFactory::Create(type, parsed_codec_ids, media_log);
+}
+
+// Helper to calculate the expected codecs parsed from initialization segments
+// for a few mime types that have an implicit codec.
+std::string ExpectedCodecs(const std::string& type, const std::string& codecs) {
+  if (codecs == "" && type == "audio/aac")
+    return "aac";
+  if (codecs == "" && (type == "audio/mpeg" || type == "audio/mp3"))
+    return "mp3";
+  return codecs;
+}
+
+}  // namespace
+
 namespace media {
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type,
@@ -228,6 +256,7 @@ void ChunkDemuxerStream::OnStartOfCodedFrameGroup(DecodeTimestamp start_dts,
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
+                                           bool allow_codec_change,
                                            MediaLog* media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
@@ -245,10 +274,11 @@ bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
     return true;
   }
 
-  return SBSTREAM_OP(UpdateAudioConfig(config));
+  return SBSTREAM_OP(UpdateAudioConfig(config, allow_codec_change));
 }
 
 bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
+                                           bool allow_codec_change,
                                            MediaLog* media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
@@ -260,7 +290,7 @@ bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
     return true;
   }
 
-  return SBSTREAM_OP(UpdateVideoConfig(config));
+  return SBSTREAM_OP(UpdateVideoConfig(config, allow_codec_change));
 }
 
 void ChunkDemuxerStream::UpdateTextConfig(const TextTrackConfig& config,
@@ -627,12 +657,8 @@ ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
   // needed. See https://crbug.com/786975.
   CHECK(!init_cb_.is_null());
 
-  std::vector<std::string> parsed_codec_ids;
-  media::SplitCodecsToVector(codecs, &parsed_codec_ids, false);
-
   std::unique_ptr<media::StreamParser> stream_parser(
-      StreamParserFactory::Create(type, parsed_codec_ids, media_log_));
-
+      CreateParserForTypeAndCodecs(type, codecs, media_log_));
   if (!stream_parser) {
     DVLOG(1) << __func__ << " failed: unsupported mime_type=" << type
              << " codecs=" << codecs;
@@ -663,16 +689,10 @@ ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
   CHECK(*insert_result.first == id);
   CHECK(insert_result.second);  // Only true if insertion succeeded.
 
-  std::string expected_sbs_codecs = codecs;
-  if (codecs == "" && type == "audio/aac")
-    expected_sbs_codecs = "aac";
-  if (codecs == "" && (type == "audio/mpeg" || type == "audio/mp3"))
-    expected_sbs_codecs = "mp3";
-
   source_state->Init(base::BindOnce(&ChunkDemuxer::OnSourceInitDone,
                                     base::Unretained(this), id),
-                     expected_sbs_codecs, encrypted_media_init_data_cb_,
-                     new_text_track_cb);
+                     ExpectedCodecs(type, codecs),
+                     encrypted_media_init_data_cb_, new_text_track_cb);
 
   // TODO(wolenetz): Change to DCHECKs once less verification in release build
   // is needed. See https://crbug.com/786975.
@@ -940,6 +960,51 @@ void ChunkDemuxer::Remove(const std::string& id, TimeDelta start,
   host_->OnBufferedTimeRangesChanged(GetBufferedRanges_Locked());
 }
 
+bool ChunkDemuxer::CanChangeTypeTo(const std::string& id,
+                                   const std::string& type,
+                                   const std::string& codecs) {
+  // Note, Chromium currently will not compare type's codec parameters, if any,
+  // with previous type of the SourceBuffer.
+  // TODO(wolenetz): Consider returning false if the codec parameters
+  // are ever made to be precise such that they signal number of tracks of
+  // various media types differ from the first initialization segment (if
+  // received already). Switching to an audio-only container, when the first
+  // initialization segment only contained non-audio tracks, is one example we
+  // could enforce earlier here.
+
+  DVLOG(1) << __func__ << " id=" << id << " mime_type=" << type
+           << " codecs=" << codecs;
+  base::AutoLock auto_lock(lock_);
+
+  DCHECK(IsValidId(id));
+
+  // CanChangeType() doesn't care if there has or hasn't been received a first
+  // initialization segment for the source buffer corresponding to |id|.
+
+  std::unique_ptr<media::StreamParser> stream_parser(
+      CreateParserForTypeAndCodecs(type, codecs, media_log_));
+  return !!stream_parser;
+}
+
+void ChunkDemuxer::ChangeType(const std::string& id,
+                              const std::string& type,
+                              const std::string& codecs) {
+  DVLOG(1) << __func__ << " id=" << id << " mime_type=" << type
+           << " codecs=" << codecs;
+
+  base::AutoLock auto_lock(lock_);
+
+  DCHECK(state_ == INITIALIZING || state_ == INITIALIZED) << state_;
+  DCHECK(IsValidId(id));
+
+  std::unique_ptr<media::StreamParser> stream_parser(
+      CreateParserForTypeAndCodecs(type, codecs, media_log_));
+  // Caller should query CanChangeType() first to protect from failing this.
+  DCHECK(stream_parser);
+  source_state_map_[id]->ChangeType(std::move(stream_parser),
+                                    ExpectedCodecs(type, codecs));
+}
+
 double ChunkDemuxer::GetDuration() {
   base::AutoLock auto_lock(lock_);
   return GetDuration_Locked();

media/filters/chunk_demuxer.h

@@ -103,10 +103,16 @@ class MEDIA_EXPORT ChunkDemuxerStream : public DemuxerStream {
                                 base::TimeDelta start_pts);
 
   // Called when midstream config updates occur.
+  // For audio and video, if the codec is allowed to change, the caller should
+  // set |allow_codec_change| to true.
   // Returns true if the new config is accepted.
   // Returns false if the new config should trigger an error.
-  bool UpdateAudioConfig(const AudioDecoderConfig& config, MediaLog* media_log);
-  bool UpdateVideoConfig(const VideoDecoderConfig& config, MediaLog* media_log);
+  bool UpdateAudioConfig(const AudioDecoderConfig& config,
+                         bool allow_codec_change,
+                         MediaLog* media_log);
+  bool UpdateVideoConfig(const VideoDecoderConfig& config,
+                         bool allow_codec_change,
+                         MediaLog* media_log);
   void UpdateTextConfig(const TextTrackConfig& config, MediaLog* media_log);
 
   void MarkEndOfStream();
@@ -283,6 +289,23 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
   void Remove(const std::string& id, base::TimeDelta start,
               base::TimeDelta end);
 
+  // Returns whether or not the source buffer associated with |id| can change
+  // its parser type to one which parses |type| and |codecs|.  |type| indicates
+  // the MIME type for the data that we intend to append for this |id|.
+  bool CanChangeTypeTo(const std::string& id,
+                       const std::string& type,
+                       const std::string& codecs);
+
+  // For the source buffer associated with |id|, changes its parser type to one
+  // which parses |type| and |codecs|.  |type| indicates the MIME type for the
+  // data that we intend to append for this |id|.  Caller must first ensure
+  // CanChangeTypeTo() returns true for the same parameters.  Caller must also
+  // ensure that ResetParserState() is done before calling this, to flush any
+  // pending frames.
+  void ChangeType(const std::string& id,
+                  const std::string& type,
+                  const std::string& codecs);
+
   // If the buffer is full, attempts to try to free up space, as specified in
   // the "Coded Frame Eviction Algorithm" in the Media Source Extensions Spec.
   // Returns false iff buffer is still full after running eviction.

media/filters/frame_processor_unittest.cc

@@ -352,15 +352,16 @@ class FrameProcessorTest
                                           CHANNEL_LAYOUT_STEREO, 1000,
                                           EmptyExtraData(), Unencrypted());
         frame_processor_->OnPossibleAudioConfigUpdate(decoder_config);
-        ASSERT_TRUE(audio_->UpdateAudioConfig(decoder_config, &media_log_));
+        ASSERT_TRUE(
+            audio_->UpdateAudioConfig(decoder_config, false, &media_log_));
         break;
       }
       case DemuxerStream::VIDEO: {
         ASSERT_FALSE(video_);
         video_.reset(
             new ChunkDemuxerStream(DemuxerStream::VIDEO, "2", range_api_));
-        ASSERT_TRUE(
-            video_->UpdateVideoConfig(TestVideoConfig::Normal(), &media_log_));
+        ASSERT_TRUE(video_->UpdateVideoConfig(TestVideoConfig::Normal(), false,
+                                              &media_log_));
         break;
       }
       // TODO(wolenetz): Test text coded frame processing.

media/filters/source_buffer_state.cc

@@ -155,42 +155,24 @@ void SourceBufferState::Init(
   init_cb_ = std::move(init_cb);
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_text_track_cb_ = new_text_track_cb;
+  state_ = PENDING_PARSER_CONFIG;
+  InitializeParser(expected_codecs);
+}
 
-  std::vector<std::string> expected_codecs_parsed;
-  SplitCodecsToVector(expected_codecs, &expected_codecs_parsed, false);
+void SourceBufferState::ChangeType(
+    std::unique_ptr<StreamParser> new_stream_parser,
+    const std::string& new_expected_codecs) {
+  DCHECK_GE(state_, PENDING_PARSER_CONFIG);
+  DCHECK_NE(state_, PENDING_PARSER_INIT);
+  DCHECK(!parsing_media_segment_);
 
-  std::vector<AudioCodec> expected_acodecs;
-  std::vector<VideoCodec> expected_vcodecs;
-  for (const auto& codec_id : expected_codecs_parsed) {
-    AudioCodec acodec = StringToAudioCodec(codec_id);
-    if (acodec != kUnknownAudioCodec) {
-      expected_audio_codecs_.push_back(acodec);
-      continue;
-    }
-    VideoCodec vcodec = StringToVideoCodec(codec_id);
-    if (vcodec != kUnknownVideoCodec) {
-      expected_video_codecs_.push_back(vcodec);
-      continue;
-    }
-    MEDIA_LOG(INFO, media_log_) << "Unrecognized media codec: " << codec_id;
-  }
+  // If this source buffer has already handled an initialization segment, avoid
+  // running |init_cb_| again later.
+  if (state_ == PARSER_INITIALIZED)
+    state_ = PENDING_PARSER_RECONFIG;
 
-  state_ = PENDING_PARSER_CONFIG;
-  stream_parser_->Init(
-      base::BindOnce(&SourceBufferState::OnSourceInitDone,
-                     base::Unretained(this)),
-      base::BindRepeating(&SourceBufferState::OnNewConfigs,
-                          base::Unretained(this), expected_codecs),
-      base::BindRepeating(&SourceBufferState::OnNewBuffers,
-                          base::Unretained(this)),
-      new_text_track_cb_.is_null(),
-      base::BindRepeating(&SourceBufferState::OnEncryptedMediaInitData,
-                          base::Unretained(this)),
-      base::BindRepeating(&SourceBufferState::OnNewMediaSegment,
-                          base::Unretained(this)),
-      base::BindRepeating(&SourceBufferState::OnEndOfMediaSegment,
-                          base::Unretained(this)),
-      media_log_);
+  stream_parser_ = std::move(new_stream_parser);
+  InitializeParser(new_expected_codecs);
 }
 
 void SourceBufferState::SetSequenceMode(bool sequence_mode) {
@@ -558,6 +540,46 @@ bool SourceBufferState::IsSeekWaitingForData() const {
   return false;
 }
 
+void SourceBufferState::InitializeParser(const std::string& expected_codecs) {
+  expected_audio_codecs_.clear();
+  expected_video_codecs_.clear();
+
+  std::vector<std::string> expected_codecs_parsed;
+  SplitCodecsToVector(expected_codecs, &expected_codecs_parsed, false);
+
+  std::vector<AudioCodec> expected_acodecs;
+  std::vector<VideoCodec> expected_vcodecs;
+  for (const auto& codec_id : expected_codecs_parsed) {
+    AudioCodec acodec = StringToAudioCodec(codec_id);
+    if (acodec != kUnknownAudioCodec) {
+      expected_audio_codecs_.push_back(acodec);
+      continue;
+    }
+    VideoCodec vcodec = StringToVideoCodec(codec_id);
+    if (vcodec != kUnknownVideoCodec) {
+      expected_video_codecs_.push_back(vcodec);
+      continue;
+    }
+    MEDIA_LOG(INFO, media_log_) << "Unrecognized media codec: " << codec_id;
+  }
+
+  stream_parser_->Init(
+      base::BindOnce(&SourceBufferState::OnSourceInitDone,
+                     base::Unretained(this)),
+      base::BindRepeating(&SourceBufferState::OnNewConfigs,
+                          base::Unretained(this), expected_codecs),
+      base::BindRepeating(&SourceBufferState::OnNewBuffers,
+                          base::Unretained(this)),
+      new_text_track_cb_.is_null(),
+      base::BindRepeating(&SourceBufferState::OnEncryptedMediaInitData,
+                          base::Unretained(this)),
+      base::BindRepeating(&SourceBufferState::OnNewMediaSegment,
+                          base::Unretained(this)),
+      base::BindRepeating(&SourceBufferState::OnEndOfMediaSegment,
+                          base::Unretained(this)),
+      media_log_);
+}
+
 bool SourceBufferState::OnNewConfigs(
     std::string expected_codecs,
     std::unique_ptr<MediaTracks> tracks,
@@ -589,6 +611,11 @@ bool SourceBufferState::OnNewConfigs(
   std::vector<AudioCodec> expected_acodecs = expected_audio_codecs_;
   std::vector<VideoCodec> expected_vcodecs = expected_video_codecs_;
 
+  // TODO(wolenetz): Once codec strictness is relaxed, we can change
+  // |allow_codec_changes| to always be true. Until then, we only allow codec
+  // changes on explicit ChangeType().
+  const bool allow_codec_changes = state_ == PENDING_PARSER_RECONFIG;
+
   FrameProcessor::TrackIdChanges track_id_changes;
   for (const auto& track : tracks->tracks()) {
     const auto& track_id = track->bytestream_track_id();
@@ -648,7 +675,8 @@ bool SourceBufferState::OnNewConfigs(
 
       track->set_id(stream->media_track_id());
       frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
-      success &= stream->UpdateAudioConfig(audio_config, media_log_);
+      success &= stream->UpdateAudioConfig(audio_config, allow_codec_changes,
+                                           media_log_);
     } else if (track->type() == MediaTrack::Video) {
       VideoDecoderConfig video_config = tracks->getVideoConfig(track_id);
       DVLOG(1) << "Video track_id=" << track_id
@@ -703,7 +731,8 @@ bool SourceBufferState::OnNewConfigs(
       }
 
       track->set_id(stream->media_track_id());
-      success &= stream->UpdateVideoConfig(video_config, media_log_);
+      success &= stream->UpdateVideoConfig(video_config, allow_codec_changes,
+                                           media_log_);
     } else {
       MEDIA_LOG(ERROR, media_log_) << "Error: unsupported media track type "
                                    << track->type();
@@ -811,6 +840,8 @@ bool SourceBufferState::OnNewConfigs(
   if (success) {
     if (state_ == PENDING_PARSER_CONFIG)
       state_ = PENDING_PARSER_INIT;
+    if (state_ == PENDING_PARSER_RECONFIG)
+      state_ = PENDING_PARSER_REINIT;
     DCHECK(!init_segment_received_cb_.is_null());
     init_segment_received_cb_.Run(std::move(tracks));
   }
@@ -935,9 +966,15 @@ void SourceBufferState::OnEncryptedMediaInitData(
 
 void SourceBufferState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
-  DCHECK_EQ(state_, PENDING_PARSER_INIT);
+  // We've either yet-to-run |init_cb_| if pending init, or we've previously
+  // run it if pending reinit.
+  DCHECK((!init_cb_.is_null() && state_ == PENDING_PARSER_INIT) ||
+         (init_cb_.is_null() && state_ == PENDING_PARSER_REINIT));
+  State old_state = state_;
   state_ = PARSER_INITIALIZED;
-  std::move(init_cb_).Run(params);
+
+  if (old_state == PENDING_PARSER_INIT)
+    std::move(init_cb_).Run(params);
 }
 
 }  // namespace media

media/filters/source_buffer_state.h

@@ -50,6 +50,12 @@ class MEDIA_EXPORT SourceBufferState {
                 encrypted_media_init_data_cb,
             const NewTextTrackCB& new_text_track_cb);
 
+  // Reconfigures this source buffer to use |new_stream_parser|. Caller must
+  // first ensure that ResetParserState() was done to flush any pending frames
+  // from the old stream parser.
+  void ChangeType(std::unique_ptr<StreamParser> new_stream_parser,
+                  const std::string& new_expected_codecs);
+
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
@@ -145,16 +151,30 @@ class MEDIA_EXPORT SourceBufferState {
       const SourceBufferParseWarningCB& parse_warning_cb);
 
  private:
-  // State advances through this list. The intent is to ensure at least one
-  // config is received prior to parser calling initialization callback, and
-  // that such initialization callback occurs at most once per parser.
+  // State advances through this list to PARSER_INITIALIZED.
+  // The intent is to ensure at least one config is received prior to parser
+  // calling initialization callback, and that such initialization callback
+  // occurs at most once per parser.
+  // PENDING_PARSER_RECONFIG occurs if State had reached PARSER_INITIALIZED
+  // before changing to a new StreamParser in ChangeType(). In such case, State
+  // would then advance to PENDING_PARSER_REINIT, then PARSER_INITIALIZED upon
+  // the next initialization segment parsed, but would not run the
+  // initialization callback in this case (since such would already have
+  // occurred on the initial transition from PENDING_PARSER_INIT to
+  // PARSER_INITIALIZED.)
   enum State {
     UNINITIALIZED = 0,
     PENDING_PARSER_CONFIG,
     PENDING_PARSER_INIT,
-    PARSER_INITIALIZED
+    PARSER_INITIALIZED,
+    PENDING_PARSER_RECONFIG,
+    PENDING_PARSER_REINIT
   };
 
+  // Initializes |stream_parser_|. Also, updates |expected_audio_codecs| and
+  // |expected_video_codecs|.
+  void InitializeParser(const std::string& expected_codecs);
+
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occurred while

media/filters/source_buffer_stream.cc

@@ -1976,13 +1976,21 @@ base::TimeDelta SourceBufferStream<RangeClass>::GetMaxInterbufferDistance()
 
 template <typename RangeClass>
 bool SourceBufferStream<RangeClass>::UpdateAudioConfig(
-    const AudioDecoderConfig& config) {
+    const AudioDecoderConfig& config,
+    bool allow_codec_change) {
   DCHECK(!audio_configs_.empty());
   DCHECK(video_configs_.empty());
   DVLOG(3) << "UpdateAudioConfig.";
 
-  if (audio_configs_[0].codec() != config.codec()) {
-    MEDIA_LOG(ERROR, media_log_) << "Audio codec changes not allowed.";
+  if (!allow_codec_change &&
+      audio_configs_[append_config_index_].codec() != config.codec()) {
+    // TODO(wolenetz): When we relax addSourceBuffer() and changeType() codec
+    // strictness, codec changes should be allowed even without changing the
+    // bytestream.
+    // TODO(wolenetz): Remove "experimental" from this error message when
+    // changeType() ships without needing experimental blink flag.
+    MEDIA_LOG(ERROR, media_log_) << "Audio codec changes not allowed unless "
+                                    "using experimental changeType().";
     return false;
   }
 
@@ -2004,13 +2012,21 @@ bool SourceBufferStream<RangeClass>::UpdateAudioConfig(
 
 template <typename RangeClass>
 bool SourceBufferStream<RangeClass>::UpdateVideoConfig(
-    const VideoDecoderConfig& config) {
+    const VideoDecoderConfig& config,
+    bool allow_codec_change) {
   DCHECK(!video_configs_.empty());
   DCHECK(audio_configs_.empty());
   DVLOG(3) << "UpdateVideoConfig.";
 
-  if (video_configs_[0].codec() != config.codec()) {
-    MEDIA_LOG(ERROR, media_log_) << "Video codec changes not allowed.";
+  if (!allow_codec_change &&
+      video_configs_[append_config_index_].codec() != config.codec()) {
+    // TODO(wolenetz): When we relax addSourceBuffer() and changeType() codec
+    // strictness, codec changes should be allowed even without changing the
+    // bytestream.
+    // TODO(wolenetz): Remove "experimental" from this error message when
+    // changeType() ships without needing experimental blink flag.
+    MEDIA_LOG(ERROR, media_log_) << "Video codec changes not allowed unless "
+                                    "using experimental changeType()";
     return false;
   }
 

media/filters/source_buffer_stream.h

@@ -164,11 +164,17 @@ class MEDIA_EXPORT SourceBufferStream {
 
   // Notifies this object that the audio config has changed and buffers in
   // future Append() calls should be associated with this new config.
-  bool UpdateAudioConfig(const AudioDecoderConfig& config);
+  // If the codec is allowed to change, the caller should set
+  // |allow_codec_change| to true.
+  bool UpdateAudioConfig(const AudioDecoderConfig& config,
+                         bool allow_codec_change);
 
   // Notifies this object that the video config has changed and buffers in
   // future Append() calls should be associated with this new config.
-  bool UpdateVideoConfig(const VideoDecoderConfig& config);
+  // If the codec is allowed to change, the caller should set
+  // |allow_codec_change| to true.
+  bool UpdateVideoConfig(const VideoDecoderConfig& config,
+                         bool allow_codec_change);
 
   // Returns the largest distance between two adjacent buffers in this stream,
   // or an estimate if no two adjacent buffers have been appended to the stream

media/filters/source_buffer_stream_unittest.cc

@@ -3472,7 +3472,7 @@ TEST_P(SourceBufferStreamTest, ConfigChange_Basic) {
   CheckVideoConfig(video_config_);
 
   // Signal a config change.
-  STREAM_OP(UpdateVideoConfig(new_config));
+  STREAM_OP(UpdateVideoConfig(new_config, false));
 
   // Make sure updating the config doesn't change anything since new_config
   // should not be associated with the buffer GetNextBuffer() will return.
@@ -3508,7 +3508,7 @@ TEST_P(SourceBufferStreamTest, ConfigChange_Seek) {
 
   Seek(0);
   NewCodedFrameGroupAppend(0, 5, &kDataA);
-  STREAM_OP(UpdateVideoConfig(new_config));
+  STREAM_OP(UpdateVideoConfig(new_config, false));
   NewCodedFrameGroupAppend(5, 5, &kDataB);
 
   // Seek to the start of the buffers with the new config and make sure a
@@ -4709,7 +4709,7 @@ TEST_P(SourceBufferStreamTest, Audio_ConfigChangeWithPreroll) {
   NewCodedFrameGroupAppend("0K 3K 6K");
 
   // Update the configuration.
-  STREAM_OP(UpdateAudioConfig(new_config));
+  STREAM_OP(UpdateAudioConfig(new_config, false));
 
   // We haven't read any buffers at this point, so the config for the next
   // buffer at time 0 should still be the original config.
@@ -4969,7 +4969,7 @@ TEST_P(SourceBufferStreamTest, ConfigChange_ReSeek) {
   // Append a few buffers, with a config change in the middle.
   VideoDecoderConfig new_config = TestVideoConfig::Large();
   NewCodedFrameGroupAppend("2000K 2010 2020D10");
-  STREAM_OP(UpdateVideoConfig(new_config));
+  STREAM_OP(UpdateVideoConfig(new_config, false));
   NewCodedFrameGroupAppend("2030K 2040 2050D10");
   CheckExpectedRangesByTimestamp("{ [2000,2060) }");