Move DataSourceHost to BufferedDataSourceHost.

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 
 namespace media {
 
 Pipeline::Pipeline(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     MediaLog* media_log)
     : task_runner_(task_runner),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
-      total_bytes_(0),
       volume_(1.0f),
       playback_rate_(0.0f),
       clock_(new Clock(&default_tick_clock_)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
       text_ended_(false),
       audio_disabled_(false),
@@ skipping 101 matching lines @@
   }
 }
 
 TimeDelta Pipeline::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
   return clock_->Elapsed();
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() {
   base::AutoLock auto_lock(lock_);
-  Ranges<TimeDelta> time_ranges;
-  for (size_t i = 0; i < buffered_time_ranges_.size(); ++i) {
-    time_ranges.Add(buffered_time_ranges_.start(i),
-                    buffered_time_ranges_.end(i));
-  }
-  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;
+  return buffered_time_ranges_;
 }
 
 TimeDelta Pipeline::GetMediaDuration() const {
   base::AutoLock auto_lock(lock_);
   return clock_->Duration();
 }
 
-int64 Pipeline::GetTotalBytes() const {
-  base::AutoLock auto_lock(lock_);
-  return total_bytes_;
-}
-
 bool Pipeline::DidLoadingProgress() const {
   base::AutoLock auto_lock(lock_);
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
 
 PipelineStatistics Pipeline::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
@@ skipping 164 matching lines @@
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
   clock_->SetDuration(duration);
   if (!duration_change_cb_.is_null())
     duration_change_cb_.Run();
 }
 
-void Pipeline::SetTotalBytes(int64 total_bytes) {
-  media_log_->AddEvent(
-      media_log_->CreateStringEvent(
-          MediaLogEvent::TOTAL_BYTES_SET, "total_bytes",
-          base::Int64ToString(total_bytes)));
-  int64 total_mbytes = total_bytes >> 20;
-  if (total_mbytes > kint32max)
-    total_mbytes = kint32max;
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Media.TotalMBytes", static_cast<int32>(total_mbytes), 1, kint32max, 50);
-
-  base::AutoLock auto_lock(lock_);
-  total_bytes_ = total_bytes;
-}
-
-TimeDelta Pipeline::TimeForByteOffset_Locked(int64 byte_offset) const {
-  lock_.AssertAcquired();
-  // Use floating point to avoid potential overflow when using 64 bit integers.
-  double time_offset_in_ms = clock_->Duration().InMilliseconds() *
-      (static_cast<double>(byte_offset) / total_bytes_);
-  TimeDelta time_offset(TimeDelta::FromMilliseconds(
-      static_cast<int64>(time_offset_in_ms)));
-  // 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::OnStateTransition(PipelineStatus status) {
   // Force post to process state transitions after current execution frame.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StateTransitionTask, base::Unretained(this), status));
 }
 
 void Pipeline::StateTransitionTask(PipelineStatus status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // No-op any state transitions if we're stopping.
@@ skipping 258 matching lines @@
     // NOTE: pipeline may be deleted at this point in time as a result of
     // executing |stop_cb_|.
     return;
   }
   if (!error_cb_.is_null()) {
     DCHECK_NE(status_, PIPELINE_OK);
     base::ResetAndReturn(&error_cb_).Run(status_);
   }
 }
 
-void Pipeline::AddBufferedByteRange(int64 start, int64 end) {
-  base::AutoLock auto_lock(lock_);
-  buffered_byte_ranges_.Add(start, end);
-  did_loading_progress_ = true;
-}
-
 void Pipeline::AddBufferedTimeRange(base::TimeDelta start,
                                     base::TimeDelta end) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
   buffered_time_ranges_.Add(start, end);
   did_loading_progress_ = true;
 }
 
 void Pipeline::OnAudioRendererEnded() {
   // Force post to process ended tasks after current execution frame.
@@ skipping 284 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media