Merge 23255 - Implemented endofstream callback for media::PipelineImpl....

media/base/pipeline_impl.cc

 // Copyright (c) 2008-2009 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/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
@@ skipping 131 matching lines @@
 bool PipelineImpl::IsInitialized() const {
   // TODO(scherkus): perhaps replace this with a bool that is set/get under the
   // lock, because this is breaching the contract that |state_| is only accessed
   // on |message_loop_|.
   AutoLock auto_lock(lock_);
   switch (state_) {
     case kPausing:
     case kSeeking:
     case kStarting:
     case kStarted:
+    case kEnded:
       return true;
     default:
       return false;
   }
 }
 
 bool PipelineImpl::IsRendered(const std::string& major_mime_type) const {
   AutoLock auto_lock(lock_);
   bool is_rendered = (rendered_mime_types_.find(major_mime_type) !=
                       rendered_mime_types_.end());
@@ skipping 32 matching lines @@
   AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::VolumeChangedTask,
                           volume));
   }
 }
 
 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_|.
   AutoLock auto_lock(lock_);
   base::TimeDelta elapsed = clock_.Elapsed();
-  if (elapsed > duration_) {
+  if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() const {
   AutoLock auto_lock(lock_);
 
   // If buffered time was set, we report that value directly.
   if (buffered_time_.ToInternalValue() > 0)
@@ skipping 38 matching lines @@
 bool PipelineImpl::IsStreaming() const {
   AutoLock auto_lock(lock_);
   return streaming_;
 }
 
 PipelineError PipelineImpl::GetError() const {
   AutoLock auto_lock(lock_);
   return error_;
 }
 
+void PipelineImpl::SetPipelineEndedCallback(PipelineCallback* ended_callback) {
+  DCHECK(!IsRunning())
+      << "Permanent callbacks should be set before the pipeline has started";
+  ended_callback_.reset(ended_callback);
+}
+
 void PipelineImpl::SetPipelineErrorCallback(PipelineCallback* error_callback) {
+  DCHECK(!IsRunning())
+      << "Permanent callbacks should be set before the pipeline has started";
   error_callback_.reset(error_callback);
 }
 
 void PipelineImpl::ResetState() {
   AutoLock auto_lock(lock_);
   const base::TimeDelta kZero;
   running_          = false;
   duration_         = kZero;
   buffered_time_    = kZero;
   buffered_bytes_   = 0;
@@ skipping 91 matching lines @@
   video_width_ = width;
   video_height_ = height;
 }
 
 void PipelineImpl::SetStreaming(bool streaming) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
   streaming_ = streaming;
 }
 
+void PipelineImpl::NotifyEnded() {
+  DCHECK(IsRunning());
+  message_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &PipelineImpl::NotifyEndedTask));
+}
+
 void PipelineImpl::BroadcastMessage(FilterMessage message) {
   DCHECK(IsRunning());
 
   // Broadcast the message on the message loop.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::BroadcastMessageTask,
                         message));
 }
 
 void PipelineImpl::InsertRenderedMimeType(const std::string& major_mime_type) {
@@ skipping 218 matching lines @@
   if (audio_renderer) {
     audio_renderer->SetVolume(volume);
   }
 }
 
 void PipelineImpl::SeekTask(base::TimeDelta time,
                             PipelineCallback* seek_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Suppress seeking if we're not fully started.
-  if (state_ != kStarted) {
+  if (state_ != kStarted && state_ != kEnded) {
     // TODO(scherkus): should we run the callback?  I'm tempted to say the API
     // will only execute the first Seek() request.
-    LOG(INFO) << "Media pipeline is not in started state, ignoring seek to "
+    LOG(INFO) << "Media pipeline has not started, ignoring seek to "
               << time.InMicroseconds();
     delete seek_callback;
     return;
   }
 
   // We'll need to pause every filter before seeking.  The state transition
   // is as follows:
-  //   kStarted
+  //   kStarted/kEnded
   //   kPausing (for each filter)
   //   kSeeking (for each filter)
   //   kStarting (for each filter)
   //   kStarted
   state_ = kPausing;
   seek_timestamp_ = time;
   seek_callback_.reset(seek_callback);
   remaining_transitions_ = filters_.size();
 
   // Kick off seeking!
   clock_.Pause();
   filters_.front()->Pause(
       NewCallback(this, &PipelineImpl::OnFilterStateTransition));
 }
 
+void PipelineImpl::NotifyEndedTask() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
+  // We can only end if we were actually playing.
+  if (state_ != kStarted) {
+    return;
+  }
+
+  // Grab the renderers, if they exist.
+  scoped_refptr<AudioRenderer> audio_renderer;
+  scoped_refptr<VideoRenderer> video_renderer;
+  GetFilter(&audio_renderer);
+  GetFilter(&video_renderer);
+  DCHECK(audio_renderer || video_renderer);
+
+  // Make sure every extant renderer has ended.
+  if ((audio_renderer && !audio_renderer->HasEnded()) ||
+      (video_renderer && !video_renderer->HasEnded())) {
+    return;
+  }
+
+  // Transition to ended, executing the callback if present.
+  state_ = kEnded;
+  if (ended_callback_.get()) {
+    ended_callback_->Run();
+  }
+}
+
 void PipelineImpl::BroadcastMessageTask(FilterMessage message) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Broadcast the message to all filters.
   for (FilterVector::iterator iter = filters_.begin();
        iter != filters_.end();
        ++iter) {
     (*iter)->OnReceivedMessage(message);
   }
 }
@@ skipping 213 matching lines @@
 
   // Reset the pipeline, which will decrement a reference to this object.
   // We will get destroyed as soon as the remaining tasks finish executing.
   // To be safe, we'll set our pipeline reference to NULL.
   filters_.clear();
   filter_types_.clear();
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media