Track buffered byte ranges correctly in media::Pipeline.

webkit/media/buffered_data_source.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 "webkit/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 14 matching lines @@
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     WebFrame* frame,
     media::MediaLog* media_log)
     : total_bytes_(kPositionNotSpecified),
       buffered_bytes_(0),
       streaming_(false),
       frame_(frame),
       loader_(NULL),
       is_downloading_data_(false),
-      read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
+      last_read_start_(0),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       stopped_on_render_loop_(false),
       media_has_played_(false),
       preload_(AUTO),
       cache_miss_retries_left_(kNumCacheMissRetries),
       bitrate_(0),
       playback_rate_(0.0),
@@ skipping 152 matching lines @@
   DCHECK(MessageLoop::current() == render_loop_);
   {
     base::AutoLock auto_lock(lock_);
     if (stopped_on_render_loop_)
       return;
 
     DCHECK(!read_cb_.is_null());
   }
 
   // Saves the read parameters.
-  read_position_ = position;
+  last_read_start_ = position;
   read_size_ = read_size;
   read_buffer_ = buffer;
   cache_miss_retries_left_ = kNumCacheMissRetries;
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::CleanupTask() {
   DCHECK(MessageLoop::current() == render_loop_);
@@ skipping 11 matching lines @@
 
     if (!read_cb_.is_null())
       DoneRead_Locked(kReadError);
   }
 
   // We just need to stop the loader, so it stops activity.
   if (loader_.get())
     loader_->Stop();
 
   // Reset the parameters of the current read request.
-  read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = 0;
 }
 
 void BufferedDataSource::RestartLoadingTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (stopped_on_render_loop_)
     return;
 
   {
     // If there's no outstanding read then return early.
     base::AutoLock auto_lock(lock_);
     if (read_cb_.is_null())
       return;
   }
 
-  loader_.reset(CreateResourceLoader(read_position_, kPositionNotSpecified));
+  loader_.reset(
+      CreateResourceLoader(last_read_start_, kPositionNotSpecified));
   loader_->Start(
       base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
       base::Bind(&BufferedDataSource::NetworkEventCallback, this),
       frame_);
 }
 
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
@@ skipping 36 matching lines @@
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (read_size_ > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[read_size_]);
   }
 
   // Perform the actual read with BufferedResourceLoader.
-  loader_->Read(read_position_, read_size_, intermediate_read_buffer_.get(),
-                base::Bind(&BufferedDataSource::ReadCallback, this));
+  loader_->Read(
+      last_read_start_, read_size_, intermediate_read_buffer_.get(),
+      base::Bind(&BufferedDataSource::ReadCallback, this));
 }
 
 void BufferedDataSource::DoneRead_Locked(int bytes_read) {
   DVLOG(1) << "DoneRead: " << bytes_read << " bytes";
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!read_cb_.is_null());
   DCHECK(bytes_read >= 0 || bytes_read == kReadError);
   lock_.AssertAcquired();
 
   read_cb_.Run(bytes_read);
   read_cb_.Reset();
-  read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = 0;
 }
 
 void BufferedDataSource::DoneInitialization_Locked(
     media::PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!initialize_cb_.is_null());
   lock_.AssertAcquired();
 
@@ skipping 179 matching lines @@
   if (bytes_read > 0) {
     memcpy(read_buffer_, intermediate_read_buffer_.get(), bytes_read);
   } else if (bytes_read == 0 && total_bytes_ == kPositionNotSpecified) {
     // We've reached the end of the file and we didn't know the total size
     // before. Update the total size so Read()s past the end of the file will
     // fail like they would if we had known the file size at the beginning.
     total_bytes_ = loader_->instance_size();
 
     if (host() && total_bytes_ != kPositionNotSpecified) {
       host()->SetTotalBytes(total_bytes_);
-      host()->SetBufferedBytes(total_bytes_);
+      host()->AddBufferedByteRange(last_read_start_, total_bytes_);
     }
   }
   DoneRead_Locked(bytes_read);
 }
 
 void BufferedDataSource::NetworkEventCallback() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // In case of non-HTTP request we don't need to report network events,
   // so return immediately.
   if (!url_.SchemeIs(kHttpScheme) && !url_.SchemeIs(kHttpsScheme))
     return;
 
   bool is_downloading_data = loader_->is_downloading_data();
-  int64 buffered_position = loader_->GetBufferedPosition();
+  int64 current_buffered_position = loader_->GetBufferedPosition();
 
   // If we get an unspecified value, return immediately.
-  if (buffered_position == kPositionNotSpecified)
+  if (current_buffered_position == kPositionNotSpecified)
     return;
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (is_downloading_data != is_downloading_data_) {
     is_downloading_data_ = is_downloading_data;
     if (host())
       host()->SetNetworkActivity(is_downloading_data);
   }
 
-  buffered_bytes_ = buffered_position + 1;
-  if (host())
-    host()->SetBufferedBytes(buffered_bytes_);
+  if (host() && current_buffered_position > last_read_start_)
+    host()->AddBufferedByteRange(last_read_start_, current_buffered_position);
 }
 
 void BufferedDataSource::UpdateHostState_Locked() {
   // Called from various threads, under lock.
   lock_.AssertAcquired();
 
   if (!host())
     return;
 
   if (total_bytes_ != kPositionNotSpecified)
     host()->SetTotalBytes(total_bytes_);
-  host()->SetBufferedBytes(buffered_bytes_);
+  if (buffered_bytes_ > last_read_start_)
+    host()->AddBufferedByteRange(last_read_start_, buffered_bytes_);
 }
 
 }  // namespace webkit_media