MSE: Use frame duration, if available, in LegacyFrameProcessor

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 363 matching lines @@
         block_flags = kWebMFlagKeyframe;
         // Remove the "K" off of the token.
         timestamp_str = timestamp_str.substr(0, timestamps[i].length() - 1);
       }
       int timestamp_in_ms;
       CHECK(base::StringToInt(timestamp_str, &timestamp_in_ms));
 
       if (i == 0)
         cb.SetClusterTimecode(timestamp_in_ms);
 
-      if (track_number == kTextTrackNum) {
-        cb.AddBlockGroup(track_number, timestamp_in_ms, kTextBlockDuration,
-                         block_flags, &data[0], data.size());
-      } else {
-        cb.AddSimpleBlock(track_number, timestamp_in_ms, block_flags,
-                          &data[0], data.size());
+      switch (track_number) {
+        case kVideoTrackNum:
+          AddVideoBlockGroup(&cb, kVideoTrackNum, timestamp_in_ms,
+                             kVideoBlockDuration, block_flags);
+          break;
+        case kAudioTrackNum:
+          cb.AddBlockGroup(kAudioTrackNum, timestamp_in_ms,
+                           kAudioBlockDuration, block_flags, &data[0],
+                           data.size());
+          break;
+        case kTextTrackNum:
+          cb.AddBlockGroup(kTextTrackNum, timestamp_in_ms,
+                           kTextBlockDuration, block_flags, &data[0],
+                           data.size());
+          break;
+        default:
+          DCHECK(false) << "Unknown track number: " << track_number;
       }
     }
     AppendCluster(source_id, cb.Finish());
   }
 
   void AppendData(const std::string& source_id,
                   const uint8* data, size_t length) {
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     // TODO(wolenetz): Test timestamp offset updating once "sequence" append
@@ skipping 149 matching lines @@
   // bear-640x360.webm AudioDecoderConfig returns 3935 for its extra_data_size()
   // The resulting audio stream returns data from each file for the following
   // time ranges.
   // bear-320x240.webm : [0-524)       [779-2737)
   // bear-640x360.webm :       [527-759)
   bool InitDemuxerWithConfigChangeData() {
     scoped_refptr<DecoderBuffer> bear1 = ReadTestDataFile("bear-320x240.webm");
     scoped_refptr<DecoderBuffer> bear2 = ReadTestDataFile("bear-640x360.webm");
 
     EXPECT_CALL(*this, DemuxerOpened());
+
+    // TODO(wolenetz/acolwell): Remove this SetDuration expectation once the
+    // files are fixed to have the correct duration in their init segments.
+    // See http://crbug.com/354284.
+    EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2744)));

[acolwell GONE FROM CHROMIUM, 2014/03/21 15:50:15]

What triggers this? Does this need to be here or can it be moved closer to the
code that triggers it?

[wolenetz, 2014/03/21 18:14:01]

The file has 2744 encoded in its init segment. Parsing the init segment causes
SetDuration(2744) (which needs to be expected). However, the full file append,
along with the usage of parser's frame duration or estimate, causes the duration
to be not just the highest presentation timestamp, but increased to the
HPET+frame duration (==2768 with this change's usage of
SBS::GetBufferedDuration() to estimate the full duration). Bug 354284 tracks
getting the file fixed. Note, fixing that bug and the expectations here will
likely be impacted by change(s) we're working on to get WebM stream parser to
emit at least an estimated frame duration (part of fixing bug 351166), so that
the coded frame processor can use it to directly calculate the duration increase
instead of SBS::GetBufferedDuration().

Done, here and in similar places elsewhere in this file that reference
http://crbug.com/354284.

+
     demuxer_->Initialize(
-        &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
+        &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2768),
                                  PIPELINE_OK), true);
 
     if (AddId(kSourceId, HAS_AUDIO | HAS_VIDEO) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
     AppendData(bear1->data(), bear1->data_size());
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     // Append initialization segment for bear2.
@@ skipping 57 matching lines @@
     if (block_count == 1) {
       cb.AddBlockGroup(kAudioTrackNum, first_audio_timecode,
                        kAudioBlockDuration, kWebMFlagKeyframe,
                        data.get(), size);
       return cb.Finish();
     }
 
     int audio_timecode = first_audio_timecode;
     int video_timecode = first_video_timecode;
 
-    // Create simple blocks for everything except the last 2 blocks.
-    // The first video frame must be a keyframe.
+    // Create block groups for everything to ensure parser can emit durations
+    // for every buffer. The first video frame must be a keyframe.
+    // TODO(acolwell): Also use simple blocks once WebM stream parser can emit
+    // valid frame durations for them. See http://crbug.com/351166.
     uint8 video_flag = kWebMFlagKeyframe;
-    for (int i = 0; i < block_count - 2; i++) {
+    for (int i = 0; i < block_count; i++) {
       if (audio_timecode <= video_timecode) {
-        cb.AddSimpleBlock(kAudioTrackNum, audio_timecode, kWebMFlagKeyframe,
-                          data.get(), size);
+        cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
+                         kWebMFlagKeyframe, data.get(), size);
         audio_timecode += kAudioBlockDuration;
         continue;
       }
 
-      cb.AddSimpleBlock(kVideoTrackNum, video_timecode, video_flag, data.get(),
-                        size);
+      AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
+                         kVideoBlockDuration, video_flag);
       video_timecode += kVideoBlockDuration;
       video_flag = 0;
     }
 
-    // Make the last 2 blocks BlockGroups so that they don't get delayed by the
-    // block duration calculation logic.
-    if (audio_timecode <= video_timecode) {
-      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
-                       kWebMFlagKeyframe, data.get(), size);
-      AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
-                         kVideoBlockDuration, video_flag);
-    } else {
-      AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
-                         kVideoBlockDuration, video_flag);
-      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
-                       kWebMFlagKeyframe, data.get(), size);
-    }
-
     return cb.Finish();
   }
 
   scoped_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
                                                   int end_timecode,
                                                   int track_number,
                                                   int block_duration) {
     CHECK_GT(end_timecode, timecode);
 
     std::vector<uint8> data(kBlockSize);
 
     ClusterBuilder cb;
     cb.SetClusterTimecode(timecode);
 
+    // Create block groups for everything to ensure parser can emit durations
+    // for every buffer. Sets every frame to be a key frame.
+    // TODO(acolwell): Also use simple blocks once WebM stream parser can emit
+    // valid frame durations for them. See http://crbug.com/351166.
+
     // Create simple blocks for everything except the last block.
-    for (int i = 0; timecode < (end_timecode - block_duration); i++) {
-      cb.AddSimpleBlock(track_number, timecode, kWebMFlagKeyframe,
-                        &data[0], data.size());
+    for (int i = 0; timecode < end_timecode; i++) {
+      if (track_number == kVideoTrackNum) {
+        AddVideoBlockGroup(&cb, track_number, timecode, block_duration,
+                           kWebMFlagKeyframe);
+      } else {
+        cb.AddBlockGroup(track_number, timecode, block_duration,
+                         kWebMFlagKeyframe, &data[0], data.size());
+      }
+
       timecode += block_duration;
     }
 
-    // Make the last block a BlockGroup so that it doesn't get delayed by the
-    // block duration calculation logic.
-    if (track_number == kVideoTrackNum) {

[acolwell GONE FROM CHROMIUM, 2014/03/21 15:50:15]

heh.. this is a left over from my previous attempt at making the parser generate
durations.

-      AddVideoBlockGroup(&cb, track_number, timecode, block_duration,
-                         kWebMFlagKeyframe);
-    } else {
-      cb.AddBlockGroup(track_number, timecode, block_duration,
-                       kWebMFlagKeyframe, &data[0], data.size());
-    }
     return cb.Finish();
   }
 
   void Read(DemuxerStream::Type type, const DemuxerStream::ReadCB& read_cb) {
     demuxer_->GetStream(type)->Read(read_cb);
     message_loop_.RunUntilIdle();
   }
 
   void ReadAudio(const DemuxerStream::ReadCB& read_cb) {
     Read(DemuxerStream::AUDIO, read_cb);
@@ skipping 860 matching lines @@
 }
 
 // Verify buffered range change behavior for audio/video/text tracks.
 TEST_F(ChunkDemuxerTest, EndOfStreamRangeChanges) {
   DemuxerStream* text_stream = NULL;
 
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
-  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 30");
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 33");
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, "0K 23K");
 
   // Check expected ranges and verify that an empty text track does not
   // affect the expected ranges.
   CheckExpectedRanges(kSourceId, "{ [0,46) }");
 
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(60)));
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(66)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Check expected ranges and verify that an empty text track does not
   // affect the expected ranges.
-  CheckExpectedRanges(kSourceId, "{ [0,60) }");
+  CheckExpectedRanges(kSourceId, "{ [0,66) }");
 
   // Unmark end of stream state and verify that the ranges return to
   // their pre-"end of stream" values.
   demuxer_->UnmarkEndOfStream();
   CheckExpectedRanges(kSourceId, "{ [0,46) }");
 
   // Add text track data and verify that the buffered ranges don't change
   // since the intersection of all the tracks doesn't change.
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(200)));
   AppendSingleStreamCluster(kSourceId, kTextTrackNum, "0K 100K");
@@ skipping 41 matching lines @@
 TEST_F(ChunkDemuxerTest, WebMFile_AudioAndVideo) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {67, 6},
     {100, 9},
     {133, 12},
     {kSkip, kSkip},
   };
 
+  // TODO(wolenetz/acolwell): Remove this SetDuration expectation once the
+  // file is fixed to have the correct duration in the init segment.
+  // See http://crbug.com/354284.
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2744)));
+
   ASSERT_TRUE(ParseWebMFile("bear-320x240.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2744)));
+                            base::TimeDelta::FromMilliseconds(2768)));
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_LiveAudioAndVideo) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {67, 6},
     {100, 9},
     {133, 12},
     {kSkip, kSkip},
   };
 
   ASSERT_TRUE(ParseWebMFile("bear-320x240-live.webm", buffer_timestamps,
                             kInfiniteDuration()));
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_AudioOnly) {
   struct BufferTimestamps buffer_timestamps[] = {
     {kSkip, 0},
     {kSkip, 3},
     {kSkip, 6},
     {kSkip, 9},
     {kSkip, 12},
     {kSkip, kSkip},
   };
 
+  // TODO(wolenetz/acolwell): Remove this SetDuration expectation once the
+  // file is fixed to have the correct duration in the init segment.
+  // See http://crbug.com/354284.
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2744)));
+
   ASSERT_TRUE(ParseWebMFile("bear-320x240-audio-only.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2744),
+                            base::TimeDelta::FromMilliseconds(2768),
                             HAS_AUDIO));
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_VideoOnly) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, kSkip},
     {33, kSkip},
     {67, kSkip},
     {100, kSkip},
     {133, kSkip},
     {kSkip, kSkip},
   };
 
+  // TODO(wolenetz/acolwell): Remove this SetDuration expectation once the
+  // file is fixed to have the correct duration in the init segment.
+  // See http://crbug.com/354284.
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2703)));
+
   ASSERT_TRUE(ParseWebMFile("bear-320x240-video-only.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2703),
+                            base::TimeDelta::FromMilliseconds(2737),
                             HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_AltRefFrames) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {33, 6},
     {67, 9},
     {100, 12},
     {kSkip, kSkip},
   };
 
+  // TODO(wolenetz/acolwell): Remove this SetDuration expectation once the
+  // file is fixed to have the correct duration in the init segment.
+  // See http://crbug.com/354284.
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
+
   ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2767)));
+                            base::TimeDelta::FromMilliseconds(2768)));
 }
 
 // Verify that we output buffers before the entire cluster has been parsed.
 TEST_F(ChunkDemuxerTest, IncrementalClusterParsing) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   AppendEmptyCluster(0);
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 6));
 
   bool audio_read_done = false;
@@ skipping 993 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   const int kStreamDuration = kDefaultDuration().InMilliseconds();
 
   // Add data leading up to the currently set duration.
   AppendCluster(GenerateCluster(kStreamDuration - kAudioBlockDuration,
                                 kStreamDuration - kVideoBlockDuration,
                                 2));
 
   CheckExpectedRanges(kSourceId, "{ [201191,201224) }");
 
-  // Add data at the currently set duration. The duration should not increase.
+  // Add data beginning at the currently set duration and expect a new duration
+  // to be signaled. Note that the last video block will have a higher end
+  // timestamp than the last audio block.
+  // TODO(wolenetz): Compliant coded frame processor will emit a max of one
+  // duration change per each ProcessFrames(). Remove the first expectation here
+  // once compliant coded frame processor is used. See http://crbug.com/249422.
+  const int kNewStreamDurationAudio = kStreamDuration + kAudioBlockDuration;
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kNewStreamDurationAudio)));
+  const int kNewStreamDurationVideo = kStreamDuration + kVideoBlockDuration;
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kNewStreamDurationVideo)));
   AppendCluster(GenerateCluster(kDefaultDuration().InMilliseconds(), 2));
 
-  // Range should not be affected.
-  CheckExpectedRanges(kSourceId, "{ [201191,201224) }");
+  CheckExpectedRanges(kSourceId, "{ [201191,201247) }");
 
-  // Now add data past the duration and expect a new duration to be signalled.
-  const int kNewStreamDuration = kStreamDuration + kAudioBlockDuration * 2;
+  // Add more data to the end of each media type. Note that the last audio block
+  // will have a higher end timestamp than the last video block.
+  const int kFinalStreamDuration = kStreamDuration + kAudioBlockDuration * 3;
   EXPECT_CALL(host_, SetDuration(
-      base::TimeDelta::FromMilliseconds(kNewStreamDuration)));
+      base::TimeDelta::FromMilliseconds(kFinalStreamDuration)));
   AppendCluster(GenerateCluster(kStreamDuration + kAudioBlockDuration,
                                 kStreamDuration + kVideoBlockDuration,
-                                2));
+                                3));
 
-  // See that the range has increased appropriately.
-  CheckExpectedRanges(kSourceId, "{ [201191,201270) }");
+  // See that the range has increased appropriately (but not to the full
+  // duration of 201293, since there is not enough video appended for that).
+  CheckExpectedRanges(kSourceId, "{ [201191,201290) }");
 }
 
 TEST_F(ChunkDemuxerTest, DurationChangeTimestampOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(SetTimestampOffset(kSourceId, kDefaultDuration()));
 
+  // TODO(wolenetz): Compliant coded frame processor will emit a max of one
+  // duration change per each ProcessFrames(). Remove the first expectation here
+  // once compliant coded frame processor is used. See http://crbug.com/249422.
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kAudioBlockDuration * 2)));
+  EXPECT_CALL(host_, SetDuration(
+      kDefaultDuration() + base::TimeDelta::FromMilliseconds(
+          kVideoBlockDuration * 2)));
   AppendCluster(GenerateCluster(0, 4));
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamTruncateDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(kDefaultFirstCluster());
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp)));
@@ skipping 44 matching lines @@
 
   // Normally this would return an audio buffer at timestamp zero, but
   // all reads should return EOS buffers when disabled.
   bool audio_read_done = false;
   stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done);
 }
 
-// Verifies that signalling end of stream while stalled at a gap
+// Verifies that signaling end of stream while stalled at a gap
 // boundary does not trigger end of stream buffers to be returned.
 TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(0, 10);
   AppendCluster(300, 10);
   CheckExpectedRanges(kSourceId, "{ [0,132) [300,432) }");
 
-
   GenerateExpectedReads(0, 10);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &video_read_done));
 
   // Verify that the reads didn't complete
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(438)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Verify that the reads still haven't completed.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->UnmarkEndOfStream();
 
-  AppendCluster(138, 24);
+  AppendCluster(138, 22);
 
   message_loop_.RunUntilIdle();
 
-  CheckExpectedRanges(kSourceId, "{ [0,438) }");
+  CheckExpectedRanges(kSourceId, "{ [0,435) }");
 
   // Verify that the reads have completed.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Read the rest of the buffers.
-  GenerateExpectedReads(161, 171, 22);
+  GenerateExpectedReads(161, 171, 20);
 
   // Verify that reads block because the append cleared the end of stream state.
   audio_read_done = false;
   video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_EOSExpected,
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_EOSExpected,
                        &video_read_done));
 
   // Verify that the reads don't complete.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(437)));
   MarkEndOfStream(PIPELINE_OK);
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, CanceledSeekDuringInitialPreroll) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Cancel preroll.
@@ skipping 68 matching lines @@
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "0K 30 60 90 120K 150 180 210 240K 270 300 330K");
 
   // Verify that GOPs that start outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
-  // window and extend beyond the end of the window are included.
-  CheckExpectedRanges(kSourceId, "{ [120,300) }");
-  CheckExpectedBuffers(stream, "120 150 180 210 240 270");
+  // window and extend beyond the end of the window are not included.
+  CheckExpectedRanges(kSourceId, "{ [120,273) }");
+  CheckExpectedBuffers(stream, "120 150 180 210 240");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that adding buffers start at the next
   // keyframe.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
-  CheckExpectedRanges(kSourceId, "{ [120,300) [420,660) }");
+  CheckExpectedRanges(kSourceId, "{ [120,273) [420,633) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "0K 30K 60K 90K 120K 150K 180K 210K 240K 270K 300K 330K");
 
   // Verify that frames that start outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
-  // window and extend beyond the end of the window are included.
-  CheckExpectedRanges(kSourceId, "{ [30,300) }");
-  CheckExpectedBuffers(stream, "30 60 90 120 150 180 210 240 270");
+  // window and extend beyond the end of the window are not included.

[acolwell GONE FROM CHROMIUM, 2014/03/21 15:50:15]

Why did this change? Is this an artifact of supporting step 1.10 of the coded
frame processing algorithm?

[wolenetz, 2014/03/21 18:14:01]

Yes. I included that step's support in this change. Previously, only the frame
PTS was compared to append window end. Now, if there is a frame duration, frame
PTS+duration is compared to append window end. And the tests here now always
provide duration.

Window is [20,280]. Audio duration is 23ms. Audio frames appended at 270,300,330
are dropped. Similar occurs for video and text in AppendWindow_Text, below.

+  CheckExpectedRanges(kSourceId, "{ [30,263) }");
+  CheckExpectedBuffers(stream, "30 60 90 120 150 180 210 240");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "360K 390K 420K 450K 480K 510K 540K 570K 600K 630K");
-  CheckExpectedRanges(kSourceId, "{ [30,300) [360,660) }");
+  CheckExpectedRanges(kSourceId, "{ [30,263) [360,623) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO | HAS_TEXT));
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append
   // window.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "0K 30 60 90 120K 150 180 210 240K 270 300 330K");
   AppendSingleStreamCluster(kSourceId, kTextTrackNum, "0K 100K 200K 300K");
 
   // Verify that text cues that start outside the window are not included
   // in the buffer. Also verify that cues that extend beyond the
-  // window are included.
-  CheckExpectedRanges(kSourceId, "{ [120,300) }");
-  CheckExpectedBuffers(video_stream, "120 150 180 210 240 270");
-  CheckExpectedBuffers(text_stream, "100 200");
+  // window are not included.
+  CheckExpectedRanges(kSourceId, "{ [120,273) }");
+  CheckExpectedBuffers(video_stream, "120 150 180 210 240");
+  CheckExpectedBuffers(text_stream, "100");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
   AppendSingleStreamCluster(kSourceId, kTextTrackNum, "400K 500K 600K 700K");
-  CheckExpectedRanges(kSourceId, "{ [120,300) [420,660) }");
+  CheckExpectedRanges(kSourceId, "{ [120,273) [420,633) }");
 
   // Seek to the new range and verify that the expected buffers are returned.
   Seek(base::TimeDelta::FromMilliseconds(420));
-  CheckExpectedBuffers(video_stream, "420 450 480 510 540 570 600 630");
-  CheckExpectedBuffers(text_stream, "400 500 600");
+  CheckExpectedBuffers(video_stream, "420 450 480 510 540 570 600");
+  CheckExpectedBuffers(text_stream, "400 500");
 }
 
 TEST_F(ChunkDemuxerTest, StartWaitingForSeekAfterParseError) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendGarbage();
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(50);
   demuxer_->StartWaitingForSeek(seek_time);
 }
 
@@ skipping 60 matching lines @@
 
   bool text_read_done = false;
   text_stream->Read(base::Bind(&OnReadDone,
                                base::TimeDelta::FromMilliseconds(125),
                                &text_read_done));
 
   // Append audio & video data so the seek completes.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             "0K 20K 40K 60K 80K 100K 120K 140K 160K 180K");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
-                            "0K 30 60 90 120K 150 180 210");
+                            "0K 30 60 90K 120K 150 180 210");
 
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(seek_cb_was_called);
   EXPECT_FALSE(text_read_done);
 
   // Read some audio & video buffers to further verify seek completion.
   CheckExpectedBuffers(audio_stream, "120 140");
   CheckExpectedBuffers(video_stream, "120 150");
 
   EXPECT_FALSE(text_read_done);
 
   // Append text cues that start after the seek point and verify that
   // they are returned by Read() calls.
   AppendSingleStreamCluster(kSourceId, kTextTrackNum, "125K 175K 225K");
 
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(text_read_done);
 
   // NOTE: we start at 175 here because the buffer at 125 was returned
   // to the pending read initiated above.
   CheckExpectedBuffers(text_stream, "175 225");
 
-  // Verify that audio & video streams contiue to return expected values.
+  // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 }  // namespace media