Re-land r136486 (reverted in r136500).

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 53 matching lines @@
   scoped_refptr<CompositeFilter> composite;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop->message_loop_proxy()),
       media_log_(media_log),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
       current_bytes_(0),
-      creation_time_(base::Time::Now()),
-      is_downloading_data_(false) {
+      creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   ResetState();
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(!stop_pending_);
@@ skipping 24 matching lines @@
   // Stop the pipeline, which will set |running_| to false on our behalf.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, this, stop_cb));
 }
 
 void Pipeline::Seek(base::TimeDelta time,
                     const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
-  download_rate_monitor_.Stop();
-
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::SeekTask, this, time, seek_cb));
 }
 
 bool Pipeline::IsRunning() const {
   base::AutoLock auto_lock(lock_);
   return running_;
 }
 
 bool Pipeline::IsInitialized() const {
@@ skipping 89 matching lines @@
 }
 
 void Pipeline::GetNaturalVideoSize(gfx::Size* out_size) const {
   CHECK(out_size);
   base::AutoLock auto_lock(lock_);
   *out_size = natural_size_;
 }
 
 bool Pipeline::IsStreaming() const {
   base::AutoLock auto_lock(lock_);
-  return streaming_;
+  return demuxer_ && !demuxer_->IsSeekable();
 }
 
 bool Pipeline::IsLocalSource() const {
   base::AutoLock auto_lock(lock_);
-  return local_source_;
+  return demuxer_ && demuxer_->IsLocalSource();
 }
 
 PipelineStatistics Pipeline::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
 void Pipeline::SetClockForTesting(Clock* clock) {
   clock_.reset(clock);
 }
@@ skipping 16 matching lines @@
   base::AutoLock auto_lock(lock_);
   const base::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();
-  streaming_        = false;
-  local_source_     = false;
   total_bytes_      = 0;
   natural_size_.SetSize(0, 0);
   volume_           = 1.0f;
   playback_rate_    = 0.0f;
   pending_playback_rate_ = 0.0f;
   status_           = PIPELINE_OK;
   has_audio_        = false;
   has_video_        = false;
   waiting_for_clock_update_ = false;
   audio_disabled_   = false;
   clock_->Reset();
-  download_rate_monitor_.Reset();
 }
 
 void Pipeline::SetState(State next_state) {
   if (state_ != kStarted && next_state == kStarted &&
       !creation_time_.is_null()) {
     UMA_HISTOGRAM_TIMES(
         "Media.TimeToPipelineStarted", base::Time::Now() - creation_time_);
     creation_time_ = base::Time();
   }
   state_ = next_state;
@@ skipping 148 matching lines @@
       media_log_->CreateIntegerEvent(
           MediaLogEvent::TOTAL_BYTES_SET, "total_bytes", 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;
-  download_rate_monitor_.set_total_bytes(total_bytes_);
 }
 
 void Pipeline::SetBufferedBytes(int64 buffered_bytes) {
   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;
-  download_rate_monitor_.SetBufferedBytes(buffered_bytes, base::Time::Now());
   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.
@@ skipping 21 matching lines @@
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 }
 
 void Pipeline::SetNetworkActivity(bool is_downloading_data) {
   DCHECK(IsRunning());
 
   NetworkEvent type = DOWNLOAD_PAUSED;
   if (is_downloading_data)
     type = DOWNLOAD_CONTINUED;
 
-  {
-    base::AutoLock auto_lock(lock_);
-    download_rate_monitor_.SetNetworkActivity(is_downloading_data);
-  }
-
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::NotifyNetworkEventTask, this, type));
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading_data));
 }
 
 void Pipeline::DisableAudioRenderer() {
   DCHECK(IsRunning());
@@ skipping 444 matching lines @@
 
     base::AutoLock auto_lock(lock_);
     // We use audio stream to update the clock. So if there is such a stream,
     // we pause the clock until we receive a valid timestamp.
     waiting_for_clock_update_ = true;
     if (!has_audio_) {
       clock_->SetMaxTime(clock_->Duration());
       StartClockIfWaitingForTimeUpdate_Locked();
     }
 
-    // Start monitoring rate of downloading.
-    int bitrate = 0;
-    if (demuxer_) {
-      bitrate = demuxer_->GetBitrate();
-      local_source_ = demuxer_->IsLocalSource();
-      streaming_ = !demuxer_->IsSeekable();
-    }
-    // Needs to be locked because most other calls to |download_rate_monitor_|
-    // occur on the renderer thread.
-    download_rate_monitor_.Start(
-        base::Bind(&Pipeline::OnCanPlayThrough, this),
-        bitrate, streaming_, local_source_);
-    download_rate_monitor_.SetBufferedBytes(buffered_bytes_, base::Time::Now());
-
     if (IsPipelineStopPending()) {
       // We had a pending stop request need to be honored right now.
       TearDownPipeline();
     }
   } else {
     NOTREACHED() << "Unexpected state: " << state_;
   }
 }
 
 void Pipeline::TeardownStateTransitionTask() {
@@ skipping 326 matching lines @@
     return;
   }
 
   if (state_ != kStarted)
     return;
 
   if (audio_renderer_)
     audio_renderer_->ResumeAfterUnderflow(true);
 }
 
-void Pipeline::OnCanPlayThrough() {
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::NotifyCanPlayThrough, this));
-}
-
-void Pipeline::NotifyCanPlayThrough() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-  NotifyNetworkEventTask(CAN_PLAY_THROUGH);
-}
-
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media