Ensure media's buffered ranges always have a range that includes currentTime.

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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
@@ skipping 108 matching lines @@
   // Default cluster to append after kDefaultFirstCluster()
   // has been appended. This cluster starts with blocks that
   // have timestamps consistent with the end times of the blocks
   // in kDefaultFirstCluster() so that these two clusters represent
   // a continuous region.
   scoped_ptr<Cluster> kDefaultSecondCluster() {
     return GenerateCluster(46, 66, 5);
   }
 
   ChunkDemuxerTest()
-      : buffered_bytes_(0),
-        client_(new MockChunkDemuxerClient()),
+      : client_(new MockChunkDemuxerClient()),
         demuxer_(new ChunkDemuxer(client_.get())) {
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(bool has_audio, bool has_video,
                          bool video_content_encoded,
                          scoped_array<uint8>* buffer,
@@ skipping 89 matching lines @@
     return demuxer_->AddId(source_id, type, codecs);
   }
 
   bool AppendData(const uint8* data, size_t length) {
     return AppendData(kSourceId, data, length);
   }
 
   bool AppendData(const std::string& source_id,
                   const uint8* data, size_t length) {
     CHECK(length);
-    EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber())
-        .WillRepeatedly(SaveArg<1>(&buffered_bytes_));
+    EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber())
+        .WillRepeatedly(SaveArg<1>(&buffered_time_));
     return demuxer_->AppendData(source_id, data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length) {
     return AppendDataInPieces(data, length, 7);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
     const uint8* end = data + length;
     while (start < end) {
-      int64 old_buffered_bytes = buffered_bytes_;
+      base::TimeDelta old_buffered_time = buffered_time_;
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
 
-      EXPECT_GE(buffered_bytes_, old_buffered_bytes);
+      EXPECT_GE(buffered_time_, old_buffered_time);
     }
     return true;
   }
 
   bool AppendInitSegment(bool has_audio, bool has_video,
                          bool video_content_encoded) {
     return AppendInitSegment(kSourceId, has_audio, has_video,
                              video_content_encoded);
   }
 
@@ skipping 292 matching lines @@
                                &video_read_done));
 
         EXPECT_TRUE(video_read_done);
       }
     }
 
     return true;
   }
 
   MockDemuxerHost host_;
-  int64 buffered_bytes_;
+  base::TimeDelta buffered_time_;
 
   scoped_ptr<MockChunkDemuxerClient> client_;
   scoped_refptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
   // Test no streams, audio-only, video-only, and audio & video scenarios,
@@ skipping 1101 matching lines @@
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(&host_, CreateInitDoneCB(PIPELINE_OK));
   ASSERT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   ASSERT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("audio", "{ }");
   CheckExpectedRanges("video", "{ }");
 }
 
 }  // namespace media