Track buffered byte ranges correctly in media::Pipeline.

Previously, the interaction was:
BufferedDataSource: hey Pipeline, I just read byte X
Pipeline: cool story bro!  I'll just pretend you've read every single byte from 0 to X.

Now the interaction is:
BufferedDataSource: hey Pipeline, I just read bytes X-Y
Pipeline: neato!  I'll just add that range to my list of buffered ranges.

The most noticeable outcome of this change is that seeking in a media format that requires reading a seek index from the end of the file (e.g. WebM w/ CUES at the end) no longer results in an almost-instant claim of having buffered the entire video just because a seek was completed (esp. dramatic when viewing a very large file, such as a multi-hour video).

BUG=103513,127355
TEST=besides unittests, this allows a cleaned-up version of http/tests/media/video-buffered.html to be un-SKIPped!


Review URL: https://chromiumcodereview.appspot.com/10451049

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@139452 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 73 insertions, 109 deletions

diff --git a/media/base/data_source.h b/media/base/data_source.h
index a394a03..7ce965f 100644
--- a/media/base/data_source.h
+++ b/media/base/data_source.h
@@ -18,9 +18,8 @@ class MEDIA_EXPORT DataSourceHost {
   // Set the total size of the media file.
   virtual void SetTotalBytes(int64 total_bytes) = 0;
 
-  // Sets the total number of bytes that are buffered on the client and ready to
-  // be played.
-  virtual void SetBufferedBytes(int64 buffered_bytes) = 0;
+  // Notify the host that byte range [start,end] has been buffered.
+  virtual void AddBufferedByteRange(int64 start, int64 end) = 0;
 
   // Sets the flag to indicate current network activity.
   virtual void SetNetworkActivity(bool is_downloading_data) = 0;
diff --git a/media/base/demuxer.h b/media/base/demuxer.h
index 49aa238..48d0e6a 100644
--- a/media/base/demuxer.h
+++ b/media/base/demuxer.h
@@ -22,9 +22,6 @@ class MEDIA_EXPORT DemuxerHost : public DataSourceHost {
   // Duration may be kInfiniteDuration() if the duration is not known.
   virtual void SetDuration(base::TimeDelta duration) = 0;
 
-  // Sets the byte offset at which the client is requesting the video.
-  virtual void SetCurrentReadPosition(int64 offset) = 0;
-
   // Stops execution of the pipeline due to a fatal error.  Do not call this
   // method with PIPELINE_OK.
   virtual void OnDemuxerError(PipelineStatus error) = 0;
diff --git a/media/base/mock_data_source_host.h b/media/base/mock_data_source_host.h
index 9af893d..a1a2365 100644
--- a/media/base/mock_data_source_host.h
+++ b/media/base/mock_data_source_host.h
@@ -19,7 +19,7 @@ class MockDataSourceHost : public DataSourceHost {
 
   // DataSourceHost implementation.
   MOCK_METHOD1(SetTotalBytes, void(int64 total_bytes));
-  MOCK_METHOD1(SetBufferedBytes, void(int64 buffered_bytes));
+  MOCK_METHOD2(AddBufferedByteRange, void(int64 start, int64 end));
   MOCK_METHOD1(SetNetworkActivity, void(bool network_activity));
 
  private:
diff --git a/media/base/mock_demuxer_host.h b/media/base/mock_demuxer_host.h
index 4c46fa9..cdb5509 100644
--- a/media/base/mock_demuxer_host.h
+++ b/media/base/mock_demuxer_host.h
@@ -19,13 +19,12 @@ class MockDemuxerHost : public DemuxerHost {
 
   // DataSourceHost implementation.
   MOCK_METHOD1(SetTotalBytes, void(int64 total_bytes));
-  MOCK_METHOD1(SetBufferedBytes, void(int64 buffered_bytes));
+  MOCK_METHOD2(AddBufferedByteRange, void(int64 start, int64 end));
   MOCK_METHOD1(SetNetworkActivity, void(bool network_activity));
 
   // DemuxerHost implementation.
   MOCK_METHOD1(OnDemuxerError, void(PipelineStatus error));
   MOCK_METHOD1(SetDuration, void(base::TimeDelta duration));
-  MOCK_METHOD1(SetCurrentReadPosition, void(int64 offset));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerHost);
diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index 607cf8c..4b4fec0 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -24,6 +24,8 @@
 #include "media/base/video_decoder.h"
 #include "media/base/video_renderer.h"
 
+using base::TimeDelta;
+
 namespace media {
 
 PipelineStatusNotification::PipelineStatusNotification()
@@ -73,7 +75,6 @@ Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
-      current_bytes_(0),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   ResetState();
@@ -114,8 +115,7 @@ void Pipeline::Stop(const base::Closure& stop_cb) {
       &Pipeline::StopTask, this, stop_cb));
 }
 
-void Pipeline::Seek(base::TimeDelta time,
-                    const PipelineStatusCB& seek_cb) {
+void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
@@ -190,29 +190,43 @@ void Pipeline::SetVolume(float volume) {
   }
 }
 
-base::TimeDelta Pipeline::GetCurrentTime() const {
+TimeDelta Pipeline::GetCurrentTime() const {
   base::AutoLock auto_lock(lock_);
   return GetCurrentTime_Locked();
 }
 
-base::TimeDelta Pipeline::GetCurrentTime_Locked() const {
+TimeDelta Pipeline::GetCurrentTime_Locked() const {
   lock_.AssertAcquired();
   return clock_->Elapsed();
 }
 
-Ranges<base::TimeDelta> Pipeline::GetBufferedTimeRanges() {
+Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() {
   base::AutoLock auto_lock(lock_);
-  return buffered_time_ranges_;
+  Ranges<TimeDelta> time_ranges;
+  if (clock_->Duration() == TimeDelta() || total_bytes_ == 0)
+    return time_ranges;
+  for (size_t i = 0; i < buffered_byte_ranges_.size(); ++i) {
+    TimeDelta start = TimeForByteOffset_Locked(buffered_byte_ranges_.start(i));
+    TimeDelta end = TimeForByteOffset_Locked(buffered_byte_ranges_.end(i));
+    // Cap approximated buffered time at the length of the video.
+    end = std::min(end, clock_->Duration());
+    time_ranges.Add(start, end);
+  }
+
+  return time_ranges;
 }
 
-base::TimeDelta Pipeline::GetMediaDuration() const {
+TimeDelta Pipeline::GetMediaDuration() const {
   base::AutoLock auto_lock(lock_);
   return clock_->Duration();
 }
 
 int64 Pipeline::GetBufferedBytes() const {
   base::AutoLock auto_lock(lock_);
-  return buffered_bytes_;
+  int64 ret = 0;
+  for (size_t i = 0; i < buffered_byte_ranges_.size(); ++i)
+    ret += buffered_byte_ranges_.end(i) - buffered_byte_ranges_.start(i);
+  return ret;
 }
 
 int64 Pipeline::GetTotalBytes() const {
@@ -235,31 +249,16 @@ void Pipeline::SetClockForTesting(Clock* clock) {
   clock_.reset(clock);
 }
 
-void Pipeline::SetCurrentReadPosition(int64 offset) {
-  base::AutoLock auto_lock(lock_);
-
-  // The current read position should never be ahead of the buffered byte
-  // position but threading issues between BufferedDataSource::DoneRead_Locked()
-  // and BufferedDataSource::NetworkEventCallback() can cause them to be
-  // temporarily out of sync. The easiest fix for this is to cap both
-  // buffered_bytes_ and current_bytes_ to always be legal values in
-  // SetCurrentReadPosition() and in SetBufferedBytes().
-  if (offset > buffered_bytes_)
-    buffered_bytes_ = offset;
-  current_bytes_ = offset;
-}
-
 void Pipeline::ResetState() {
   base::AutoLock auto_lock(lock_);
-  const base::TimeDelta kZero;
+  const TimeDelta kZero;
   running_          = false;
   stop_pending_     = false;
   seek_pending_     = false;
   tearing_down_     = false;
   error_caused_teardown_ = false;
   playback_rate_change_pending_ = false;
-  buffered_bytes_   = 0;
-  buffered_time_ranges_.clear();
+  buffered_byte_ranges_.clear();
   total_bytes_      = 0;
   natural_size_.SetSize(0, 0);
   volume_           = 1.0f;
@@ -378,18 +377,17 @@ void Pipeline::SetError(PipelineStatus error) {
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
-base::TimeDelta Pipeline::GetTime() const {
+TimeDelta Pipeline::GetTime() const {
   DCHECK(IsRunning());
   return GetCurrentTime();
 }
 
-base::TimeDelta Pipeline::GetDuration() const {
+TimeDelta Pipeline::GetDuration() const {
   DCHECK(IsRunning());
   return GetMediaDuration();
 }
 
-void Pipeline::OnAudioTimeUpdate(base::TimeDelta time,
-                                 base::TimeDelta max_time) {
+void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK(time <= max_time);
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
@@ -403,7 +401,7 @@ void Pipeline::OnAudioTimeUpdate(base::TimeDelta time,
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
-void Pipeline::OnVideoTimeUpdate(base::TimeDelta max_time) {
+void Pipeline::OnVideoTimeUpdate(TimeDelta max_time) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
@@ -414,7 +412,7 @@ void Pipeline::OnVideoTimeUpdate(base::TimeDelta max_time) {
   clock_->SetMaxTime(max_time);
 }
 
-void Pipeline::SetDuration(base::TimeDelta duration) {
+void Pipeline::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateTimeEvent(
@@ -423,7 +421,6 @@ void Pipeline::SetDuration(base::TimeDelta duration) {
 
   base::AutoLock auto_lock(lock_);
   clock_->SetDuration(duration);
-  UpdateBufferedTimeRanges_Locked();
 }
 
 void Pipeline::SetTotalBytes(int64 total_bytes) {
@@ -441,29 +438,23 @@ void Pipeline::SetTotalBytes(int64 total_bytes) {
   total_bytes_ = total_bytes;
 }
 
-void Pipeline::SetBufferedBytes(int64 buffered_bytes) {
+TimeDelta Pipeline::TimeForByteOffset_Locked(int64 byte_offset) const {
+  lock_.AssertAcquired();
+  TimeDelta time_offset = byte_offset * clock_->Duration() / total_bytes_;
+  // Since the byte->time calculation is approximate, fudge the beginning &
+  // ending areas to look better.
+  TimeDelta epsilon = clock_->Duration() / 100;
+  if (time_offset < epsilon)
+    return TimeDelta();
+  if (time_offset + epsilon > clock_->Duration())
+    return clock_->Duration();
+  return time_offset;
+}
+
+void Pipeline::AddBufferedByteRange(int64 start, int64 end) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
-  // See comments in SetCurrentReadPosition() about capping.
-  if (buffered_bytes < current_bytes_)
-    current_bytes_ = buffered_bytes;
-  buffered_bytes_ = buffered_bytes;
-  UpdateBufferedTimeRanges_Locked();
-}
-
-void Pipeline::UpdateBufferedTimeRanges_Locked() {
-  lock_.AssertAcquired();
-  if (total_bytes_ == 0)
-    return;
-  base::TimeDelta buffered_time =
-      clock_->Duration() * buffered_bytes_ / total_bytes_;
-  // Cap approximated buffered time at the length of the video.
-  buffered_time = std::min(buffered_time, clock_->Duration());
-  // Make sure buffered_time is at least the current time and at least the
-  // current seek target.
-  buffered_time = std::max(buffered_time, GetCurrentTime_Locked());
-  buffered_time = std::max(buffered_time, seek_timestamp_);
-  buffered_time_ranges_.Add(seek_timestamp_, buffered_time);
+  buffered_byte_ranges_.Add(start, end);
 }
 
 void Pipeline::SetNaturalVideoSize(const gfx::Size& size) {
@@ -782,8 +773,7 @@ void Pipeline::VolumeChangedTask(float volume) {
     audio_renderer_->SetVolume(volume);
 }
 
-void Pipeline::SeekTask(base::TimeDelta time,
-                        const PipelineStatusCB& seek_cb) {
+void Pipeline::SeekTask(TimeDelta time, const PipelineStatusCB& seek_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!IsPipelineStopPending());
 
@@ -1260,7 +1250,7 @@ void Pipeline::OnDemuxerStopDone(const base::Closure& callback) {
   callback.Run();
 }
 
-void Pipeline::DoSeek(base::TimeDelta seek_timestamp) {
+void Pipeline::DoSeek(TimeDelta seek_timestamp) {
   // TODO(acolwell): We might be able to convert this if (demuxer_) into a
   // DCHECK(). Further investigation is needed to make sure this won't introduce
   // a bug.
@@ -1273,7 +1263,7 @@ void Pipeline::DoSeek(base::TimeDelta seek_timestamp) {
   OnDemuxerSeekDone(seek_timestamp, PIPELINE_OK);
 }
 
-void Pipeline::OnDemuxerSeekDone(base::TimeDelta seek_timestamp,
+void Pipeline::OnDemuxerSeekDone(TimeDelta seek_timestamp,
                                  PipelineStatus status) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index 73359c2..45f59b8 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -219,6 +219,9 @@ class MEDIA_EXPORT Pipeline
 
   // Get the total number of bytes that are buffered on the client and ready to
   // be played.
+  // TODO(fischman): this interface is only needed so WMPI can provide
+  // bytesLoaded() which is only present so that HTMLMediaElement can decide
+  // whether progress has been made.  Bogus!  http://webk.it/86113
   int64 GetBufferedBytes() const;
 
   // Get the total size of the media file.  If the size has not yet been
@@ -299,12 +302,11 @@ class MEDIA_EXPORT Pipeline
 
   // DataSourceHost (by way of DemuxerHost) implementation.
   virtual void SetTotalBytes(int64 total_bytes) OVERRIDE;
-  virtual void SetBufferedBytes(int64 buffered_bytes) OVERRIDE;
+  virtual void AddBufferedByteRange(int64 start, int64 end) OVERRIDE;
   virtual void SetNetworkActivity(bool is_downloading_data) OVERRIDE;
 
   // DemuxerHost implementaion.
   virtual void SetDuration(base::TimeDelta duration) OVERRIDE;
-  virtual void SetCurrentReadPosition(int64 offset) OVERRIDE;
   virtual void OnDemuxerError(PipelineStatus error) OVERRIDE;
 
   // FilterHost implementation.
@@ -423,8 +425,8 @@ class MEDIA_EXPORT Pipeline
   // caller.
   base::TimeDelta GetCurrentTime_Locked() const;
 
-  // Update internal records of which time ranges are buffered.
-  void UpdateBufferedTimeRanges_Locked();
+  // Compute the time corresponding to a byte offset.
+  base::TimeDelta TimeForByteOffset_Locked(int64 byte_offset) const;
 
   // Initiates a Stop() on |demuxer_| & |pipeline_filter_|. |callback|
   // is called once both objects have been stopped.
@@ -476,11 +478,8 @@ class MEDIA_EXPORT Pipeline
   // Whether or not a playback rate change should be done once seeking is done.
   bool playback_rate_change_pending_;
 
-  // Amount of available buffered data.  Set by filters.
-  int64 buffered_bytes_;
-
-  // Approximate time ranges of buffered media.
-  Ranges<base::TimeDelta> buffered_time_ranges_;
+  // Amount of available buffered data.
+  Ranges<int64> buffered_byte_ranges_;
 
   // Total size of the media.  Set by filters.
   int64 total_bytes_;
@@ -534,10 +533,6 @@ class MEDIA_EXPORT Pipeline
   // replies.
   base::TimeDelta seek_timestamp_;
 
-  // For GetCurrentBytes()/SetCurrentBytes() we need to know what byte we are
-  // currently reading.
-  int64 current_bytes_;
-
   // Set to true in DisableAudioRendererTask().
   bool audio_disabled_;
 
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 888b962..6679421 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -477,7 +477,7 @@ TEST_F(PipelineTest, GetBufferedTimeRanges) {
 
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 
-  pipeline_->SetBufferedBytes(kTotalBytes / 8);
+  pipeline_->AddBufferedByteRange(0, kTotalBytes / 8);
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
@@ -486,7 +486,8 @@ TEST_F(PipelineTest, GetBufferedTimeRanges) {
   ExpectSeek(kSeekTime);
   DoSeek(kSeekTime);
 
-  pipeline_->SetBufferedBytes(kTotalBytes / 2 + kTotalBytes / 8);
+  pipeline_->AddBufferedByteRange(kTotalBytes / 2,
+                                  kTotalBytes / 2 + kTotalBytes / 8);
   EXPECT_EQ(2u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
diff --git a/media/filters/chunk_demuxer.cc b/media/filters/chunk_demuxer.cc
index 1ceba74..8ec5161 100644
--- a/media/filters/chunk_demuxer.cc
+++ b/media/filters/chunk_demuxer.cc
@@ -571,8 +571,9 @@ bool ChunkDemuxer::AppendData(const std::string& id,
     buffered_bytes = buffered_bytes_;
   }
 
-  // Notify the host of 'network activity' because we got data.
-  host_->SetBufferedBytes(buffered_bytes);
+  // Notify the host of 'network activity' because we got data, using a bogus
+  // range.
+  host_->AddBufferedByteRange(0, buffered_bytes);
 
   host_->SetNetworkActivity(true);
 
@@ -715,7 +716,6 @@ void ChunkDemuxer::OnSourceBufferInitDone(bool success,
 
   duration_ = duration;
   host_->SetDuration(duration_);
-  host_->SetCurrentReadPosition(0);
 
   ChangeState_Locked(INITIALIZED);
   PipelineStatusCB cb;
diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc
index ae59363..aafaf28 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -184,9 +184,8 @@ class ChunkDemuxerTest : public testing::Test {
 
   bool AppendData(const uint8* data, size_t length) {
     CHECK(length);
-    EXPECT_CALL(host_, SetBufferedBytes(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(SaveArg<0>(&buffered_bytes_));
+    EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber())
+        .WillRepeatedly(SaveArg<1>(&buffered_bytes_));
     EXPECT_CALL(host_, SetNetworkActivity(true))
         .Times(AnyNumber());
     return demuxer_->AppendData(kSourceId, data, length);
@@ -228,10 +227,8 @@ class ChunkDemuxerTest : public testing::Test {
 
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
-    if (expected_status == PIPELINE_OK) {
+    if (expected_status == PIPELINE_OK)
       EXPECT_CALL(host_, SetDuration(expected_duration));
-      EXPECT_CALL(host_, SetCurrentReadPosition(_));
-    }
 
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 94032d1..3d7a5fe 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -398,7 +398,6 @@ size_t FFmpegDemuxer::Read(size_t size, uint8* data) {
     return AVERROR(EIO);
   }
   read_position_ += last_read_bytes;
-  host_->SetCurrentReadPosition(read_position_);
 
   return last_read_bytes;
 }
diff --git a/media/filters/ffmpeg_demuxer_unittest.cc b/media/filters/ffmpeg_demuxer_unittest.cc
index 2c223cf..292bb2f 100644
--- a/media/filters/ffmpeg_demuxer_unittest.cc
+++ b/media/filters/ffmpeg_demuxer_unittest.cc
@@ -65,9 +65,7 @@ class FFmpegDemuxerTest : public testing::Test {
     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_);
@@ -125,8 +123,6 @@ class FFmpegDemuxerTest : public testing::Test {
   StrictMock<MockDemuxerHost> host_;
   MessageLoop message_loop_;
 
-  int64 current_read_position_;
-
   AVFormatContext* format_context() {
     return demuxer_->format_context_;
   }
@@ -182,7 +178,6 @@ class FFmpegDemuxerTest : public testing::Test {
 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));
 
@@ -202,7 +197,6 @@ TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
 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();
@@ -592,13 +586,11 @@ TEST_F(FFmpegDemuxerTest, ProtocolRead) {
   // 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);
 
@@ -607,17 +599,14 @@ TEST_F(FFmpegDemuxerTest, ProtocolRead) {
   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);
 
@@ -651,7 +640,6 @@ TEST_F(FFmpegDemuxerTest, ProtocolGetSetPosition) {
   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));
diff --git a/media/filters/file_data_source.cc b/media/filters/file_data_source.cc
index 8491bfc..d8f14e5 100644
--- a/media/filters/file_data_source.cc
+++ b/media/filters/file_data_source.cc
@@ -110,7 +110,7 @@ FileDataSource::~FileDataSource() {
 void FileDataSource::UpdateHostBytes() {
   if (host() && file_) {
     host()->SetTotalBytes(file_size_);
-    host()->SetBufferedBytes(file_size_);
+    host()->AddBufferedByteRange(0, file_size_);
   }
 }
 
diff --git a/media/filters/file_data_source_unittest.cc b/media/filters/file_data_source_unittest.cc
index c7748ab..e80695b 100644
--- a/media/filters/file_data_source_unittest.cc
+++ b/media/filters/file_data_source_unittest.cc
@@ -53,7 +53,7 @@ std::string TestFileURL() {
 TEST(FileDataSourceTest, OpenFile) {
   StrictMock<MockDataSourceHost> host;
   EXPECT_CALL(host, SetTotalBytes(10));
-  EXPECT_CALL(host, SetBufferedBytes(10));
+  EXPECT_CALL(host, AddBufferedByteRange(0, 10));
 
   scoped_refptr<FileDataSource> filter(new FileDataSource());
   filter->set_host(&host);
diff --git a/media/tools/seek_tester/seek_tester.cc b/media/tools/seek_tester/seek_tester.cc
index b14628c..901c1bd 100644
--- a/media/tools/seek_tester/seek_tester.cc
+++ b/media/tools/seek_tester/seek_tester.cc
@@ -26,12 +26,11 @@ class DemuxerHostImpl : public media::DemuxerHost {
  public:
   // DataSourceHost implementation.
   virtual void SetTotalBytes(int64 total_bytes) OVERRIDE {}
-  virtual void SetBufferedBytes(int64 buffered_bytes) OVERRIDE {}
+  virtual void AddBufferedByteRange(int64 start, int64 end) OVERRIDE {}
   virtual void SetNetworkActivity(bool is_downloading_data) OVERRIDE {}
 
   // DemuxerHost implementation.
   virtual void SetDuration(base::TimeDelta duration) OVERRIDE {}
-  virtual void SetCurrentReadPosition(int64 offset) OVERRIDE {}
   virtual void OnDemuxerError(media::PipelineStatus error) OVERRIDE {}
 };