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_,
-        &new_media_segment_, &timestamp_offset_));
+        empty_text_buffers_, append_window_start_, append_window_end_,
+        &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);
   }
 
+  bool in_coded_frame_group() {

[chcunningham, 2016/01/22 01:26:37]

Edit:

I that the test I described (and many more) live in chunk demuxer unit tests...
I'm fine with that. 

I still think these tests would be better off using the mocked stream and
checking for the notify call instead of checking this private flag though. 

[chcunningham, 2016/01/22 01:26:38]

I feel like this is testing implementation details rather than the public
interface. Can you instead replace this with checks that the ChunkDemuxerStream
(possibly mocked) receives the notification of a new coded frame group at the
points when it should and not when it shouldn't?

Unless I'm missing it, I think a test thats definitely worth adding would be:

1. Append media segment that doesn't start with a keyframe and has none 
2. verify no notification to ChunkDemuxerStream
3. Append media segment that still doesn't start with KF, but has one in middle
4. verify notification to ChunkDemuxerStrea, but careful to verify the timestamp
notifies matches that of the KF in middle of segment

[wolenetz, 2016/01/22 01:50:03]

SGTM. Good idea (around mocked stream; checking for notify call/lack thereof).
I'll see if such a mock implementation is reasonably workable for inclusion in
this CL (IOW, not too complex for a potential merge-to-m49.) If complex, would
you be ok with a TODO and crbug to follow-up with the recommended rework? (I
think it'll fit within this CL, just getting an idea to how strong you're
feeling about this is.)

[wolenetz, 2016/01/22 01:50:03]

Acknowledged (your edit).

[wolenetz, 2016/01/22 18:59:31]

From my investigation and offline chat w/chcunningham@, it's not a simple mock
method addition since FrameProcessorTests rely on ChunkDemuxerStream to do all
the things like buffering and reading/stalling reads, etc. Rather, probably one
of at least two more complex alternatives would be needed:
1) Determine a (or create a new) subset of FrameProcessorTests that verify
expected new-coded-frame-group calls on a mocked ChunkDemuxerStream, with
limited scope on the mock otherwise (no buffered ranges, reading back of
buffers, etc).
2) Make the ChunkDemuxerStream new-coded-frame-group callback method virtual and
subclass it specifically for these tests.
3) Find some other way to mock/verify the signal.
Note that at least the "media-segmented-ness" is no longer the responsibility at
all of FrameProcessor (solely owned now by StreamParsers and their interaction
with MediaSourceState callbacks, and verified by ChunkDemuxerTests). Only the
"new coded frame group signalling" verification needs some cleanup.

IIUC, chcunningham@ was ok with such verification cleanup in a follow-up CL to
ease the merging of this CL (and since we have mostly equivalent coverage
currently, but on the internal state of FPTest's coded-frame-group flag but not
the signalling thereof.)

I've added a TODO and crbug to clean this up.

[chcunningham, 2016/01/22 19:26:02]

Acknowledged.

+    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);
-  new_media_segment_ = true;
+  EXPECT_FALSE(in_coded_frame_group());
 
   ASSERT_FALSE(frame_processor_->ProcessFrames(
-      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_);
+      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());
   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_,
-      &new_media_segment_, &timestamp_offset_));
-  EXPECT_TRUE(new_media_segment_);
+      empty_queue_, empty_text_buffers_, append_window_start_,
+      append_window_end_, &timestamp_offset_));
+  EXPECT_FALSE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
 
   // 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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
 
   EXPECT_CALL(callbacks_, PossibleDurationIncrease(frame_duration_ * 4));
   ProcessFrames("20K 30K", "");
-  EXPECT_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
 
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
 
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
 
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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_FALSE(new_media_segment_);
+  EXPECT_TRUE(in_coded_frame_group());
   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