More media::PipelineImpl cleanup, this time focusing on not taking down the render process.

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 60 matching lines @@
 
 PipelineImpl::~PipelineImpl() {
   DCHECK(!pipeline_internal_)
       << "Stop() must complete before destroying object";
 }
 
 // Creates the PipelineInternal and calls it's start method.
 bool PipelineImpl::Start(FilterFactory* factory,
                          const std::string& url,
                          PipelineCallback* start_callback) {
-  DCHECK(!pipeline_internal_);
-  DCHECK(factory);
+  DCHECK(!pipeline_internal_) << "PipelineInternal already exists";
+  scoped_ptr<PipelineCallback> callback(start_callback);

[Alpha Left Google, 2009/07/11 02:05:36]

good catch on leak! :)

   if (pipeline_internal_ || !factory) {
     return false;
   }
 
   // Create and start the PipelineInternal.
   pipeline_internal_ = new PipelineInternal(this, message_loop_);
   if (!pipeline_internal_) {
     NOTREACHED() << "Could not create PipelineInternal";
     return false;
   }
-  pipeline_internal_->Start(factory, url, start_callback);
+  pipeline_internal_->Start(factory, url, callback.release());
   return true;
 }
 
 // Stop the PipelineInternal who will NULL our reference to it and reset our
 // state to a newly created PipelineImpl object.
 void PipelineImpl::Stop(PipelineCallback* stop_callback) {
+  scoped_ptr<PipelineCallback> callback(stop_callback);
   if (pipeline_internal_) {
-    pipeline_internal_->Stop(stop_callback);
+    pipeline_internal_->Stop(callback.release());
   }
 }
 
 void PipelineImpl::Seek(base::TimeDelta time,
                         PipelineCallback* seek_callback) {
-  if (IsPipelineOk()) {
-    pipeline_internal_->Seek(time, seek_callback);
-  } else {
-    NOTREACHED();
+  scoped_ptr<PipelineCallback> callback(seek_callback);
+  if (pipeline_internal_) {
+    pipeline_internal_->Seek(time, callback.release());
   }
 }
 
 bool PipelineImpl::IsRunning() const {
-  AutoLock auto_lock(const_cast<Lock&>(lock_));
+  AutoLock auto_lock(lock_);
   return pipeline_internal_ != NULL;
 }
 
 bool PipelineImpl::IsInitialized() const {
   AutoLock auto_lock(lock_);
   return pipeline_internal_ && pipeline_internal_->IsInitialized();
 }
 
 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());
   return is_rendered;
 }
 
 float PipelineImpl::GetPlaybackRate() const {
   AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
-void PipelineImpl::SetPlaybackRate(float rate) {
-  if (IsPipelineOk() && rate >= 0.0f) {
-    pipeline_internal_->SetPlaybackRate(rate);
-  } else {
-    // It's OK for a client to call SetPlaybackRate(0.0f) if we're stopped.
-    DCHECK(rate == 0.0f && playback_rate_ == 0.0f);
+void PipelineImpl::SetPlaybackRate(float playback_rate) {
+  if (playback_rate < 0.0f) {
+    return;
+  }
+
+  AutoLock auto_lock(lock_);
+  playback_rate_ = playback_rate;
+  if (pipeline_internal_) {
+    pipeline_internal_->PlaybackRateChanged(playback_rate);
   }
 }
 
 float PipelineImpl::GetVolume() const {
   AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
-  if (IsPipelineOk() && volume >= 0.0f && volume <= 1.0f) {
-    pipeline_internal_->SetVolume(volume);
-  } else {
-    NOTREACHED();
+  if (volume < 0.0f || volume > 1.0f) {
+    return;
+  }
+
+  AutoLock auto_lock(lock_);
+  volume_ = volume;
+  if (pipeline_internal_) {
+    pipeline_internal_->VolumeChanged(volume);
   }
 }
 
 base::TimeDelta PipelineImpl::GetTime() const {
   AutoLock auto_lock(lock_);
   return time_;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() const {
   AutoLock auto_lock(lock_);
@@ skipping 72 matching lines @@
   AutoLock auto_lock(lock_);
   video_width_ = width;
   video_height_ = height;
 }
 
 void PipelineImpl::SetTime(base::TimeDelta time) {
   AutoLock auto_lock(lock_);
   time_ = time;
 }
 
-void PipelineImpl::InternalSetPlaybackRate(float rate) {
-  AutoLock auto_lock(lock_);
-  playback_rate_ = rate;
-}
-
 bool PipelineImpl::InternalSetError(PipelineError error) {
   // Don't want callers to set an error of "OK".  STOPPING is a special value
   // that should only be used internally by the StopTask() method.
   DCHECK(PIPELINE_OK != error && PIPELINE_STOPPING != error);
   AutoLock auto_lock(lock_);
   bool changed_error = false;
   if (PIPELINE_OK == error_) {
     error_ = error;
     changed_error = true;
   }
@@ skipping 37 matching lines @@
 
 // Called on client's thread.
 void PipelineInternal::Seek(base::TimeDelta time,
                           PipelineCallback* seek_callback) {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineInternal::SeekTask, time,
                         seek_callback));
 }
 
 // Called on client's thread.
-void PipelineInternal::SetPlaybackRate(float rate) {
+void PipelineInternal::PlaybackRateChanged(float playback_rate) {
   message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &PipelineInternal::SetPlaybackRateTask, rate));
+      NewRunnableMethod(this, &PipelineInternal::PlaybackRateChangedTask,
+                        playback_rate));
 }
 
 // Called on client's thread.
-void PipelineInternal::SetVolume(float volume) {
+void PipelineInternal::VolumeChanged(float volume) {
   message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &PipelineInternal::SetVolumeTask, volume));
+      NewRunnableMethod(this, &PipelineInternal::VolumeChangedTask, volume));
 }
 
 // Called from any thread.
 void PipelineInternal::InitializationComplete(FilterHostImpl* host) {
   if (IsPipelineOk()) {
     // Continue the initialize task by proceeding to the next stage.
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineInternal::InitializeTask));
   }
 }
@@ skipping 101 matching lines @@
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || pipeline_->rendered_mime_types_.empty()) {
       Error(PIPELINE_ERROR_COULD_NOT_RENDER);
       return;
     }
 
+    // Initialization was successful, set the volume and playback rate.
+    PlaybackRateChangedTask(pipeline_->GetPlaybackRate());
+    VolumeChangedTask(pipeline_->GetVolume());
+
     state_ = kStarted;
     filter_factory_ = NULL;
     if (start_callback_.get()) {
       start_callback_->Run(true);
       start_callback_.reset();
     }
   }
 }
 
 // This method is called as a result of the client calling Pipeline::Stop() or
@@ skipping 50 matching lines @@
   start_callback_.reset();
   filter_factory_ = NULL;
 
   // We no longer need to examine our previous state, set it to stopped.
   state_ = kError;
 
   // Destroy every filter and reset the pipeline as well.
   DestroyFilters();
 }
 
-void PipelineInternal::SetPlaybackRateTask(float rate) {
+void PipelineInternal::PlaybackRateChangedTask(float playback_rate) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  pipeline_->InternalSetPlaybackRate(rate);
   for (FilterHostVector::iterator iter = filter_hosts_.begin();
        iter != filter_hosts_.end();
        ++iter) {
-    (*iter)->media_filter()->SetPlaybackRate(rate);
+    (*iter)->media_filter()->SetPlaybackRate(playback_rate);
   }
 }
 
+void PipelineInternal::VolumeChangedTask(float volume) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
+  scoped_refptr<AudioRenderer> audio_renderer;
+  GetFilter(&audio_renderer);
+  if (audio_renderer) {
+    audio_renderer->SetVolume(volume);
+  }
+}
+
 void PipelineInternal::SeekTask(base::TimeDelta time,
                                 PipelineCallback* seek_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   seek_callback_.reset(seek_callback);
 
+  // Supress seeking if we haven't fully started.
+  if (state_ != kStarted) {
+    return;
+  }
+
   for (FilterHostVector::iterator iter = filter_hosts_.begin();
        iter != filter_hosts_.end();
        ++iter) {
     (*iter)->media_filter()->Seek(time);
   }
 
   // TODO(hclam): we should set the time when the above seek operations were all
   // successful and first frame/packet at the desired time is decoded. I'm
   // setting the time here because once we do the callback the user can ask for
   // current time immediately, which is the old time. In order to get rid this
   // little glitch, we either assume the seek was successful and time is updated
   // immediately here or we set time and do callback when we have new
   // frames/packets.
   SetTime(time);
   if (seek_callback_.get()) {
     seek_callback_->Run(true);
     seek_callback_.reset();
   }
 }
 
-void PipelineInternal::SetVolumeTask(float volume) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
-
-  pipeline_->volume_ = volume;
-  scoped_refptr<AudioRenderer> audio_renderer;
-  GetFilter(&audio_renderer);
-  if (audio_renderer) {
-    audio_renderer->SetVolume(volume);
-  }
-}
-
 template <class Filter, class Source>
 void PipelineInternal::CreateFilter(FilterFactory* filter_factory,
                                     Source source,
                                     const MediaFormat& media_format) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   // Create the filter.
   scoped_refptr<Filter> filter = filter_factory->Create<Filter>(media_format);
   if (!filter) {
@@ skipping 141 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.
   STLDeleteElements(&filter_hosts_);
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media