Use enum instead of string in MessageLoopFactory::GetMessageLoop*

This reinforces that only certain thread/message_loop can be created, which also makes thread/message_loop access easier and more reliable.

Also use scoped_refptr<MessageLoopProxy> instead of raw MessageLoop pointer in various places.

BUG=none
TEST=media_unittest, content_unittest and normal <video> playback.


Review URL: https://chromiumcodereview.appspot.com/10855051

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151204 0039d316-1c4b-4281-b951-d872f2087c98

22 files changed, 145 insertions, 112 deletions

diff --git a/media/base/message_loop_factory.cc b/media/base/message_loop_factory.cc
index 22ec96c..04a904a 100644
--- a/media/base/message_loop_factory.cc
+++ b/media/base/message_loop_factory.cc
@@ -20,27 +20,34 @@ MessageLoopFactory::~MessageLoopFactory() {
   threads_.clear();
 }
 
-MessageLoop* MessageLoopFactory::GetMessageLoop(const std::string& name) {
-  return GetThread(name)->message_loop();
+scoped_refptr<base::MessageLoopProxy> MessageLoopFactory::GetMessageLoop(
+    Type type) {
+  return GetThread(type)->message_loop_proxy();
 }
 
-scoped_refptr<base::MessageLoopProxy>
-MessageLoopFactory::GetMessageLoopProxy(const std::string& name) {
-  return GetThread(name)->message_loop_proxy();
-}
-
-base::Thread* MessageLoopFactory::GetThread(const std::string& name) {
-  DCHECK(!name.empty());
-
+base::Thread* MessageLoopFactory::GetThread(Type type) {
   base::AutoLock auto_lock(lock_);
   for (ThreadList::iterator it = threads_.begin(); it != threads_.end(); ++it) {
-    if (it->first == name)
+    if (it->first == type)
       return it->second;
   }
 
-  base::Thread* thread = new base::Thread(name.c_str());
+  const char* name = NULL;
+  switch (type) {
+    case kAudioDecoder:
+      name = "AudioDecoderThread";
+      break;
+    case kVideoDecoder:
+      name = "VideoDecoderThread";
+      break;
+    case kPipeline:
+      name = "PipelineThread";
+      break;
+  }
+
+  base::Thread* thread = new base::Thread(name);
   CHECK(thread->Start()) << "Failed to start thread: " << name;
-  threads_.push_back(std::make_pair(name, thread));
+  threads_.push_back(std::make_pair(type, thread));
   return thread;
 }
 
diff --git a/media/base/message_loop_factory.h b/media/base/message_loop_factory.h
index f5ecda2..1112b34 100644
--- a/media/base/message_loop_factory.h
+++ b/media/base/message_loop_factory.h
@@ -27,35 +27,32 @@ namespace media {
 // TODO(scherkus): replace this with something simpler http://crbug.com/116873
 class MEDIA_EXPORT MessageLoopFactory {
  public:
-  MessageLoopFactory();
+  enum Type {
+    kAudioDecoder,
+    kVideoDecoder,
+    kPipeline
+  };
 
-  // Get the message loop associated with |name|. A new MessageLoop
-  // is created if the factory doesn't have one associated with |name|.
-  //
-  // |name| must not be an empty string.
-  MessageLoop* GetMessageLoop(const std::string& name);
+  MessageLoopFactory();
 
-  // Get the message loop proxy associated with |name|. A new MessageLoopProxy
-  // is created if the factory doesn't have one associated with |name|.
-  //
-  // |name| must not be an empty string.
-  scoped_refptr<base::MessageLoopProxy> GetMessageLoopProxy(
-      const std::string& name);
+  // Get the message loop proxy associated with |type|. A new MessageLoopProxy
+  // is created if the factory doesn't have one associated with |type|.
+  scoped_refptr<base::MessageLoopProxy> GetMessageLoop(Type type);
 
  private:
   // Only allow scoped_ptr<> to delete factory.
   friend class scoped_ptr<MessageLoopFactory>;
   ~MessageLoopFactory();
 
-  // Returns the thread associated with |name| creating a new thread if needed.
-  base::Thread* GetThread(const std::string& name);
+  // Returns the thread associated with |type| creating a new thread if needed.
+  base::Thread* GetThread(Type type);
 
   // Lock used to serialize access for the following data members.
   base::Lock lock_;
 
-  // List of pairs of created threads and their names.  We use a list to ensure
+  // List of pairs of created threads and their types.  We use a list to ensure
   // threads are stopped & deleted in reverse order of creation.
-  typedef std::list<std::pair<std::string, base::Thread*> > ThreadList;
+  typedef std::list<std::pair<Type, base::Thread*> > ThreadList;
   ThreadList threads_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageLoopFactory);
diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index de94d0b..8559bd1 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -65,8 +65,9 @@ struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder;
 };
 
-Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
-    : message_loop_(message_loop->message_loop_proxy()),
+Pipeline::Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
+                   MediaLog* media_log)
+    : message_loop_(message_loop),
       media_log_(media_log),
       running_(false),
       seek_pending_(false),
@@ -520,8 +521,8 @@ void Pipeline::OnFilterInitialize(PipelineStatus status) {
 // makes it look like a host()->SetError() call followed by a call to
 // OnFilterStateTransition() when errors occur.
 //
-// TODO: Revisit this code when SetError() is removed from FilterHost and
-//       all the Closures are converted to PipelineStatusCB.
+// TODO(scherkus): Revisit this code when SetError() is removed from FilterHost
+// and all the Closures are converted to PipelineStatusCB.
 void Pipeline::OnFilterStateTransition(PipelineStatus status) {
   if (status != PIPELINE_OK)
     SetError(status);
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index 91b6c5e..ecad11c 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -98,7 +98,8 @@ class MEDIA_EXPORT Pipeline
       public DemuxerHost {
  public:
   // Constructs a media pipeline that will execute on |message_loop|.
-  Pipeline(MessageLoop* message_loop, MediaLog* media_log);
+  Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
+           MediaLog* media_log);
 
   // Build a pipeline to using the given filter collection to construct a filter
   // chain, executing |start_cb| when initialization has completed.
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 5b50205..c6d9c35 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -92,7 +92,8 @@ class CallbackHelper {
 class PipelineTest : public ::testing::Test {
  public:
   PipelineTest()
-      : pipeline_(new Pipeline(&message_loop_, new MediaLog())) {
+      : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
+                               new MediaLog())) {
     mocks_.reset(new MockFilterCollection());
 
     // InitializeDemuxer() adds overriding expectations for expected non-NULL
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index 903edba..7a6ee41 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -6,6 +6,8 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
@@ -26,8 +28,8 @@ static inline bool IsEndOfStream(int result, int decoded_size, Buffer* input) {
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
-    const base::Callback<MessageLoop*()>& message_loop_cb)
-    : message_loop_factory_cb_(message_loop_cb),
+    const MessageLoopFactoryCB& message_loop_factory_cb)
+    : message_loop_factory_cb_(message_loop_factory_cb),
       message_loop_(NULL),
       codec_context_(NULL),
       bits_per_channel_(0),
@@ -49,8 +51,7 @@ void FFmpegAudioDecoder::Initialize(
   FFmpegGlue::GetInstance();
 
   if (!message_loop_) {
-    message_loop_ = message_loop_factory_cb_.Run();
-    message_loop_factory_cb_.Reset();
+    message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
   } else {
     // TODO(scherkus): initialization currently happens more than once in
     // PipelineIntegrationTest.BasicPlayback.
@@ -154,7 +155,7 @@ void FFmpegAudioDecoder::DoReset(const base::Closure& closure) {
 }
 
 void FFmpegAudioDecoder::DoRead(const ReadCB& read_cb) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
@@ -165,7 +166,7 @@ void FFmpegAudioDecoder::DoRead(const ReadCB& read_cb) {
 void FFmpegAudioDecoder::DoDecodeBuffer(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& input) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb_.is_null());
 
   if (status != DemuxerStream::kOk) {
diff --git a/media/filters/ffmpeg_audio_decoder.h b/media/filters/ffmpeg_audio_decoder.h
index c63edae..8e67f59 100644
--- a/media/filters/ffmpeg_audio_decoder.h
+++ b/media/filters/ffmpeg_audio_decoder.h
@@ -8,13 +8,16 @@
 #include <list>
 
 #include "base/callback.h"
-#include "base/message_loop.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/demuxer_stream.h"
 
 struct AVCodecContext;
 struct AVFrame;
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 
 class DataBuffer;
@@ -22,7 +25,10 @@ class DecoderBuffer;
 
 class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
  public:
-  FFmpegAudioDecoder(const base::Callback<MessageLoop*()>& message_loop_cb);
+  typedef base::Callback<
+      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
+  explicit FFmpegAudioDecoder(
+      const MessageLoopFactoryCB& message_loop_factory_cb);
 
   // AudioDecoder implementation.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
@@ -58,8 +64,9 @@ class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
   base::TimeDelta GetNextOutputTimestamp() const;
 
   // This is !is_null() iff Initialize() hasn't been called.
-  base::Callback<MessageLoop*()> message_loop_factory_cb_;
-  MessageLoop* message_loop_;
+  MessageLoopFactoryCB message_loop_factory_cb_;
+
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   scoped_refptr<DemuxerStream> demuxer_stream_;
   StatisticsCB statistics_cb_;
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/ffmpeg_audio_decoder_unittest.cc
index ae5b82c..cac6e8a 100644
--- a/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -30,8 +30,9 @@ ACTION_P(InvokeReadPacket, test) {
 class FFmpegAudioDecoderTest : public testing::Test {
  public:
   FFmpegAudioDecoderTest()
-      : decoder_(new FFmpegAudioDecoder(base::Bind(&Identity<MessageLoop*>,
-                                                   &message_loop_))),
+      : decoder_(new FFmpegAudioDecoder(base::Bind(
+            &Identity<scoped_refptr<base::MessageLoopProxy> >,
+            message_loop_.message_loop_proxy()))),
         demuxer_(new StrictMock<MockDemuxerStream>()) {
     CHECK(FFmpegGlue::GetInstance());
 
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 8457520..4bd653f 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -59,7 +59,7 @@ FFmpegDemuxerStream::FFmpegDemuxerStream(
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
@@ -68,7 +68,7 @@ bool FFmpegDemuxerStream::HasPendingReads() {
 
 void FFmpegDemuxerStream::EnqueuePacket(
     scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet) {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   if (stopped_) {
@@ -110,7 +110,7 @@ void FFmpegDemuxerStream::EnqueuePacket(
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(read_queue_.empty()) << "Read requests should be empty";
   buffer_queue_.clear();
@@ -118,7 +118,7 @@ void FFmpegDemuxerStream::FlushBuffers() {
 }
 
 void FFmpegDemuxerStream::Stop() {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   buffer_queue_.clear();
   for (ReadQueue::iterator it = read_queue_.begin();
@@ -168,7 +168,7 @@ void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
 }
 
 void FFmpegDemuxerStream::ReadTask(const ReadCB& read_cb) {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
@@ -191,7 +191,7 @@ void FFmpegDemuxerStream::ReadTask(const ReadCB& read_cb) {
 }
 
 void FFmpegDemuxerStream::FulfillPendingRead() {
-  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
+  DCHECK(demuxer_->message_loop()->BelongsToCurrentThread());
   lock_.AssertAcquired();
   if (buffer_queue_.empty() || read_queue_.empty()) {
     return;
@@ -255,7 +255,7 @@ base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(
-    MessageLoop* message_loop,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const scoped_refptr<DataSource>& data_source)
     : host_(NULL),
       message_loop_(message_loop),
@@ -408,7 +408,7 @@ bool FFmpegDemuxer::IsStreaming() {
   return data_source_->IsStreaming();
 }
 
-MessageLoop* FFmpegDemuxer::message_loop() {
+scoped_refptr<base::MessageLoopProxy> FFmpegDemuxer::message_loop() {
   return message_loop_;
 }
 
@@ -450,7 +450,7 @@ static int CalculateBitrate(
 
 void FFmpegDemuxer::InitializeTask(DemuxerHost* host,
                                    const PipelineStatusCB& status_cb) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   host_ = host;
 
   // TODO(scherkus): DataSource should have a host by this point,
@@ -569,7 +569,7 @@ void FFmpegDemuxer::InitializeTask(DemuxerHost* host,
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time, const PipelineStatusCB& cb) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
@@ -596,7 +596,7 @@ void FFmpegDemuxer::SeekTask(base::TimeDelta time, const PipelineStatusCB& cb) {
 }
 
 void FFmpegDemuxer::DemuxTask() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
@@ -655,7 +655,7 @@ void FFmpegDemuxer::DemuxTask() {
 }
 
 void FFmpegDemuxer::StopTask(const base::Closure& callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter)
@@ -669,7 +669,7 @@ void FFmpegDemuxer::StopTask(const base::Closure& callback) {
 }
 
 void FFmpegDemuxer::DisableAudioStreamTask() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   audio_disabled_ = true;
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
@@ -680,7 +680,7 @@ void FFmpegDemuxer::DisableAudioStreamTask() {
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->HasPendingReads()) {
@@ -691,7 +691,7 @@ bool FFmpegDemuxer::StreamsHavePendingReads() {
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (!*iter ||
@@ -714,7 +714,7 @@ void FFmpegDemuxer::SignalReadCompleted(int size) {
 }
 
 void FFmpegDemuxer::NotifyBufferingChanged() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   Ranges<base::TimeDelta> buffered;
   scoped_refptr<FFmpegDemuxerStream> audio =
       audio_disabled_ ? NULL : GetFFmpegStream(DemuxerStream::AUDIO);
diff --git a/media/filters/ffmpeg_demuxer.h b/media/filters/ffmpeg_demuxer.h
index 43af791..6097c6b 100644
--- a/media/filters/ffmpeg_demuxer.h
+++ b/media/filters/ffmpeg_demuxer.h
@@ -140,7 +140,7 @@ class FFmpegDemuxerStream : public DemuxerStream {
 
 class MEDIA_EXPORT FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
  public:
-  FFmpegDemuxer(MessageLoop* message_loop,
+  FFmpegDemuxer(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                 const scoped_refptr<DataSource>& data_source);
 
   // Posts a task to perform additional demuxing.
@@ -165,7 +165,7 @@ class MEDIA_EXPORT FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
   virtual bool IsStreaming() OVERRIDE;
 
   // Provide access to FFmpegDemuxerStream.
-  MessageLoop* message_loop();
+  scoped_refptr<base::MessageLoopProxy> message_loop();
 
   // Allow FFmpegDemuxerStream to notify us when there is updated information
   // about what buffered data is available.
@@ -218,7 +218,7 @@ class MEDIA_EXPORT FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
 
   DemuxerHost* host_;
 
-  MessageLoop* message_loop_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   // FFmpeg context handle.
   AVFormatContext* format_context_;
diff --git a/media/filters/ffmpeg_demuxer_unittest.cc b/media/filters/ffmpeg_demuxer_unittest.cc
index 64b0c29..fbb11de 100644
--- a/media/filters/ffmpeg_demuxer_unittest.cc
+++ b/media/filters/ffmpeg_demuxer_unittest.cc
@@ -83,7 +83,8 @@ class FFmpegDemuxerTest : public testing::Test {
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     CreateDataSource(name, disable_file_size);
-    demuxer_ = new FFmpegDemuxer(&message_loop_, data_source_);
+    demuxer_ = new FFmpegDemuxer(message_loop_.message_loop_proxy(),
+                                 data_source_);
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index 32aff94..6c9387a 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -10,7 +10,8 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/message_loop.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
@@ -54,9 +55,9 @@ static int GetThreadCount(CodecID codec_id) {
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
-    const base::Callback<MessageLoop*()>& message_loop_cb,
+    const MessageLoopFactoryCB& message_loop_factory_cb,
     Decryptor* decryptor)
-    : message_loop_factory_cb_(message_loop_cb),
+    : message_loop_factory_cb_(message_loop_factory_cb),
       message_loop_(NULL),
       state_(kUninitialized),
       codec_context_(NULL),
@@ -139,16 +140,14 @@ void FFmpegVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
   FFmpegGlue::GetInstance();
 
   if (!message_loop_) {
-    message_loop_ = message_loop_factory_cb_.Run();
-    message_loop_factory_cb_.Reset();
-
+    message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Initialize, this,
         stream, status_cb, statistics_cb));
     return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!demuxer_stream_);
 
   if (!stream) {
@@ -208,7 +207,7 @@ void FFmpegVideoDecoder::Read(const ReadCB& read_cb) {
 }
 
 void FFmpegVideoDecoder::Reset(const base::Closure& closure) {
-  if (MessageLoop::current() != message_loop_) {
+  if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Reset, this, closure));
     return;
@@ -233,7 +232,7 @@ void FFmpegVideoDecoder::DoReset() {
 }
 
 void FFmpegVideoDecoder::Stop(const base::Closure& closure) {
-  if (MessageLoop::current() != message_loop_) {
+  if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Stop, this, closure));
     return;
@@ -262,7 +261,7 @@ FFmpegVideoDecoder::~FFmpegVideoDecoder() {
 }
 
 void FFmpegVideoDecoder::DoRead(const ReadCB& read_cb) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
@@ -304,7 +303,7 @@ void FFmpegVideoDecoder::DecryptOrDecodeBuffer(
 void FFmpegVideoDecoder::DoDecryptOrDecodeBuffer(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(!read_cb_.is_null());
@@ -349,7 +348,7 @@ void FFmpegVideoDecoder::BufferDecrypted(
 void FFmpegVideoDecoder::DoBufferDecrypted(
     Decryptor::Status decrypt_status,
     const scoped_refptr<DecoderBuffer>& buffer) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(!read_cb_.is_null());
@@ -376,7 +375,7 @@ void FFmpegVideoDecoder::DoBufferDecrypted(
 
 void FFmpegVideoDecoder::DecodeBuffer(
     const scoped_refptr<DecoderBuffer>& buffer) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(reset_cb_.is_null());
diff --git a/media/filters/ffmpeg_video_decoder.h b/media/filters/ffmpeg_video_decoder.h
index 493d8e33..a48e3b4 100644
--- a/media/filters/ffmpeg_video_decoder.h
+++ b/media/filters/ffmpeg_video_decoder.h
@@ -11,18 +11,22 @@
 #include "media/base/demuxer_stream.h"
 #include "media/base/video_decoder.h"
 
-class MessageLoop;
-
 struct AVCodecContext;
 struct AVFrame;
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 
 class DecoderBuffer;
 
 class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
  public:
-  FFmpegVideoDecoder(const base::Callback<MessageLoop*()>& message_loop_cb,
+  typedef base::Callback<
+      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
+  FFmpegVideoDecoder(const MessageLoopFactoryCB& message_loop_factory_cb,
                      Decryptor* decryptor);
 
   // VideoDecoder implementation.
@@ -87,9 +91,9 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
   void DoStop();
 
   // This is !is_null() iff Initialize() hasn't been called.
-  base::Callback<MessageLoop*()> message_loop_factory_cb_;
+  MessageLoopFactoryCB message_loop_factory_cb_;
 
-  MessageLoop* message_loop_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   DecoderState state_;
 
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 11c9a08..be32dac 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -77,9 +77,10 @@ class FFmpegVideoDecoderTest : public testing::Test {
                             base::Unretained(this))) {
     CHECK(FFmpegGlue::GetInstance());
 
-    decoder_ = new FFmpegVideoDecoder(base::Bind(&Identity<MessageLoop*>,
-                                                 &message_loop_),
-                                      decryptor_.get());
+    decoder_ = new FFmpegVideoDecoder(
+        base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
+                   message_loop_.message_loop_proxy()),
+        decryptor_.get());
 
     // Initialize various test buffers.
     frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index 5e8231a..3a59a3c 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -44,11 +44,12 @@ GpuVideoDecoder::BufferData::BufferData(
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
-    MessageLoop* message_loop,
-    MessageLoop* vda_loop,
+    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
     const scoped_refptr<Factories>& factories)
-    : gvd_loop_proxy_(message_loop->message_loop_proxy()),
-      vda_loop_proxy_(vda_loop->message_loop_proxy()),
+    : message_loop_factory_cb_(message_loop_factory_cb),
+      gvd_loop_proxy_(NULL),
+      vda_loop_proxy_(vda_loop_proxy),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
@@ -57,7 +58,8 @@ GpuVideoDecoder::GpuVideoDecoder(
       next_bitstream_buffer_id_(0),
       shutting_down_(false),
       error_occured_(false) {
-  DCHECK(gvd_loop_proxy_ && factories_);
+  DCHECK(!message_loop_factory_cb_.is_null());
+  DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
@@ -113,13 +115,15 @@ void GpuVideoDecoder::Stop(const base::Closure& closure) {
 void GpuVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
+  if (!gvd_loop_proxy_) {
+    gvd_loop_proxy_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Initialize,
         this, stream, orig_status_cb, statistics_cb));
     return;
   }
 
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
       "Media.GpuVideoDecoderInitializeStatus", orig_status_cb);
 
diff --git a/media/filters/gpu_video_decoder.h b/media/filters/gpu_video_decoder.h
index df765e6..0a65379 100644
--- a/media/filters/gpu_video_decoder.h
+++ b/media/filters/gpu_video_decoder.h
@@ -56,8 +56,10 @@ class MEDIA_EXPORT GpuVideoDecoder
     virtual ~Factories();
   };
 
-  GpuVideoDecoder(MessageLoop* message_loop,
-                  MessageLoop* vda_loop,
+  typedef base::Callback<
+      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
+  GpuVideoDecoder(const MessageLoopFactoryCB& message_loop_factory_cb,
+                  const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
                   const scoped_refptr<Factories>& factories);
 
   // VideoDecoder implementation.
@@ -149,6 +151,9 @@ class MEDIA_EXPORT GpuVideoDecoder
   // Pointer to the demuxer stream that will feed us compressed buffers.
   scoped_refptr<DemuxerStream> demuxer_stream_;
 
+  // This is !is_null() iff Initialize() hasn't been called.
+  MessageLoopFactoryCB message_loop_factory_cb_;
+
   // MessageLoop on which to fire callbacks and trampoline calls to this class
   // if they arrive on other loops.
   scoped_refptr<base::MessageLoopProxy> gvd_loop_proxy_;
diff --git a/media/filters/pipeline_integration_test_base.cc b/media/filters/pipeline_integration_test_base.cc
index 3e01b57..76152ed 100644
--- a/media/filters/pipeline_integration_test_base.cc
+++ b/media/filters/pipeline_integration_test_base.cc
@@ -22,7 +22,8 @@ const char kNullHash[] = "d41d8cd98f00b204e9800998ecf8427e";
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
       message_loop_factory_(new MessageLoopFactory()),
-      pipeline_(new Pipeline(&message_loop_, new MediaLog())),
+      pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
+                             new MediaLog())),
       ended_(false),
       pipeline_status_(PIPELINE_OK) {
   base::MD5Init(&md5_context_);
@@ -171,8 +172,9 @@ scoped_ptr<FilterCollection>
 PipelineIntegrationTestBase::CreateFilterCollection(const std::string& url) {
   scoped_refptr<FileDataSource> data_source = new FileDataSource();
   CHECK(data_source->Initialize(url));
-  return CreateFilterCollection(new FFmpegDemuxer(&message_loop_, data_source),
-                                NULL);
+  return CreateFilterCollection(
+      new FFmpegDemuxer(message_loop_.message_loop_proxy(), data_source),
+      NULL);
 }
 
 scoped_ptr<FilterCollection>
@@ -191,11 +193,11 @@ PipelineIntegrationTestBase::CreateFilterCollection(
   collection->AddAudioDecoder(new FFmpegAudioDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "AudioDecoderThread")));
+                 media::MessageLoopFactory::kAudioDecoder)));
   scoped_refptr<VideoDecoder> decoder = new FFmpegVideoDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "VideoDecoderThread"),
+                 media::MessageLoopFactory::kVideoDecoder),
       decryptor);
   collection->GetVideoDecoders()->push_back(decoder);
 
diff --git a/media/filters/video_frame_generator.cc b/media/filters/video_frame_generator.cc
index 8c90f2e..4429c19 100644
--- a/media/filters/video_frame_generator.cc
+++ b/media/filters/video_frame_generator.cc
@@ -12,7 +12,7 @@
 namespace media {
 
 VideoFrameGenerator::VideoFrameGenerator(
-    base::MessageLoopProxy* message_loop_proxy,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
     const gfx::Size& size,
     const base::TimeDelta& frame_duration)
     : message_loop_proxy_(message_loop_proxy),
diff --git a/media/filters/video_frame_generator.h b/media/filters/video_frame_generator.h
index 2d32b55..2a4667f 100644
--- a/media/filters/video_frame_generator.h
+++ b/media/filters/video_frame_generator.h
@@ -23,7 +23,7 @@ class VideoFrame;
 class MEDIA_EXPORT VideoFrameGenerator : public VideoDecoder {
  public:
   VideoFrameGenerator(
-      base::MessageLoopProxy* message_loop_proxy,
+      const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
       const gfx::Size& size,
       const base::TimeDelta& frame_duration);
 
diff --git a/media/tools/player_wtl/movie.cc b/media/tools/player_wtl/movie.cc
index 2660b2e..c29f8a0 100644
--- a/media/tools/player_wtl/movie.cc
+++ b/media/tools/player_wtl/movie.cc
@@ -59,8 +59,9 @@ bool Movie::Open(const wchar_t* url, VideoRendererBase* video_renderer) {
 
   message_loop_factory_.reset(new media::MessageLoopFactory());
 
-  MessageLoop* pipeline_loop =
-      message_loop_factory_->GetMessageLoop("PipelineThread");
+  scoped_refptr<base::MessageLoopProxy> pipeline_loop =
+      message_loop_factory_->GetMessageLoop(
+          media::MessageLoopFactory::kPipeline);
   pipeline_ = new Pipeline(pipeline_loop, new media::MediaLog());
 
   // Open the file.
@@ -76,11 +77,11 @@ bool Movie::Open(const wchar_t* url, VideoRendererBase* video_renderer) {
   collection->AddAudioDecoder(new FFmpegAudioDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "AudioDecoderThread")));
+                 media::MessageLoopFactory::kAudioDecoder)));
   collection->GetVideoDecoders()->push_back(new FFmpegVideoDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "VideoDecoderThread"),
+                 media::MessageLoopFactory::kVideoDecoder),
       NULL));
 
   // TODO(vrk): Re-enabled audio. (crbug.com/112159)
diff --git a/media/tools/player_x11/player_x11.cc b/media/tools/player_x11/player_x11.cc
index e224021..8970b18 100644
--- a/media/tools/player_x11/player_x11.cc
+++ b/media/tools/player_x11/player_x11.cc
@@ -98,7 +98,7 @@ void Paint(MessageLoop* message_loop, const PaintCB& paint_cb) {
 }
 
 // TODO(vrk): Re-enabled audio. (crbug.com/112159)
-bool InitPipeline(MessageLoop* message_loop,
+bool InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                   const scoped_refptr<media::DataSource>& data_source,
                   const PaintCB& paint_cb,
                   bool /* enable_audio */,
@@ -118,11 +118,11 @@ bool InitPipeline(MessageLoop* message_loop,
   collection->AddAudioDecoder(new media::FFmpegAudioDecoder(
       base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory),
-                 "AudioDecoderThread")));
+                 media::MessageLoopFactory::kAudioDecoder)));
   collection->GetVideoDecoders()->push_back(new media::FFmpegVideoDecoder(
       base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory),
-                 "VideoDecoderThread"),
+                 media::MessageLoopFactory::kVideoDecoder),
       NULL));
 
   // Create our video renderer and save a reference to it for painting.
@@ -283,7 +283,7 @@ int main(int argc, char** argv) {
       new DataSourceLogger(CreateFileDataSource(filename),
                            command_line->HasSwitch("streaming")));
 
-  if (InitPipeline(thread->message_loop(), data_source,
+  if (InitPipeline(thread->message_loop_proxy(), data_source,
                    paint_cb, command_line->HasSwitch("audio"),
                    &pipeline, &message_loop, message_loop_factory.get())) {
     // Main loop of the application.
diff --git a/media/tools/seek_tester/seek_tester.cc b/media/tools/seek_tester/seek_tester.cc
index 72d709c..69d7b2e 100644
--- a/media/tools/seek_tester/seek_tester.cc
+++ b/media/tools/seek_tester/seek_tester.cc
@@ -67,7 +67,7 @@ int main(int argc, char** argv) {
   MessageLoop loop;
   media::PipelineStatusCB quitter = base::Bind(&QuitMessageLoop, &loop);
   scoped_refptr<media::FFmpegDemuxer> demuxer(
-      new media::FFmpegDemuxer(&loop, file_data_source));
+      new media::FFmpegDemuxer(loop.message_loop_proxy(), file_data_source));
   demuxer->Initialize(&host, quitter);
   loop.Run();