Switching decoders to use the injected message loop.

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, nested message loops, etc...
 
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
 #include "media/base/filter_host_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/pipeline_impl.h"
 
 namespace media {
 
 namespace {
 
 // Small helper function to help us transition over to injected message loops.
 //
 // TODO(scherkus): have every filter support injected message loops.
 template <class Filter>
 bool SupportsSetMessageLoop() {
   switch (Filter::filter_type()) {
     case FILTER_DEMUXER:
+    case FILTER_AUDIO_DECODER:
+    case FILTER_VIDEO_DECODER:
       return true;
     default:
       return false;
   }
 }
 
 // Helper function used with NewRunnableMethod to implement a (very) crude
 // blocking counter.
 //
 // TODO(scherkus): remove this as soon as Stop() is made asynchronous.
@@ skipping 413 matching lines @@
     init_complete_callback->Run(pipeline_->initialized_);
     delete init_complete_callback;
   }
 }
 
 // This method is called as a result of the client calling Pipeline::Stop() or
 // as the result of an error condition.  If there is no error, then set the
 // pipeline's error_ member to PIPELINE_STOPPING.  We stop the filters in the
 // reverse order.
 //
-// TODO(scherkus): beware!  this can get posted multiple times!  it shouldn't!
+// TODO(scherkus): beware!  this can get posted multiple times since we post
+// Stop() tasks even if we've already stopped.  Perhaps this should no-op for
+// additional calls, however most of this logic will be changing.
 void PipelineThread::StopTask() {
   if (PipelineOk()) {
     pipeline_->error_ = PIPELINE_STOPPING;
   }
 
   // Stop every filter.
   for (FilterHostVector::iterator iter = filter_hosts_.begin();
        iter != filter_hosts_.end();
        ++iter) {
     (*iter)->Stop();
@@ skipping 158 matching lines @@
   if (!filter) {
     Error(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
   } else {
     DCHECK(!host_initializing_);
     host_initializing_ = new FilterHostImpl(this, filter.get());
     if (NULL == host_initializing_) {
       Error(PIPELINE_ERROR_OUT_OF_MEMORY);
     } else {
       // Create a dedicated thread for this filter.
       if (SupportsSetMessageLoop<Filter>()) {
+        // TODO(scherkus): figure out a way to name these threads so it matches
+        // the filter type.
         scoped_ptr<base::Thread> thread(new base::Thread("FilterThread"));
         if (!thread.get() || !thread->Start()) {
           NOTREACHED() << "Could not start filter thread";
           Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
         } else {
           filter->SetMessageLoop(thread->message_loop());
           filter_threads_.push_back(thread.release());
         }
       }
 
@@ skipping 43 matching lines @@
 
 // Called as a result of destruction of the thread.
 //
 // TODO(scherkus): this can block the client due to synchronous Stop() API call.
 void PipelineThread::WillDestroyCurrentMessageLoop() {
   STLDeleteElements(&filter_hosts_);
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media