Fire canplaythrough event at the proper time for audio/video

media/base/pipeline_impl.cc

 // Copyright (c) 2011 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 "media/base/pipeline_impl.h"
 
 #include <algorithm>
@@ skipping 168 matching lines @@
   base::AutoLock auto_lock(lock_);
   return has_video_;
 }
 
 float PipelineImpl::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void PipelineImpl::SetPlaybackRate(float playback_rate) {
-  if (playback_rate < 0.0f) {
+  if (playback_rate < 0.0f)
     return;
-  }
 
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
   if (running_ && !tearing_down_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &PipelineImpl::PlaybackRateChangedTask, this, playback_rate));
   }
 }
 
 float PipelineImpl::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
-  if (volume < 0.0f || volume > 1.0f) {
+  if (volume < 0.0f || volume > 1.0f)
     return;
-  }
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_ && !tearing_down_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &PipelineImpl::VolumeChangedTask, this, volume));
   }
 }
 
 Preload PipelineImpl::GetPreload() const {
@@ skipping 12 matching lines @@
 
 base::TimeDelta PipelineImpl::GetCurrentTime() const {
   // TODO(scherkus): perhaps replace checking state_ == kEnded with a bool that
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
   base::AutoLock auto_lock(lock_);
   return GetCurrentTime_Locked();
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime_Locked() const {
+  lock_.AssertAcquired();
   base::TimeDelta elapsed = clock_->Elapsed();
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() {
   base::AutoLock auto_lock(lock_);
 
   // If media is fully loaded, then return duration.
   if (loaded_ || total_bytes_ == buffered_bytes_) {
     max_buffered_time_ = duration_;
     return duration_;
   }
 
   base::TimeDelta current_time = GetCurrentTime_Locked();
 
   // If buffered time was set, we report that value directly.
-  if (buffered_time_.ToInternalValue() > 0) {
+  if (buffered_time_.ToInternalValue() > 0)
     return std::max(buffered_time_, current_time);
-  }
 
   if (total_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 estimated_rate = duration_.InMillisecondsF() / total_bytes_;
   double estimated_current_time = estimated_rate * current_bytes_;
   DCHECK_GE(buffered_bytes_, current_bytes_);
   base::TimeDelta buffered_time = base::TimeDelta::FromMilliseconds(
@@ skipping 90 matching lines @@
   volume_           = 1.0f;
   preload_          = AUTO;
   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_->SetTime(kZero);
+  is_downloading_data_ = false;

[acolwell GONE FROM CHROMIUM, 2011/11/09 00:50:22]

Does download_rate_monitor_ need to be reset here?

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

Yes, done.

 }
 
 void PipelineImpl::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 31 matching lines @@
 }
 
 void PipelineImpl::FinishInitialization() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
   if (!seek_callback_.is_null()) {
     seek_callback_.Run(status_);
     seek_callback_.Reset();
   }
+
+  base::AutoLock auto_lock(lock_);

[acolwell GONE FROM CHROMIUM, 2011/11/09 00:50:22]

This is neaded because the SetXXXBytes() calls are on the Demuxer thread? You
should add a comment indicating why the lock is needed eventhough we are on the
pipeline thread here.

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

Actually the SetXXXBytes method calls (and SetLoaded, and SetNetworkActivity)
originate from BufferedDataSource and so are called on the renderer thread. But
yes, those methods are the reason for the lock.

Though your question leads me to ask: Looking at the code, it appears that the
demuxer runs on the pipeline's thread. Is that not true?
Done.

+  int bitrate = 0;
+  if (demuxer_.get())
+    bitrate = demuxer_->GetBitrate();
+  download_rate_monitor_.Start(
+      base::Bind(&PipelineImpl::OnCanPlayThrough, this), bitrate);
 }
 
 // static
 bool PipelineImpl::TransientState(State state) {
   return state == kPausing ||
          state == kFlushing ||
          state == kSeeking ||
          state == kStarting ||
          state == kStopping;
 }
@@ skipping 82 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_.SetTotalBytes(total_bytes_);
 }
 
 void PipelineImpl::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());
 }
 
 void PipelineImpl::SetNaturalVideoSize(const gfx::Size& size) {
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       size.width(), size.height()));
 
   base::AutoLock auto_lock(lock_);
   natural_size_ = size;
 }
@@ skipping 16 matching lines @@
 }
 
 void PipelineImpl::SetLoaded(bool loaded) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::LOADED_SET, "loaded", loaded));
 
   base::AutoLock auto_lock(lock_);
   loaded_ = loaded;
+  download_rate_monitor_.SetLoaded(loaded_);
 }
 
 void PipelineImpl::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(
-          &PipelineImpl::NotifyNetworkEventTask, this, is_downloading_data));
+          &PipelineImpl::NotifyNetworkEventTask, this, type,
+          is_downloading_data));

[acolwell GONE FROM CHROMIUM, 2011/11/09 00:50:22]

Is is_downloading_data still needed given that it's value is encoded in type? We
have the lock above so we could update is_downloading_data_ here.

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

AH oops, you're right! It served a purpose when the canplaythrough logic was
still in this class. Deleted. 
Actually the lock is for download_rate_monitor_.

   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading_data));
 }
 
 void PipelineImpl::DisableAudioRenderer() {
   DCHECK(IsRunning());
 
   // Disable renderer on the message loop.
@@ skipping 85 matching lines @@
   // If we have received the stop or error signal, return immediately.
   if (IsPipelineStopPending() || IsPipelineStopped() || !IsPipelineOk())
     return;
 
   DCHECK(state_ == kInitDemuxer ||
          state_ == kInitAudioDecoder ||
          state_ == kInitAudioRenderer ||
          state_ == kInitVideoDecoder ||
          state_ == kInitVideoRenderer);
 
-
   // Demuxer created, create audio decoder.
   if (state_ == kInitDemuxer) {
     SetState(kInitAudioDecoder);
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
@@ skipping 237 matching lines @@
     return;
   }
 
   // Transition to ended, executing the callback if present.
   SetState(kEnded);
   if (!ended_callback_.is_null()) {
     ended_callback_.Run(status_);
   }
 }
 
-void PipelineImpl::NotifyNetworkEventTask(bool is_downloading_data) {
+void PipelineImpl::NotifyNetworkEventTask(NetworkEvent type,
+                                          bool is_downloading_data) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  is_downloading_data_ = is_downloading_data;
   if (!network_callback_.is_null())
-    network_callback_.Run(is_downloading_data);
+    network_callback_.Run(type);
 }
 
 void PipelineImpl::DisableAudioRendererTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   base::AutoLock auto_lock(lock_);
   has_audio_ = false;
   audio_disabled_ = true;
 
   // Notify all filters of disabled audio renderer. If the filter isn't
@@ skipping 441 matching lines @@
     return;
   }
 
   if (state_ != kStarted)
     return;
 
   if (audio_renderer_)
     audio_renderer_->ResumeAfterUnderflow(true);
 }
 
+void PipelineImpl::OnCanPlayThrough() {
+  message_loop_->PostTask(FROM_HERE,
+      base::Bind(
+          &PipelineImpl::NotifyCanPlayThrough, this));

[scherkus (not reviewing), 2011/11/09 02:55:15]

nit: can put this on previous line

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

Done.

+}
+
+void PipelineImpl::NotifyCanPlayThrough() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  NotifyNetworkEventTask(CAN_PLAY_THROUGH, is_downloading_data_);
+}
+
 }  // namespace media