Track buffered byte ranges correctly in media::Pipeline.

media/filters/ffmpeg_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 <deque>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 47 matching lines @@
   }
 
   void CreateDemuxer(const std::string& name) {
     CreateDemuxer(name, false);
   }
 
   void CreateDemuxer(const std::string& name, bool disable_file_size) {
     CHECK(!demuxer_);
 
     EXPECT_CALL(host_, SetTotalBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
-    EXPECT_CALL(host_, SetCurrentReadPosition(_))
-        .WillRepeatedly(SaveArg<0>(&current_read_position_));
+    EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber());
 
     CreateDataSource(name, disable_file_size);
     demuxer_ = new FFmpegDemuxer(&message_loop_, data_source_);
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxer() {
     EXPECT_CALL(host_, SetDuration(_));
     demuxer_->Initialize(&host_, NewExpectedStatusCB(PIPELINE_OK));
@@ skipping 37 matching lines @@
     CHECK(stream);
     return static_cast<FFmpegDemuxerStream*>(stream)->stopped_;
   }
 
   // Fixture members.
   scoped_refptr<FileDataSource> data_source_;
   scoped_refptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockDemuxerHost> host_;
   MessageLoop message_loop_;
 
-  int64 current_read_position_;
-
   AVFormatContext* format_context() {
     return demuxer_->format_context_;
   }
 
   void ReadUntilEndOfStream() {
     // We should expect an end of stream buffer.
     scoped_refptr<DemuxerStream> audio =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
 
@@ skipping 35 matching lines @@
     data_source_ = new FileDataSource(disable_file_size);
     EXPECT_EQ(PIPELINE_OK, data_source_->Initialize(file_path.MaybeAsASCII()));
   }
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 };
 
 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
   // Simulate avformat_open_input() failing.
   CreateDemuxer("ten_byte_file"),
-  EXPECT_CALL(host_, SetCurrentReadPosition(_));
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   message_loop_.RunAllPending();
 }
 
 // TODO(acolwell): Uncomment this test when we discover a file that passes
 // avformat_open_input(), but has avformat_find_stream_info() fail.
 //
 //TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
 //  CreateDemuxer("find_stream_info_fail.webm");
 //  demuxer_->Initialize(
 //      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
 //  message_loop_.RunAllPending();
 //}
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Open a file with no streams whatsoever.
   CreateDemuxer("no_streams.webm");
-  EXPECT_CALL(host_, SetCurrentReadPosition(_));
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
   // Open a file containing streams but none of which are audio/video streams.
   CreateDemuxer("no_audio_video.webm");
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
@@ skipping 369 matching lines @@
 
   // Set read head to zero as Initialize() will have parsed a bit of the file.
   int64 position = 0;
   EXPECT_TRUE(demuxer_->SetPosition(0));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(0, position);
 
   // Read 32 bytes from offset zero and verify position.
   uint8 buffer[32];
   EXPECT_EQ(32u, demuxer_->Read(32, buffer));
-  EXPECT_EQ(32, current_read_position_);
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(32, position);
 
   // Read an additional 32 bytes and verify position.
   EXPECT_EQ(32u, demuxer_->Read(32, buffer));
-  EXPECT_EQ(64, current_read_position_);
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(64, position);
 
   // Seek to end and read until EOF.
   int64 size = 0;
   EXPECT_TRUE(demuxer_->GetSize(&size));
   EXPECT_TRUE(demuxer_->SetPosition(size - 48));
   EXPECT_EQ(32u, demuxer_->Read(32, buffer));
-  EXPECT_EQ(size - 16, current_read_position_);
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(size - 16, position);
 
   EXPECT_EQ(16u, demuxer_->Read(32, buffer));
-  EXPECT_EQ(size, current_read_position_);
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(size, position);
 
   EXPECT_EQ(0u, demuxer_->Read(32, buffer));
-  EXPECT_EQ(size, current_read_position_);
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(size, position);
 
   demuxer_->Stop(NewExpectedClosure());
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, GetBitrate_SetInContainer) {
   EXPECT_TRUE(VideoHasValidBitrate("bear.ogv", false));
 }
@@ skipping 13 matching lines @@
 TEST_F(FFmpegDemuxerTest, ProtocolGetSetPosition) {
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   InSequence s;
 
   int64 size;
   int64 position;
   EXPECT_TRUE(demuxer_->GetSize(&size));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
-  EXPECT_EQ(current_read_position_, position);
 
   EXPECT_TRUE(demuxer_->SetPosition(512));
   EXPECT_FALSE(demuxer_->SetPosition(size));
   EXPECT_FALSE(demuxer_->SetPosition(size + 1));
   EXPECT_FALSE(demuxer_->SetPosition(-1));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
   EXPECT_EQ(512, position);
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolGetSize) {
@@ skipping 120 matching lines @@
 TEST_F(FFmpegDemuxerTest, UnsupportedVideoSupportedAudioDemux) {
   CreateDemuxer("vorbis_audio_wmv_video.mkv");
   InitializeDemuxer();
 
   // Ensure the expected streams are present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
   EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
 }
 
 }  // namespace media