Remove MessageLoopProxy-getting callbacks from various media classes.

Now that the pipeline and decoder threads are combined we can guarantee that a thread exists at construction time.

BUG=116873
TBR=jamesr

Review URL: https://codereview.chromium.org/11411110

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

33 files changed, 126 insertions, 208 deletions

diff --git a/content/renderer/media/media_stream_impl.cc b/content/renderer/media/media_stream_impl.cc
index 47d56ee..04f3d1d 100644
--- a/content/renderer/media/media_stream_impl.cc
+++ b/content/renderer/media/media_stream_impl.cc
@@ -19,7 +19,6 @@
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
-#include "media/base/message_loop_factory.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
@@ -245,7 +244,7 @@ MediaStreamImpl::GetVideoFrameProvider(
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url,
-    media::MessageLoopFactory* message_loop_factory) {
+    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
   DCHECK(CalledOnValidThread());
   WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
 
@@ -257,7 +256,7 @@ scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
 
   webrtc::MediaStreamInterface* stream = GetNativeMediaStream(descriptor);
   if (stream)
-    return CreateVideoDecoder(stream, message_loop_factory);
+    return CreateVideoDecoder(stream, message_loop);
   NOTREACHED();
   return NULL;
 }
@@ -532,7 +531,7 @@ MediaStreamImpl::CreateVideoFrameProvider(
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateVideoDecoder(
     webrtc::MediaStreamInterface* stream,
-    media::MessageLoopFactory* message_loop_factory) {
+    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
@@ -540,8 +539,7 @@ scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateVideoDecoder(
            << stream->label();
 
   return new RTCVideoDecoder(
-      message_loop_factory->GetMessageLoop(
-          media::MessageLoopFactory::kPipeline),
+      message_loop,
       base::MessageLoopProxy::current(),
       stream->video_tracks()->at(0));
 }
diff --git a/content/renderer/media/media_stream_impl.h b/content/renderer/media/media_stream_impl.h
index 3070d9b..268b06c 100644
--- a/content/renderer/media/media_stream_impl.h
+++ b/content/renderer/media/media_stream_impl.h
@@ -24,6 +24,10 @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebUserMediaRequest.h"
 #include "webkit/media/media_stream_client.h"
 
+namespace base{
+class MessageLoopProxy;
+}
+
 namespace webkit_media {
 class MediaStreamAudioRenderer;
 }
@@ -78,7 +82,7 @@ class CONTENT_EXPORT MediaStreamImpl
       const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) OVERRIDE;
   virtual scoped_refptr<media::VideoDecoder> GetVideoDecoder(
       const GURL& url,
-      media::MessageLoopFactory* message_loop_factory) OVERRIDE;
+      const scoped_refptr<base::MessageLoopProxy>& message_loop) OVERRIDE;
   virtual scoped_refptr<webkit_media::MediaStreamAudioRenderer>
       GetAudioRenderer(const GURL& url) OVERRIDE;
 
@@ -166,7 +170,7 @@ class CONTENT_EXPORT MediaStreamImpl
       const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb);
   scoped_refptr<media::VideoDecoder> CreateVideoDecoder(
       webrtc::MediaStreamInterface* stream,
-      media::MessageLoopFactory* message_loop_factory);
+      const scoped_refptr<base::MessageLoopProxy>& message_loop);
   scoped_refptr<WebRtcAudioRenderer> CreateRemoteAudioRenderer(
         webrtc::MediaStreamInterface* stream);
 
diff --git a/content/renderer/media/media_stream_impl_unittest.cc b/content/renderer/media/media_stream_impl_unittest.cc
index aadfb74..173717a 100644
--- a/content/renderer/media/media_stream_impl_unittest.cc
+++ b/content/renderer/media/media_stream_impl_unittest.cc
@@ -11,7 +11,6 @@
 #include "content/renderer/media/mock_media_stream_dispatcher.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "media/base/video_decoder.h"
-#include "media/base/message_loop_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamDescriptor.h"
@@ -150,24 +149,22 @@ TEST_F(MediaStreamImplTest, LocalMediaStream) {
   WebKit::WebMediaStreamDescriptor mixed_desc = RequestLocalMediaStream(true,
                                                                         true);
   // Create a renderer for the stream.
-  scoped_ptr<media::MessageLoopFactory> message_loop_factory(
-      new media::MessageLoopFactory());
   scoped_refptr<media::VideoDecoder> mixed_decoder(
-      ms_impl_->GetVideoDecoder(GURL(), message_loop_factory.get()));
+      ms_impl_->GetVideoDecoder(GURL(), base::MessageLoopProxy::current()));
   EXPECT_TRUE(mixed_decoder.get() != NULL);
 
   // Test a stream with audio only.
   WebKit::WebMediaStreamDescriptor audio_desc = RequestLocalMediaStream(true,
                                                                         false);
   scoped_refptr<media::VideoDecoder> audio_decoder(
-      ms_impl_->GetVideoDecoder(GURL(), message_loop_factory.get()));
+      ms_impl_->GetVideoDecoder(GURL(), base::MessageLoopProxy::current()));
   EXPECT_TRUE(audio_decoder.get() == NULL);
 
   // Test a stream with video only.
   WebKit::WebMediaStreamDescriptor video_desc = RequestLocalMediaStream(false,
                                                                         true);
   scoped_refptr<media::VideoDecoder> video_decoder(
-      ms_impl_->GetVideoDecoder(GURL(), message_loop_factory.get()));
+      ms_impl_->GetVideoDecoder(GURL(), base::MessageLoopProxy::current()));
   EXPECT_TRUE(video_decoder.get() != NULL);
 
   // Stop generated local streams.
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index e66a7cd..5f1411c 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -2588,9 +2588,8 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
         RenderThreadImpl::current()->EstablishGpuChannelSync(
             CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
     collection->GetVideoDecoders()->push_back(new media::GpuVideoDecoder(
-        base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                   base::Unretained(message_loop_factory),
-                   media::MessageLoopFactory::kPipeline),
+        message_loop_factory->GetMessageLoop(
+            media::MessageLoopFactory::kPipeline),
         factories_loop,
         new RendererGpuVideoDecoderFactories(
             gpu_channel_host, factories_loop, context3d)));
diff --git a/media/filters/decrypting_audio_decoder.cc b/media/filters/decrypting_audio_decoder.cc
index c7dd5d8..822bf2b 100644
--- a/media/filters/decrypting_audio_decoder.cc
+++ b/media/filters/decrypting_audio_decoder.cc
@@ -35,9 +35,9 @@ static inline bool IsOutOfSync(const base::TimeDelta& timestamp_1,
 }
 
 DecryptingAudioDecoder::DecryptingAudioDecoder(
-    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const RequestDecryptorNotificationCB& request_decryptor_notification_cb)
-    : message_loop_factory_cb_(message_loop_factory_cb),
+    : message_loop_(message_loop),
       state_(kUninitialized),
       request_decryptor_notification_cb_(request_decryptor_notification_cb),
       decryptor_(NULL),
@@ -54,11 +54,13 @@ void DecryptingAudioDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
-  DCHECK(!message_loop_);
-  message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &DecryptingAudioDecoder::DoInitialize, this,
-      stream, status_cb, statistics_cb));
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &DecryptingAudioDecoder::DoInitialize, this,
+        stream, status_cb, statistics_cb));
+    return;
+  }
+  DoInitialize(stream, status_cb, statistics_cb);
 }
 
 void DecryptingAudioDecoder::Read(const ReadCB& read_cb) {
diff --git a/media/filters/decrypting_audio_decoder.h b/media/filters/decrypting_audio_decoder.h
index 8f732d5..40995a4 100644
--- a/media/filters/decrypting_audio_decoder.h
+++ b/media/filters/decrypting_audio_decoder.h
@@ -31,9 +31,6 @@ class Decryptor;
 // DecryptingAudioDecoder for audio decoding.
 class MEDIA_EXPORT DecryptingAudioDecoder : public AudioDecoder {
  public:
-  // Callback to get a message loop.
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
   // Callback to notify decryptor creation.
   typedef base::Callback<void(Decryptor*)> DecryptorNotificationCB;
   // Callback to request/cancel decryptor creation notification.
@@ -47,7 +44,7 @@ class MEDIA_EXPORT DecryptingAudioDecoder : public AudioDecoder {
       RequestDecryptorNotificationCB;
 
   DecryptingAudioDecoder(
-      const MessageLoopFactoryCB& message_loop_factory_cb,
+      const scoped_refptr<base::MessageLoopProxy>& message_loop,
       const RequestDecryptorNotificationCB& request_decryptor_notification_cb);
 
   // AudioDecoder implementation.
@@ -125,9 +122,6 @@ class MEDIA_EXPORT DecryptingAudioDecoder : public AudioDecoder {
   // Converts number of samples to duration.
   base::TimeDelta NumberOfSamplesToDuration(int number_of_samples) const;
 
-  // This is !is_null() iff Initialize() hasn't been called.
-  MessageLoopFactoryCB message_loop_factory_cb_;
-
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   State state_;
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index cbb1a5f..b4c2a7b 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -16,7 +16,6 @@
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/filters/decrypting_audio_decoder.h"
-#include "media/filters/ffmpeg_decoder_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ -72,8 +71,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
  public:
   DecryptingAudioDecoderTest()
       : decoder_(new DecryptingAudioDecoder(
-            base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
-                       message_loop_.message_loop_proxy()),
+            message_loop_.message_loop_proxy(),
             base::Bind(
                 &DecryptingAudioDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
diff --git a/media/filters/decrypting_demuxer_stream.cc b/media/filters/decrypting_demuxer_stream.cc
index 02ee0c5..454f8a7 100644
--- a/media/filters/decrypting_demuxer_stream.cc
+++ b/media/filters/decrypting_demuxer_stream.cc
@@ -23,9 +23,9 @@ namespace media {
     media::BindToLoop(message_loop_, base::Bind(function, this))
 
 DecryptingDemuxerStream::DecryptingDemuxerStream(
-    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const RequestDecryptorNotificationCB& request_decryptor_notification_cb)
-    : message_loop_factory_cb_(message_loop_factory_cb),
+    : message_loop_(message_loop),
       state_(kUninitialized),
       stream_type_(UNKNOWN),
       request_decryptor_notification_cb_(request_decryptor_notification_cb),
@@ -36,11 +36,12 @@ DecryptingDemuxerStream::DecryptingDemuxerStream(
 void DecryptingDemuxerStream::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb) {
-  DCHECK(!message_loop_);
-  message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &DecryptingDemuxerStream::DoInitialize, this,
-      stream, status_cb));
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &DecryptingDemuxerStream::DoInitialize, this, stream, status_cb));
+    return;
+  }
+  DoInitialize(stream, status_cb);
 }
 
 void DecryptingDemuxerStream::Read(const ReadCB& read_cb) {
diff --git a/media/filters/decrypting_demuxer_stream.h b/media/filters/decrypting_demuxer_stream.h
index 28174be..bb86dec 100644
--- a/media/filters/decrypting_demuxer_stream.h
+++ b/media/filters/decrypting_demuxer_stream.h
@@ -24,10 +24,6 @@ class DecoderBuffer;
 // that no locks are required for thread safety.
 class MEDIA_EXPORT DecryptingDemuxerStream : public DemuxerStream {
  public:
-  // Callback to get a message loop.
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
-
   // Callback to notify decryptor creation.
   typedef base::Callback<void(Decryptor*)> DecryptorNotificationCB;
 
@@ -42,7 +38,7 @@ class MEDIA_EXPORT DecryptingDemuxerStream : public DemuxerStream {
       RequestDecryptorNotificationCB;
 
   DecryptingDemuxerStream(
-      const MessageLoopFactoryCB& message_loop_factory_cb,
+      const scoped_refptr<base::MessageLoopProxy>& message_loop,
       const RequestDecryptorNotificationCB& request_decryptor_notification_cb);
 
   void Initialize(const scoped_refptr<DemuxerStream>& stream,
@@ -108,9 +104,6 @@ class MEDIA_EXPORT DecryptingDemuxerStream : public DemuxerStream {
   // Returns Decryptor::StreamType converted from |stream_type_|.
   Decryptor::StreamType GetDecryptorStreamType() const;
 
-  // This is !is_null() iff Initialize() hasn't been called.
-  MessageLoopFactoryCB message_loop_factory_cb_;
-
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   State state_;
diff --git a/media/filters/decrypting_demuxer_stream_unittest.cc b/media/filters/decrypting_demuxer_stream_unittest.cc
index 247abf3..f952d82 100644
--- a/media/filters/decrypting_demuxer_stream_unittest.cc
+++ b/media/filters/decrypting_demuxer_stream_unittest.cc
@@ -14,7 +14,6 @@
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/filters/decrypting_demuxer_stream.h"
-#include "media/filters/ffmpeg_decoder_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ -73,8 +72,7 @@ class DecryptingDemuxerStreamTest : public testing::Test {
  public:
   DecryptingDemuxerStreamTest()
       : demuxer_stream_(new DecryptingDemuxerStream(
-            base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
-                       message_loop_.message_loop_proxy()),
+            message_loop_.message_loop_proxy(),
             base::Bind(
                 &DecryptingDemuxerStreamTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
diff --git a/media/filters/decrypting_video_decoder.cc b/media/filters/decrypting_video_decoder.cc
index 48e81d0..bc42ffa 100644
--- a/media/filters/decrypting_video_decoder.cc
+++ b/media/filters/decrypting_video_decoder.cc
@@ -24,9 +24,9 @@ namespace media {
     media::BindToLoop(message_loop_, base::Bind(function, this))
 
 DecryptingVideoDecoder::DecryptingVideoDecoder(
-    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const RequestDecryptorNotificationCB& request_decryptor_notification_cb)
-    : message_loop_factory_cb_(message_loop_factory_cb),
+    : message_loop_(message_loop),
       state_(kUninitialized),
       request_decryptor_notification_cb_(request_decryptor_notification_cb),
       decryptor_(NULL),
@@ -38,11 +38,13 @@ void DecryptingVideoDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
-  DCHECK(!message_loop_);
-  message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &DecryptingVideoDecoder::DoInitialize, this,
-      stream, status_cb, statistics_cb));
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &DecryptingVideoDecoder::DoInitialize, this,
+        stream, status_cb, statistics_cb));
+    return;
+  }
+  DoInitialize(stream, status_cb, statistics_cb);
 }
 
 void DecryptingVideoDecoder::Read(const ReadCB& read_cb) {
diff --git a/media/filters/decrypting_video_decoder.h b/media/filters/decrypting_video_decoder.h
index fe72722..1d8996a 100644
--- a/media/filters/decrypting_video_decoder.h
+++ b/media/filters/decrypting_video_decoder.h
@@ -31,9 +31,6 @@ class Decryptor;
 // DecryptingVideoDecoder for video decoding.
 class MEDIA_EXPORT DecryptingVideoDecoder : public VideoDecoder {
  public:
-  // Callback to get a message loop.
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
   // Callback to notify decryptor creation.
   typedef base::Callback<void(Decryptor*)> DecryptorNotificationCB;
   // Callback to request/cancel decryptor creation notification.
@@ -47,7 +44,7 @@ class MEDIA_EXPORT DecryptingVideoDecoder : public VideoDecoder {
       RequestDecryptorNotificationCB;
 
   DecryptingVideoDecoder(
-      const MessageLoopFactoryCB& message_loop_factory_cb,
+      const scoped_refptr<base::MessageLoopProxy>& message_loop,
       const RequestDecryptorNotificationCB& request_decryptor_notification_cb);
 
   // VideoDecoder implementation.
@@ -119,9 +116,6 @@ class MEDIA_EXPORT DecryptingVideoDecoder : public VideoDecoder {
   // Free decoder resources and call |stop_cb_|.
   void DoStop();
 
-  // This is !is_null() iff Initialize() hasn't been called.
-  MessageLoopFactoryCB message_loop_factory_cb_;
-
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   State state_;
diff --git a/media/filters/decrypting_video_decoder_unittest.cc b/media/filters/decrypting_video_decoder_unittest.cc
index f1991d0..efaf4d8 100644
--- a/media/filters/decrypting_video_decoder_unittest.cc
+++ b/media/filters/decrypting_video_decoder_unittest.cc
@@ -15,7 +15,6 @@
 #include "media/base/mock_filters.h"
 #include "media/base/video_frame.h"
 #include "media/filters/decrypting_video_decoder.h"
-#include "media/filters/ffmpeg_decoder_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ -74,8 +73,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
  public:
   DecryptingVideoDecoderTest()
       : decoder_(new DecryptingVideoDecoder(
-            base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
-                       message_loop_.message_loop_proxy()),
+            message_loop_.message_loop_proxy(),
             base::Bind(
                 &DecryptingVideoDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index c0251ff..a3e0a61 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -34,9 +34,8 @@ static inline bool IsEndOfStream(int result, int decoded_size, Buffer* input) {
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
-    const MessageLoopFactoryCB& message_loop_factory_cb)
-    : message_loop_factory_cb_(message_loop_factory_cb),
-      message_loop_(NULL),
+    const scoped_refptr<base::MessageLoopProxy>& message_loop)
+    : message_loop_(message_loop),
       codec_context_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
@@ -53,20 +52,13 @@ void FFmpegAudioDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
-  // Ensure FFmpeg has been initialized
-  FFmpegGlue::InitializeFFmpeg();
-
-  if (!message_loop_) {
-    message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
-  } else {
-    // TODO(scherkus): initialization currently happens more than once in
-    // PipelineIntegrationTest.BasicPlayback.
-    LOG(ERROR) << "Initialize has already been called.";
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &FFmpegAudioDecoder::DoInitialize, this,
+        stream, status_cb, statistics_cb));
+    return;
   }
-  message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FFmpegAudioDecoder::DoInitialize, this,
-                 stream, status_cb, statistics_cb));
+  DoInitialize(stream, status_cb, statistics_cb);
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& read_cb) {
@@ -112,6 +104,15 @@ void FFmpegAudioDecoder::DoInitialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
+  FFmpegGlue::InitializeFFmpeg();
+
+  if (demuxer_stream_) {
+    // TODO(scherkus): initialization currently happens more than once in
+    // PipelineIntegrationTest.BasicPlayback.
+    LOG(ERROR) << "Initialize has already been called.";
+    CHECK(false);
+  }
+
   demuxer_stream_ = stream;
   const AudioDecoderConfig& config = stream->audio_decoder_config();
   statistics_cb_ = statistics_cb;
diff --git a/media/filters/ffmpeg_audio_decoder.h b/media/filters/ffmpeg_audio_decoder.h
index e2d1736..ef6a9581 100644
--- a/media/filters/ffmpeg_audio_decoder.h
+++ b/media/filters/ffmpeg_audio_decoder.h
@@ -26,10 +26,8 @@ struct QueuedAudioBuffer;
 
 class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
  public:
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
   explicit FFmpegAudioDecoder(
-      const MessageLoopFactoryCB& message_loop_factory_cb);
+      const scoped_refptr<base::MessageLoopProxy>& message_loop);
 
   // AudioDecoder implementation.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
@@ -62,9 +60,6 @@ class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
   // |total_frames_decoded_|.
   base::TimeDelta GetNextOutputTimestamp() const;
 
-  // This is !is_null() iff Initialize() hasn't been called.
-  MessageLoopFactoryCB message_loop_factory_cb_;
-
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   scoped_refptr<DemuxerStream> demuxer_stream_;
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/ffmpeg_audio_decoder_unittest.cc
index cafaeac..2ad7ab8 100644
--- a/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -13,7 +13,6 @@
 #include "media/base/test_data_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
-#include "media/filters/ffmpeg_decoder_unittest.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -30,9 +29,7 @@ ACTION_P(InvokeReadPacket, test) {
 class FFmpegAudioDecoderTest : public testing::Test {
  public:
   FFmpegAudioDecoderTest()
-      : decoder_(new FFmpegAudioDecoder(base::Bind(
-            &Identity<scoped_refptr<base::MessageLoopProxy> >,
-            message_loop_.message_loop_proxy()))),
+      : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy())),
         demuxer_(new StrictMock<MockDemuxerStream>()) {
     FFmpegGlue::InitializeFFmpeg();
 
diff --git a/media/filters/ffmpeg_decoder_unittest.h b/media/filters/ffmpeg_decoder_unittest.h
deleted file mode 100644
index e558c30..0000000
--- a/media/filters/ffmpeg_decoder_unittest.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2012 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.
-
-#ifndef MEDIA_FILTERS_FFMPEG_DECODER_UNITTEST_H_
-#define MEDIA_FILTERS_FFMPEG_DECODER_UNITTEST_H_
-
-namespace media {
-// Used to inject our message loop into the FFmpeg[Audio|Video|Decoder.
-template<class T> T Identity(T t) { return t; }
-}  // namespace media
-
-#endif  // MEDIA_FILTERS_FFMPEG_DECODER_UNITTEST_H_
diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index db70580..85014fb 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -55,10 +55,9 @@ static int GetThreadCount(CodecID codec_id) {
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
-    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     Decryptor* decryptor)
-    : message_loop_factory_cb_(message_loop_factory_cb),
-      message_loop_(NULL),
+    : message_loop_(message_loop),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
@@ -134,18 +133,15 @@ static void ReleaseVideoBufferImpl(AVCodecContext* s, AVFrame* frame) {
 void FFmpegVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                     const PipelineStatusCB& status_cb,
                                     const StatisticsCB& statistics_cb) {
-  FFmpegGlue::InitializeFFmpeg();
-
-  if (!message_loop_) {
-    message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
+  if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Initialize, this,
         stream, status_cb, statistics_cb));
     return;
   }
 
-  DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!demuxer_stream_);
+  FFmpegGlue::InitializeFFmpeg();
+  DCHECK(!demuxer_stream_) << "Already initialized.";
 
   if (!stream) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
diff --git a/media/filters/ffmpeg_video_decoder.h b/media/filters/ffmpeg_video_decoder.h
index e95ceff..e18f88b 100644
--- a/media/filters/ffmpeg_video_decoder.h
+++ b/media/filters/ffmpeg_video_decoder.h
@@ -24,9 +24,7 @@ class DecoderBuffer;
 
 class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
  public:
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
-  FFmpegVideoDecoder(const MessageLoopFactoryCB& message_loop_factory_cb,
+  FFmpegVideoDecoder(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                      Decryptor* decryptor);
 
   // VideoDecoder implementation.
@@ -89,9 +87,6 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
   // Reset decoder and call |reset_cb_|.
   void DoReset();
 
-  // This is !is_null() iff Initialize() hasn't been called.
-  MessageLoopFactoryCB message_loop_factory_cb_;
-
   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 73c058a0..2b20b1d 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -21,7 +21,6 @@
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
-#include "media/filters/ffmpeg_decoder_unittest.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -74,8 +73,7 @@ class FFmpegVideoDecoderTest : public testing::Test {
     FFmpegGlue::InitializeFFmpeg();
 
     decoder_ = new FFmpegVideoDecoder(
-        base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
-                   message_loop_.message_loop_proxy()),
+        message_loop_.message_loop_proxy(),
         decryptor_.get());
 
     // Initialize various test buffers.
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index d59364b..c0f7af4 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -50,11 +50,10 @@ GpuVideoDecoder::BufferData::BufferData(
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
-    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& gvd_loop_proxy,
     const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
     const scoped_refptr<Factories>& factories)
-    : message_loop_factory_cb_(message_loop_factory_cb),
-      gvd_loop_proxy_(NULL),
+    : gvd_loop_proxy_(gvd_loop_proxy),
       vda_loop_proxy_(vda_loop_proxy),
       factories_(factories),
       state_(kNormal),
@@ -63,7 +62,6 @@ GpuVideoDecoder::GpuVideoDecoder(
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       error_occured_(false) {
-  DCHECK(!message_loop_factory_cb_.is_null());
   DCHECK(factories_);
 }
 
@@ -122,8 +120,7 @@ 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_) {
-    gvd_loop_proxy_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
+  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Initialize,
         this, stream, orig_status_cb, statistics_cb));
diff --git a/media/filters/gpu_video_decoder.h b/media/filters/gpu_video_decoder.h
index da3248c..6c1fec3 100644
--- a/media/filters/gpu_video_decoder.h
+++ b/media/filters/gpu_video_decoder.h
@@ -60,9 +60,7 @@ class MEDIA_EXPORT GpuVideoDecoder
     virtual ~Factories();
   };
 
-  typedef base::Callback<
-      scoped_refptr<base::MessageLoopProxy>()> MessageLoopFactoryCB;
-  GpuVideoDecoder(const MessageLoopFactoryCB& message_loop_factory_cb,
+  GpuVideoDecoder(const scoped_refptr<base::MessageLoopProxy>& gvd_loop_proxy,
                   const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
                   const scoped_refptr<Factories>& factories);
 
@@ -159,9 +157,6 @@ 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 3f0da57..4062a47 100644
--- a/media/filters/pipeline_integration_test_base.cc
+++ b/media/filters/pipeline_integration_test_base.cc
@@ -22,7 +22,6 @@ const char kNullHash[] = "d41d8cd98f00b204e9800998ecf8427e";
 
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
-      message_loop_factory_(new MessageLoopFactory()),
       pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
                              new MediaLog())),
       ended_(false),
@@ -198,13 +197,9 @@ PipelineIntegrationTestBase::CreateFilterCollection(
   scoped_ptr<FilterCollection> collection(new FilterCollection());
   collection->SetDemuxer(demuxer);
   scoped_refptr<AudioDecoder> audio_decoder = new FFmpegAudioDecoder(
-      base::Bind(&MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory_.get()),
-                 media::MessageLoopFactory::kPipeline));
+      message_loop_.message_loop_proxy());
   scoped_refptr<VideoDecoder> video_decoder = new FFmpegVideoDecoder(
-      base::Bind(&MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory_.get()),
-                 media::MessageLoopFactory::kPipeline),
+      message_loop_.message_loop_proxy(),
       decryptor);
   collection->GetAudioDecoders()->push_back(audio_decoder);
   collection->GetVideoDecoders()->push_back(video_decoder);
diff --git a/media/filters/pipeline_integration_test_base.h b/media/filters/pipeline_integration_test_base.h
index cd77e3a..b68c428 100644
--- a/media/filters/pipeline_integration_test_base.h
+++ b/media/filters/pipeline_integration_test_base.h
@@ -9,7 +9,6 @@
 #include "base/md5.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/filter_collection.h"
-#include "media/base/message_loop_factory.h"
 #include "media/base/pipeline.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/video_renderer_base.h"
@@ -72,7 +71,6 @@ class PipelineIntegrationTestBase {
   MessageLoop message_loop_;
   base::MD5Context md5_context_;
   bool hashing_enabled_;
-  scoped_ptr<MessageLoopFactory> message_loop_factory_;
   scoped_refptr<Pipeline> pipeline_;
   scoped_refptr<VideoRendererBase> renderer_;
   scoped_refptr<NullAudioSink> audio_sink_;
diff --git a/media/media.gyp b/media/media.gyp
index 76e09b7..0b991e0 100644
--- a/media/media.gyp
+++ b/media/media.gyp
@@ -664,7 +664,6 @@
         'filters/decrypting_demuxer_stream_unittest.cc',
         'filters/decrypting_video_decoder_unittest.cc',
         'filters/ffmpeg_audio_decoder_unittest.cc',
-        'filters/ffmpeg_decoder_unittest.h',
         'filters/ffmpeg_demuxer_unittest.cc',
         'filters/ffmpeg_glue_unittest.cc',
         'filters/ffmpeg_h264_to_annex_b_bitstream_converter_unittest.cc',
diff --git a/media/tools/player_wtl/movie.cc b/media/tools/player_wtl/movie.cc
index 679c4f5..e30abd7 100644
--- a/media/tools/player_wtl/movie.cc
+++ b/media/tools/player_wtl/movie.cc
@@ -76,14 +76,9 @@ bool Movie::Open(const wchar_t* file_path, VideoRendererBase* video_renderer) {
   scoped_ptr<FilterCollection> collection(new FilterCollection());
   collection->SetDemuxer(new FFmpegDemuxer(pipeline_loop, data_source));
   collection->GetAudioDecoders()->push_back(new FFmpegAudioDecoder(
-      base::Bind(&MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory_.get()),
-                 media::MessageLoopFactory::kPipeline)));
+      pipeline_loop));
   collection->GetVideoDecoders()->push_back(new FFmpegVideoDecoder(
-      base::Bind(&MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory_.get()),
-                 media::MessageLoopFactory::kPipeline),
-      NULL));
+      pipeline_loop, NULL));
 
   // TODO(vrk): Re-enabled audio. (crbug.com/112159)
   collection->AddAudioRenderer(
diff --git a/media/tools/player_x11/player_x11.cc b/media/tools/player_x11/player_x11.cc
index a4fe749..5822253 100644
--- a/media/tools/player_x11/player_x11.cc
+++ b/media/tools/player_x11/player_x11.cc
@@ -112,14 +112,9 @@ bool InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
       new media::FilterCollection());
   collection->SetDemuxer(new media::FFmpegDemuxer(message_loop, data_source));
   collection->GetAudioDecoders()->push_back(new media::FFmpegAudioDecoder(
-      base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory),
-                 media::MessageLoopFactory::kPipeline)));
+      message_loop));
   collection->GetVideoDecoders()->push_back(new media::FFmpegVideoDecoder(
-      base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory),
-                 media::MessageLoopFactory::kPipeline),
-      NULL));
+      message_loop, NULL));
 
   // Create our video renderer and save a reference to it for painting.
   g_video_renderer = new media::VideoRendererBase(
diff --git a/webkit/media/filter_helpers.cc b/webkit/media/filter_helpers.cc
index 8003e2a..b708093 100644
--- a/webkit/media/filter_helpers.cc
+++ b/webkit/media/filter_helpers.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "media/base/filter_collection.h"
-#include "media/base/message_loop_factory.h"
 #include "media/filters/decrypting_audio_decoder.h"
 #include "media/filters/decrypting_video_decoder.h"
 #include "media/filters/chunk_demuxer.h"
@@ -28,20 +27,15 @@ namespace webkit_media {
 // stream. Some decoder may only accept certain types of streams. For example,
 // DecryptingVideoDecoder only supports encrypted video stream.
 static void AddDefaultDecodersToCollection(
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor) {
   scoped_refptr<media::FFmpegAudioDecoder> ffmpeg_audio_decoder =
-      new media::FFmpegAudioDecoder(
-          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                     base::Unretained(message_loop_factory),
-                     media::MessageLoopFactory::kPipeline));
+      new media::FFmpegAudioDecoder(message_loop);
 
   scoped_refptr<media::DecryptingAudioDecoder> decrypting_audio_decoder =
       new media::DecryptingAudioDecoder(
-          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                     base::Unretained(message_loop_factory),
-                     media::MessageLoopFactory::kPipeline),
+          message_loop,
           base::Bind(&ProxyDecryptor::RequestDecryptorNotification,
                      base::Unretained(proxy_decryptor)));
 
@@ -50,18 +44,12 @@ static void AddDefaultDecodersToCollection(
 
   scoped_refptr<media::DecryptingVideoDecoder> decrypting_video_decoder =
       new media::DecryptingVideoDecoder(
-          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                     base::Unretained(message_loop_factory),
-                     media::MessageLoopFactory::kPipeline),
+          message_loop,
           base::Bind(&ProxyDecryptor::RequestDecryptorNotification,
                      base::Unretained(proxy_decryptor)));
 
   scoped_refptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder =
-      new media::FFmpegVideoDecoder(
-          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                     base::Unretained(message_loop_factory),
-                     media::MessageLoopFactory::kPipeline),
-          proxy_decryptor);
+      new media::FFmpegVideoDecoder(message_loop, proxy_decryptor);
 
   // TODO(xhwang): Ideally we should have decrypting video decoder after
   // regular video decoder since in the real world most videos are not
@@ -73,15 +61,16 @@ static void AddDefaultDecodersToCollection(
   filter_collection->GetVideoDecoders()->push_back(ffmpeg_video_decoder);
 }
 
-bool BuildMediaStreamCollection(const WebKit::WebURL& url,
-                                MediaStreamClient* client,
-                                media::MessageLoopFactory* message_loop_factory,
-                                media::FilterCollection* filter_collection) {
+bool BuildMediaStreamCollection(
+    const WebKit::WebURL& url,
+    MediaStreamClient* client,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    media::FilterCollection* filter_collection) {
   if (!client)
     return false;
 
   scoped_refptr<media::VideoDecoder> video_decoder = client->GetVideoDecoder(
-      url, message_loop_factory);
+      url, message_loop);
   if (!video_decoder)
     return false;
 
@@ -98,7 +87,7 @@ bool BuildMediaStreamCollection(const WebKit::WebURL& url,
 
 void BuildMediaSourceCollection(
     const scoped_refptr<media::ChunkDemuxer>& demuxer,
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor) {
   DCHECK(demuxer);
@@ -109,21 +98,19 @@ void BuildMediaSourceCollection(
   DCHECK_LE(filter_collection->GetVideoDecoders()->size(), 1u);
   filter_collection->GetVideoDecoders()->clear();
 
-  AddDefaultDecodersToCollection(message_loop_factory, filter_collection,
+  AddDefaultDecodersToCollection(message_loop, filter_collection,
                                  proxy_decryptor);
 }
 
 void BuildDefaultCollection(
     const scoped_refptr<media::DataSource>& data_source,
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor) {
   filter_collection->SetDemuxer(new media::FFmpegDemuxer(
-      message_loop_factory->GetMessageLoop(
-          media::MessageLoopFactory::kPipeline),
-      data_source));
+      message_loop, data_source));
 
-  AddDefaultDecodersToCollection(message_loop_factory, filter_collection,
+  AddDefaultDecodersToCollection(message_loop, filter_collection,
                                  proxy_decryptor);
 }
 
diff --git a/webkit/media/filter_helpers.h b/webkit/media/filter_helpers.h
index ef7a8c7..f280e90 100644
--- a/webkit/media/filter_helpers.h
+++ b/webkit/media/filter_helpers.h
@@ -8,12 +8,15 @@
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 class ChunkDemuxer;
 class DataSource;
 class FFmpegVideoDecoder;
 class FilterCollection;
-class MessageLoopFactory;
 }
 
 namespace WebKit {
@@ -29,16 +32,17 @@ class ProxyDecryptor;
 // |filter_collection| returning true if successful.
 //
 // |filter_collection| is not modified if this method returns false.
-bool BuildMediaStreamCollection(const WebKit::WebURL& url,
-                                MediaStreamClient* client,
-                                media::MessageLoopFactory* message_loop_factory,
-                                media::FilterCollection* filter_collection);
+bool BuildMediaStreamCollection(
+    const WebKit::WebURL& url,
+    MediaStreamClient* client,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    media::FilterCollection* filter_collection);
 
 // Builds the required filters for handling media source URLs, adds them to
 // |filter_collection|.
 void BuildMediaSourceCollection(
     const scoped_refptr<media::ChunkDemuxer>& demuxer,
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor);
 
@@ -46,7 +50,7 @@ void BuildMediaSourceCollection(
 // |filter_collection| and fills |video_decoder| returning true if successful.
 void BuildDefaultCollection(
     const scoped_refptr<media::DataSource>& data_source,
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor);
 
diff --git a/webkit/media/media_stream_client.h b/webkit/media/media_stream_client.h
index 297c1b3..e895c4e 100644
--- a/webkit/media/media_stream_client.h
+++ b/webkit/media/media_stream_client.h
@@ -11,9 +11,12 @@
 
 class GURL;
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 class VideoDecoder;
-class MessageLoopFactory;
 }
 
 namespace webkit_media {
@@ -34,7 +37,7 @@ class MediaStreamClient {
 
   virtual scoped_refptr<media::VideoDecoder> GetVideoDecoder(
       const GURL& url,
-      media::MessageLoopFactory* message_loop_factory) = 0;
+      const scoped_refptr<base::MessageLoopProxy>& message_loop) = 0;
 
   virtual scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
       const GURL& url) = 0;
diff --git a/webkit/media/webmediaplayer_impl.cc b/webkit/media/webmediaplayer_impl.cc
index d69547b..c02e3db 100644
--- a/webkit/media/webmediaplayer_impl.cc
+++ b/webkit/media/webmediaplayer_impl.cc
@@ -257,9 +257,13 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
+  scoped_refptr<base::MessageLoopProxy> message_loop =
+      message_loop_factory_->GetMessageLoop(
+          media::MessageLoopFactory::kPipeline);
+
   // Media streams pipelines can start immediately.
   if (BuildMediaStreamCollection(url, media_stream_client_,
-                                 message_loop_factory_.get(),
+                                 message_loop,
                                  filter_collection_.get())) {
     supports_save_ = false;
     StartPipeline();
@@ -273,7 +277,7 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
         BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""));
 
     BuildMediaSourceCollection(chunk_demuxer_,
-                               message_loop_factory_.get(),
+                               message_loop,
                                filter_collection_.get(),
                                &decryptor_);
     supports_save_ = false;
@@ -295,7 +299,7 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
   BuildDefaultCollection(proxy_->data_source(),
-                         message_loop_factory_.get(),
+                         message_loop,
                          filter_collection_.get(),
                          &decryptor_);
 }
diff --git a/webkit/support/test_media_stream_client.cc b/webkit/support/test_media_stream_client.cc
index bbad1e5..96a85ca 100644
--- a/webkit/support/test_media_stream_client.cc
+++ b/webkit/support/test_media_stream_client.cc
@@ -5,7 +5,6 @@
 #include "webkit/support/test_media_stream_client.h"
 
 #include "googleurl/src/gurl.h"
-#include "media/base/message_loop_factory.h"
 #include "media/base/pipeline.h"
 #include "media/filters/video_frame_generator.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
@@ -61,7 +60,8 @@ TestMediaStreamClient::GetVideoFrameProvider(
 }
 
 scoped_refptr<media::VideoDecoder> TestMediaStreamClient::GetVideoDecoder(
-    const GURL& url, media::MessageLoopFactory* message_loop_factory) {
+    const GURL& url,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
   // This class is installed in a chain of possible VideoDecoder creators
   // which are called in order until one returns an object.
   // Make sure we are dealing with a Mock MediaStream. If not, bail out.
@@ -69,8 +69,7 @@ scoped_refptr<media::VideoDecoder> TestMediaStreamClient::GetVideoDecoder(
     return NULL;
 
   return new media::VideoFrameGenerator(
-      message_loop_factory->GetMessageLoop(
-          media::MessageLoopFactory::kPipeline),
+      message_loop,
       gfx::Size(kVideoCaptureWidth, kVideoCaptureHeight),
       base::TimeDelta::FromMilliseconds(kVideoCaptureFrameDurationMs));
 }
diff --git a/webkit/support/test_media_stream_client.h b/webkit/support/test_media_stream_client.h
index db0e53f..1534565 100644
--- a/webkit/support/test_media_stream_client.h
+++ b/webkit/support/test_media_stream_client.h
@@ -32,7 +32,7 @@ class TestMediaStreamClient : public webkit_media::MediaStreamClient {
       const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) OVERRIDE;
   virtual scoped_refptr<media::VideoDecoder> GetVideoDecoder(
       const GURL& url,
-      media::MessageLoopFactory* message_loop_factory) OVERRIDE;
+      const scoped_refptr<base::MessageLoopProxy>& message_loop) OVERRIDE;
   virtual scoped_refptr<webkit_media::MediaStreamAudioRenderer>
       GetAudioRenderer(const GURL& url) OVERRIDE;
 };