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

media/filters/frame_processor_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 49 matching lines @@
 // sequence mode (if true), or segments mode (if false).
 class FrameProcessorTest : public testing::TestWithParam<bool> {
  protected:
   FrameProcessorTest()
       : frame_processor_(new FrameProcessor(
             base::Bind(
                 &FrameProcessorTestCallbackHelper::OnPossibleDurationIncrease,
                 base::Unretained(&callbacks_)),
             new MediaLog())),
         append_window_end_(kInfiniteDuration()),
+        new_media_segment_(false),
         audio_id_(FrameProcessor::kAudioTrackId),
         video_id_(FrameProcessor::kVideoTrackId),
         frame_duration_(base::TimeDelta::FromMilliseconds(10)) {}
 
   enum StreamFlags {
     HAS_AUDIO = 1 << 0,
     HAS_VIDEO = 1 << 1
   };
 
   void AddTestTracks(int stream_flags) {
@@ skipping 69 matching lines @@
       buffers.push_back(buffer);
     }
     return buffers;
   }
 
   void ProcessFrames(const std::string& audio_timestamps,
                      const std::string& video_timestamps) {
     ASSERT_TRUE(frame_processor_->ProcessFrames(
         StringToBufferQueue(audio_timestamps, audio_id_, DemuxerStream::AUDIO),
         StringToBufferQueue(video_timestamps, video_id_, DemuxerStream::VIDEO),
-        empty_text_buffers_, append_window_start_, append_window_end_,
-        &timestamp_offset_));
+        empty_text_buffers_,
+        append_window_start_, append_window_end_,
+        &new_media_segment_, &timestamp_offset_));
   }
 
   void CheckExpectedRangesByTimestamp(ChunkDemuxerStream* stream,
                                       const std::string& expected) {
     // Note, DemuxerStream::TEXT streams return [0,duration (==infinity here))
     Ranges<base::TimeDelta> r = stream->GetBufferedRanges(kInfiniteDuration());
 
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
@@ skipping 66 matching lines @@
       if (last_read_buffer_->discard_padding().first == kInfiniteDuration() &&
           last_read_buffer_->discard_padding().second == base::TimeDelta()) {
         ss << "P";
       }
     }
 
     EXPECT_EQ(expected, ss.str());
     CheckReadStalls(stream);
   }
 
-  // TODO(wolenetz): Refactor to instead verify the expected signalling or lack
-  // thereof of new coded frame group by the FrameProcessor. See
-  // https://crbug.com/580613.
-  bool in_coded_frame_group() {
-    return frame_processor_->in_coded_frame_group_;
-  }
-
   base::MessageLoop message_loop_;
   StrictMock<FrameProcessorTestCallbackHelper> callbacks_;
 
   scoped_ptr<FrameProcessor> frame_processor_;
   base::TimeDelta append_window_start_;
   base::TimeDelta append_window_end_;
+  bool new_media_segment_;
   base::TimeDelta timestamp_offset_;
   scoped_ptr<ChunkDemuxerStream> audio_;
   scoped_ptr<ChunkDemuxerStream> video_;
   const TrackId audio_id_;
   const TrackId video_id_;
   const base::TimeDelta frame_duration_;  // Currently the same for all streams.
   const BufferQueue empty_queue_;
   const TextBufferQueueMap empty_text_buffers_;
 
   // StoreStatusAndBuffer's most recent result.
@@ skipping 43 matching lines @@
         ASSERT_FALSE(true);
       }
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(FrameProcessorTest);
 };
 
 TEST_F(FrameProcessorTest, WrongTypeInAppendedBuffer) {
   AddTestTracks(HAS_AUDIO);
-  EXPECT_FALSE(in_coded_frame_group());
+  new_media_segment_ = true;
 
   ASSERT_FALSE(frame_processor_->ProcessFrames(
-      StringToBufferQueue("0K", audio_id_, DemuxerStream::VIDEO), empty_queue_,
-      empty_text_buffers_, append_window_start_, append_window_end_,
-      &timestamp_offset_));
-  EXPECT_FALSE(in_coded_frame_group());
+      StringToBufferQueue("0K", audio_id_, DemuxerStream::VIDEO),
+      empty_queue_,
+      empty_text_buffers_,
+      append_window_start_, append_window_end_,
+      &new_media_segment_, &timestamp_offset_));
+  EXPECT_TRUE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ }");
   CheckReadStalls(audio_.get());
 }
 
 TEST_F(FrameProcessorTest, NonMonotonicallyIncreasingTimestampInOneCall) {
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
 
   ASSERT_FALSE(frame_processor_->ProcessFrames(
       StringToBufferQueue("10K 0K", audio_id_, DemuxerStream::AUDIO),
-      empty_queue_, empty_text_buffers_, append_window_start_,
-      append_window_end_, &timestamp_offset_));
-  EXPECT_FALSE(in_coded_frame_group());
+      empty_queue_,
+      empty_text_buffers_,
+      append_window_start_, append_window_end_,
+      &new_media_segment_, &timestamp_offset_));
+  EXPECT_TRUE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ }");
   CheckReadStalls(audio_.get());
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_SingleFrame) {
   // Tests A: P(A) -> (a)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("0K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,10) }");
   CheckReadsThenReadStalls(audio_.get(), "0");
 }
 
 TEST_P(FrameProcessorTest, VideoOnly_SingleFrame) {
   // Tests V: P(V) -> (v)
   InSequence s;
   AddTestTracks(HAS_VIDEO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("", "0K");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(video_.get(), "{ [0,10) }");
   CheckReadsThenReadStalls(video_.get(), "0");
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_TwoFrames) {
   // Tests A: P(A0, A10) -> (a0, a10)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   ProcessFrames("0K 10K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0 10");
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_SetOffsetThenSingleFrame) {
   // Tests A: STSO(50)+P(A0) -> TSO==50,(a0@50)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   const base::TimeDelta fifty_ms = base::TimeDelta::FromMilliseconds(50);
   SetTimestampOffset(fifty_ms);
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ + fifty_ms));
   ProcessFrames("0K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(fifty_ms, timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [50,60) }");
 
   // We do not stall on reading without seeking to 50ms due to
   // SourceBufferStream::kSeekToStartFudgeRoom().
   CheckReadsThenReadStalls(audio_.get(), "50:0");
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_SetOffsetThenFrameTimestampBelowOffset) {
   // Tests A: STSO(50)+P(A20) ->
   //   if sequence mode: TSO==30,(a20@50)
   //   if segments mode: TSO==50,(a20@70)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   bool using_sequence_mode = GetParam();
   if (using_sequence_mode)
     frame_processor_->SetSequenceMode(true);
 
   const base::TimeDelta fifty_ms = base::TimeDelta::FromMilliseconds(50);
   const base::TimeDelta twenty_ms = base::TimeDelta::FromMilliseconds(20);
   SetTimestampOffset(fifty_ms);
 
   if (using_sequence_mode) {
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(
         fifty_ms + frame_duration_));
   } else {
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(
         fifty_ms + twenty_ms + frame_duration_));
   }
 
   ProcessFrames("20K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
 
   // We do not stall on reading without seeking to 50ms / 70ms due to
   // SourceBufferStream::kSeekToStartFudgeRoom().
   if (using_sequence_mode) {
     EXPECT_EQ(fifty_ms - twenty_ms, timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [50,60) }");
     CheckReadsThenReadStalls(audio_.get(), "50:20");
   } else {
     EXPECT_EQ(fifty_ms, timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [70,80) }");
     CheckReadsThenReadStalls(audio_.get(), "70:20");
   }
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_SequentialProcessFrames) {
   // Tests A: P(A0,A10)+P(A20,A30) -> (a0,a10,a20,a30)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   ProcessFrames("0K 10K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 4));
   ProcessFrames("20K 30K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,40) }");
 
   CheckReadsThenReadStalls(audio_.get(), "0 10 20 30");
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_NonSequentialProcessFrames) {
   // Tests A: P(A20,A30)+P(A0,A10) ->
   //   if sequence mode: TSO==-20 after first P(), 20 after second P(), and
   //                     a(20@0,a30@10,a0@20,a10@30)
   //   if segments mode: TSO==0,(a0,a10,a20,a30)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   bool using_sequence_mode = GetParam();
   if (using_sequence_mode) {
     frame_processor_->SetSequenceMode(true);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   } else {
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 4));
   }
 
   ProcessFrames("20K 30K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
 
   if (using_sequence_mode) {
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
     EXPECT_EQ(frame_duration_ * -2, timestamp_offset_);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 4));
   } else {
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [20,40) }");
     EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   }
 
   ProcessFrames("0K 10K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
 
   if (using_sequence_mode) {
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,40) }");
     EXPECT_EQ(frame_duration_ * 2, timestamp_offset_);
     CheckReadsThenReadStalls(audio_.get(), "0:20 10:30 20:0 30:10");
   } else {
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,40) }");
     EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
     // TODO(wolenetz): Fix this need to seek to 0ms, possibly by having
     // SourceBufferStream defer initial seek until next read. See
     // http://crbug.com/371493.
     audio_->AbortReads();
     audio_->Seek(base::TimeDelta());
     audio_->StartReturningData();
     CheckReadsThenReadStalls(audio_.get(), "0 10 20 30");
   }
 }
 
 TEST_P(FrameProcessorTest, AudioVideo_SequentialProcessFrames) {
   // Tests AV: P(A0,A10;V0k,V10,V20)+P(A20,A30,A40,V30) ->
   //   (a0,a10,a20,a30,a40);(v0,v10,v20,v30)
   InSequence s;
   AddTestTracks(HAS_AUDIO | HAS_VIDEO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 3));
   ProcessFrames("0K 10K", "0K 10 20");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckExpectedRangesByTimestamp(video_.get(), "{ [0,30) }");
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 5));
   ProcessFrames("20K 30K 40K", "30");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,50) }");
   CheckExpectedRangesByTimestamp(video_.get(), "{ [0,40) }");
 
   CheckReadsThenReadStalls(audio_.get(), "0 10 20 30 40");
   CheckReadsThenReadStalls(video_.get(), "0 10 20 30");
 }
 
 TEST_P(FrameProcessorTest, AudioVideo_Discontinuity) {
   // Tests AV: P(A0,A10,A30,A40,A50;V0k,V10,V40,V50key) ->
   //   if sequence mode: TSO==10,(a0,a10,a30,a40,a50@60);(v0,v10,v50@60)
   //   if segments mode: TSO==0,(a0,a10,a30,a40,a50);(v0,v10,v50)
   // This assumes A40K is processed before V40, which depends currently on
   // MergeBufferQueues() behavior.
   InSequence s;
   AddTestTracks(HAS_AUDIO | HAS_VIDEO);
+  new_media_segment_ = true;
   bool using_sequence_mode = GetParam();
   if (using_sequence_mode) {
     frame_processor_->SetSequenceMode(true);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 7));
   } else {
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 6));
   }
 
   ProcessFrames("0K 10K 30K 40K 50K", "0K 10 40 50K");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
 
   if (using_sequence_mode) {
     EXPECT_EQ(frame_duration_, timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,70) }");
     CheckExpectedRangesByTimestamp(video_.get(), "{ [0,70) }");
     CheckReadsThenReadStalls(audio_.get(), "0 10 30 40 60:50");
     CheckReadsThenReadStalls(video_.get(), "0 10 60:50");
   } else {
     EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,60) }");
     CheckExpectedRangesByTimestamp(video_.get(), "{ [0,20) [50,60) }");
     CheckReadsThenReadStalls(audio_.get(), "0 10 30 40 50");
     CheckReadsThenReadStalls(video_.get(), "0 10");
     video_->AbortReads();
     video_->Seek(frame_duration_ * 5);
     video_->StartReturningData();
     CheckReadsThenReadStalls(video_.get(), "50");
   }
 }
 
 TEST_P(FrameProcessorTest,
        AppendWindowFilterOfNegativeBufferTimestampsWithPrerollDiscard) {
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
 
   SetTimestampOffset(frame_duration_ * -2);
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("0K 10K 20K", "");
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   EXPECT_EQ(frame_duration_ * -2, timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,10) }");
   CheckReadsThenReadStalls(audio_.get(), "0:10P 0:20");
 }
 
 TEST_P(FrameProcessorTest, AppendWindowFilterWithInexactPreroll) {
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
   SetTimestampOffset(-frame_duration_);
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   ProcessFrames("0K 9.75K 20K", "");
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0P 0:9.75 10:20");
 }
 
 TEST_P(FrameProcessorTest, AppendWindowFilterWithInexactPreroll_2) {
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
   SetTimestampOffset(-frame_duration_);
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   ProcessFrames("0K 10.25K 20K", "");
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0P 0:10.25 10:20");
 }
 
 TEST_P(FrameProcessorTest, AllowNegativeFramePTSAndDTSBeforeOffsetAdjustment) {
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   bool using_sequence_mode = GetParam();
   if (using_sequence_mode) {
     frame_processor_->SetSequenceMode(true);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 3));
   } else {
     EXPECT_CALL(callbacks_,
                 PossibleDurationIncrease((frame_duration_ * 5) / 2));
   }
 
   ProcessFrames("-5K 5K 15K", "");
 
   if (using_sequence_mode) {
     EXPECT_EQ(frame_duration_ / 2, timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,30) }");
     CheckReadsThenReadStalls(audio_.get(), "0:-5 10:5 20:15");
   } else {
     EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
     CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,25) }");
     CheckReadsThenReadStalls(audio_.get(), "0:-5 5 15");
   }
 }
 
 TEST_P(FrameProcessorTest, PartialAppendWindowFilterNoDiscontinuity) {
   // Tests that spurious discontinuity is not introduced by a partially
   // trimmed frame.
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   if (GetParam())
     frame_processor_->SetSequenceMode(true);
   EXPECT_CALL(callbacks_,
               PossibleDurationIncrease(base::TimeDelta::FromMilliseconds(29)));
 
   append_window_start_ = base::TimeDelta::FromMilliseconds(7);
   ProcessFrames("0K 19K", "");
 
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [7,29) }");
   CheckReadsThenReadStalls(audio_.get(), "7:0 19");
 }
 
 TEST_P(FrameProcessorTest,
        PartialAppendWindowFilterNoDiscontinuity_DtsAfterPts) {
   // Tests that spurious discontinuity is not introduced by a partially trimmed
   // frame that originally had DTS > PTS.
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   bool using_sequence_mode = GetParam();
   if (using_sequence_mode) {
     frame_processor_->SetSequenceMode(true);
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(
                                 base::TimeDelta::FromMilliseconds(20)));
   } else {
     EXPECT_CALL(callbacks_, PossibleDurationIncrease(
                                 base::TimeDelta::FromMilliseconds(13)));
   }
 
@@ skipping 18 matching lines @@
   }
 }
 
 TEST_P(FrameProcessorTest, PartialAppendWindowFilterNoNewMediaSegment) {
   // Tests that a new media segment is not forcibly signalled for audio frame
   // partial front trim, to prevent incorrect introduction of a discontinuity
   // and potentially a non-keyframe video frame to be processed next after the
   // discontinuity.
   InSequence s;
   AddTestTracks(HAS_AUDIO | HAS_VIDEO);
+  new_media_segment_ = true;
   frame_processor_->SetSequenceMode(GetParam());
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("", "0K");
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("-5K", "");
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_* 2));
   ProcessFrames("", "10");
 
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,5) }");
   CheckExpectedRangesByTimestamp(video_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0:-5");
   CheckReadsThenReadStalls(video_.get(), "0 10");
 }
 
 TEST_F(FrameProcessorTest, AudioOnly_SequenceModeContinuityAcrossReset) {
   InSequence s;
   AddTestTracks(HAS_AUDIO);
+  new_media_segment_ = true;
   frame_processor_->SetSequenceMode(true);
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_));
   ProcessFrames("0K", "");
   frame_processor_->Reset();
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 2));
   ProcessFrames("100K", "");
 
   EXPECT_EQ(frame_duration_ * -9, timestamp_offset_);
-  EXPECT_TRUE(in_coded_frame_group());
+  EXPECT_FALSE(new_media_segment_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0 10:100");
 }
 
 INSTANTIATE_TEST_CASE_P(SequenceMode, FrameProcessorTest, Values(true));
 INSTANTIATE_TEST_CASE_P(SegmentsMode, FrameProcessorTest, Values(false));
 
 }  // namespace media