Remove MessageLoop methods from Filter interface

webkit/glue/webmediaplayer_impl.cc

 // Copyright (c) 2010 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.
 
 #include "webkit/glue/webmediaplayer_impl.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 207 matching lines @@
     scoped_refptr<media::VideoFrame> frame) {
   if (video_renderer_)
     video_renderer_->PutCurrentFrame(frame);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // WebMediaPlayerImpl implementation
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebMediaPlayerClient* client,
-    media::FilterCollection* collection)
+    media::FilterCollection* collection,
+    media::MessageLoopFactory* message_loop_factory)
     : network_state_(WebKit::WebMediaPlayer::Empty),
       ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_collection_(collection),
       pipeline_(NULL),
-      pipeline_thread_("PipelineThread"),
+      message_loop_factory_(message_loop_factory),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       client_(client),
       proxy_(NULL),
       pipeline_stopped_(false, false) {
   // Saves the current message loop.
   DCHECK(!main_loop_);
   main_loop_ = MessageLoop::current();
 }
 
 bool WebMediaPlayerImpl::Initialize(
     WebKit::WebFrame* frame,
     bool use_simple_data_source,
     scoped_refptr<WebVideoRenderer> web_video_renderer) {
-  // Create the pipeline and its thread.
-  if (!pipeline_thread_.Start()) {
+  MessageLoop* pipeline_message_loop =
+      message_loop_factory_->GetMessageLoop("PipelineThread");
+  if (!pipeline_message_loop) {
     NOTREACHED() << "Could not start PipelineThread";
     return false;
   }
 
-  pipeline_ = new media::PipelineImpl(pipeline_thread_.message_loop());
+  pipeline_ = new media::PipelineImpl(pipeline_message_loop);
 
   // Also we want to be notified of |main_loop_| destruction.
   main_loop_->AddDestructionObserver(this);
 
   // Creates the proxy.
   proxy_ = new Proxy(main_loop_, this);
   web_video_renderer->SetWebMediaPlayerImplProxy(proxy_);
   proxy_->SetVideoRenderer(web_video_renderer);
 
   // Set our pipeline callbacks.
@@ skipping 16 matching lines @@
 
   if (use_simple_data_source) {
     filter_collection_->AddDataSource(simple_data_source);
     filter_collection_->AddDataSource(buffered_data_source);
   } else {
     filter_collection_->AddDataSource(buffered_data_source);
     filter_collection_->AddDataSource(simple_data_source);
   }
 
   // Add in the default filter factories.
-  filter_collection_->AddDemuxer(new media::FFmpegDemuxer());
-  filter_collection_->AddAudioDecoder(new media::FFmpegAudioDecoder());
-  filter_collection_->AddVideoDecoder(new media::FFmpegVideoDecoder(NULL));
+  filter_collection_->AddDemuxer(new media::FFmpegDemuxer(
+      message_loop_factory_->GetMessageLoop("DemuxThread")));
+  filter_collection_->AddAudioDecoder(new media::FFmpegAudioDecoder(
+      message_loop_factory_->GetMessageLoop("AudioDecoderThread")));
+  filter_collection_->AddVideoDecoder(new media::FFmpegVideoDecoder(
+      message_loop_factory_->GetMessageLoop("VideoDecoderThread"), NULL));
   filter_collection_->AddAudioRenderer(new media::NullAudioRenderer());
 
   return true;
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   Destroy();
 
   // Finally tell the |main_loop_| we don't want to be notified of destruction
   // event.
@@ skipping 481 matching lines @@
   // not blocked when issuing stop commands to the other filters.
   if (proxy_)
     proxy_->AbortDataSource();
 
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   if (pipeline_) {
     pipeline_->Stop(NewCallback(this,
         &WebMediaPlayerImpl::PipelineStoppedCallback));
     pipeline_stopped_.Wait();
-    pipeline_thread_.Stop();
   }
 
+  message_loop_factory_.reset();
+
   // And then detach the proxy, it may live on the render thread for a little
   // longer until all the tasks are finished.
   if (proxy_) {
     proxy_->Detach();
     proxy_ = NULL;
   }
 }
 
 void WebMediaPlayerImpl::PipelineStoppedCallback() {
   pipeline_stopped_.Signal();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue