Added checks to GetBufferedTime() to cap at the media's duration

media/base/pipeline_impl.cc

 // Copyright (c) 2010 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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
@@ skipping 203 matching lines @@
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
   AutoLock auto_lock(lock_);
   base::TimeDelta elapsed = clock_.Elapsed();
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
+base::TimeDelta PipelineImpl::GetBufferedTime() {
+  AutoLock auto_lock(lock_);
 
-base::TimeDelta PipelineImpl::GetBufferedTime() {
-  DCHECK(buffered_bytes_ >= current_bytes_);
-  AutoLock auto_lock(lock_);
+  // If media is fully loaded, then return duration.
+  if (loaded_)
+    return duration_;
 
   // If buffered time was set, we report that value directly.
   if (buffered_time_.ToInternalValue() > 0)
     return buffered_time_;
 
   if (total_bytes_ == 0 || current_bytes_ == 0)
     return base::TimeDelta();
 
   // If buffered time was not set, we use current time, current bytes, and
   // buffered bytes to estimate the buffered time.
   double current_time = static_cast<double>(current_bytes_) / total_bytes_ *
                         duration_.InMilliseconds();
   double rate = current_time / current_bytes_;
-  double buffered_time = rate * (buffered_bytes_ - current_bytes_) +
-                         current_time;
+  DCHECK_GE(buffered_bytes_, current_bytes_);
+  base::TimeDelta buffered_time = base::TimeDelta::FromMilliseconds(
+      static_cast<int64>(rate * (buffered_bytes_ - current_bytes_) +
+                         current_time));
+
+  // Cap approximated buffered time at the length of the video.
+  buffered_time = std::min(buffered_time, duration_);
 
   // Only print the max buffered time for smooth buffering.
-  if (buffered_time > max_buffered_time_)
-    max_buffered_time_ = buffered_time;
+  max_buffered_time_ = std::max(buffered_time, max_buffered_time_);
 
-  return base::TimeDelta::FromMilliseconds(
-      static_cast<int64>(max_buffered_time_));
+  return max_buffered_time_;
 }
 
 base::TimeDelta PipelineImpl::GetMediaDuration() const {
   AutoLock auto_lock(lock_);
   return duration_;
 }
 
 int64 PipelineImpl::GetBufferedBytes() const {
   AutoLock auto_lock(lock_);
   return buffered_bytes_;
@@ skipping 760 matching lines @@
     filters_.front()->Stop(NewCallback(
         this, &PipelineImpl::OnFilterStateTransition));
   } else {
     state_ = kStopped;
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media