Revert of MSE: Relax the 'media segment must begin with keyframe' requirement

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/filters/chunk_demuxer.h"
 #include "media/filters/frame_processor.h"
@@ skipping 72 matching lines @@
   return intersection_ranges;
 }
 
 MediaSourceState::MediaSourceState(
     scoped_ptr<StreamParser> stream_parser,
     scoped_ptr<FrameProcessor> frame_processor,
     const CreateDemuxerStreamCB& create_demuxer_stream_cb,
     const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
+      new_media_segment_(false),
       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),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
@@ skipping 536 matching lines @@
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success)
     init_segment_received_cb_.Run();
 
   return success;
 }
 
 void MediaSourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   parsing_media_segment_ = true;
+  new_media_segment_ = true;
   media_segment_contained_audio_frame_ = false;
   media_segment_contained_video_frame_ = false;
 }
 
 void MediaSourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
   parsing_media_segment_ = false;
+  new_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"
@@ skipping 26 matching lines @@
     if (have_audio_buffers && have_video_buffers) {
       new_timestamp_offset +=
           std::min(EndTimestamp(audio_buffers), EndTimestamp(video_buffers));
     } else if (have_audio_buffers) {
       new_timestamp_offset += EndTimestamp(audio_buffers);
     } else if (have_video_buffers) {
       new_timestamp_offset += EndTimestamp(video_buffers);
     }
   }
 
-  if (!frame_processor_->ProcessFrames(audio_buffers, video_buffers, text_map,
-                                       append_window_start_during_append_,
-                                       append_window_end_during_append_,
-                                       timestamp_offset_during_append_)) {
+  if (!frame_processor_->ProcessFrames(
+          audio_buffers, video_buffers, text_map,
+          append_window_start_during_append_, append_window_end_during_append_,
+          &new_media_segment_, timestamp_offset_during_append_)) {
     return false;
   }
 
   // Only update the timestamp offset if the frame processor hasn't already.
   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) {
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media