MSE: Protect better against out-of-sequence parser callbacks

media/filters/media_source_state.cc

 // Copyright (c) 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 "media/filters/media_source_state.h"
 
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
@@ skipping 82 matching lines @@
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       parsing_media_segment_(false),
       media_segment_contained_audio_frame_(false),
       media_segment_contained_video_frame_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
       media_log_(media_log),
+      state_(UNINITIALIZED),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 MediaSourceState::~MediaSourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
 
 void MediaSourceState::Init(
     const StreamParser::InitCB& init_cb,
     bool allow_audio,
     bool allow_video,
     const StreamParser::EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewTextTrackCB& new_text_track_cb) {
+  DCHECK_EQ(state_, UNINITIALIZED);
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
+  state_ = PENDING_PARSER_CONFIG;
   stream_parser_->Init(
       base::Bind(&MediaSourceState::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&MediaSourceState::OnNewConfigs, base::Unretained(this),
                  allow_audio, allow_video),
       base::Bind(&MediaSourceState::OnNewBuffers, base::Unretained(this)),
       new_text_track_cb_.is_null(), encrypted_media_init_data_cb,
       base::Bind(&MediaSourceState::OnNewMediaSegment, base::Unretained(this)),
       base::Bind(&MediaSourceState::OnEndOfMediaSegment,
                  base::Unretained(this)),
       media_log_);
@@ skipping 335 matching lines @@
   // in response to ChunkDemuxerStream::Read() calls.
 
   return false;
 }
 
 bool MediaSourceState::OnNewConfigs(
     bool allow_audio,
     bool allow_video,
     scoped_ptr<MediaTracks> tracks,
     const StreamParser::TextTrackConfigMap& text_configs) {
+  DCHECK_GE(state_, PENDING_PARSER_CONFIG);
   DCHECK(tracks.get());
   media_tracks_ = std::move(tracks);
   const AudioDecoderConfig& audio_config = media_tracks_->getFirstAudioConfig();
   const VideoDecoderConfig& video_config = media_tracks_->getFirstVideoConfig();
 
   DVLOG(1) << "OnNewConfigs(" << allow_audio << ", " << allow_video << ", "
            << audio_config.IsValidConfig() << ", "
            << video_config.IsValidConfig() << ")";
   // MSE spec allows new configs to be emitted only during Append, but not
   // during Flush or parser reset operations.
@@ skipping 154 matching lines @@
           break;
         }
       }
     }
   }
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success) {
+    if (state_ == PENDING_PARSER_CONFIG)
+      state_ = PENDING_PARSER_INIT;
     DCHECK(!init_segment_received_cb_.is_null());
     init_segment_received_cb_.Run(std::move(media_tracks_));
   }
 
   return success;
 }
 
 void MediaSourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
+  DCHECK_EQ(state_, PARSER_INITIALIZED);
   parsing_media_segment_ = true;
   media_segment_contained_audio_frame_ = false;
   media_segment_contained_video_frame_ = false;
 }
 
 void MediaSourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
+  DCHECK_EQ(state_, PARSER_INITIALIZED);
   parsing_media_segment_ = false;
 
   const bool missing_audio = audio_ && !media_segment_contained_audio_frame_;
   const bool missing_video = video_ && !media_segment_contained_video_frame_;
   if (!missing_audio && !missing_video)
     return;
 
   LIMITED_MEDIA_LOG(DEBUG, media_log_, num_missing_track_logs_,
                     kMaxMissingTrackInSegmentLogs)
       << "Media segment did not contain any "
       << (missing_audio && missing_video ? "audio or video"
                                          : missing_audio ? "audio" : "video")
       << " coded frames, mismatching initialization segment. Therefore, MSE "
          "coded frame processing may not interoperably detect discontinuities "
          "in appended media.";
 }
 
 bool MediaSourceState::OnNewBuffers(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map) {
   DVLOG(2) << "OnNewBuffers()";
+  DCHECK_EQ(state_, PARSER_INITIALIZED);
   DCHECK(timestamp_offset_during_append_);
   DCHECK(parsing_media_segment_);
 
   media_segment_contained_audio_frame_ |= !audio_buffers.empty();
   media_segment_contained_video_frame_ |= !video_buffers.empty();
 
   const TimeDelta timestamp_offset_before_processing =
       *timestamp_offset_during_append_;
 
   // Calculate the new timestamp offset for audio/video tracks if the stream
@@ skipping 23 matching lines @@
   if (auto_update_timestamp_offset_ &&
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
   return true;
 }
 
 void MediaSourceState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
+  DCHECK_EQ(state_, PENDING_PARSER_INIT);
+  state_ = PARSER_INITIALIZED;
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media