Implemented injected message loops for PipelineImpl.

webkit/glue/webmediaplayer_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.
 
 #include "webkit/glue/webmediaplayer_impl.h"
 
 #include "base/command_line.h"
 #include "googleurl/src/gurl.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
@@ skipping 125 matching lines @@
 
 void WebMediaPlayerImpl::Proxy::PipelineInitializationCallback(bool success) {
   if (success) {
     // Since we have initialized the pipeline, say we have everything.
     // TODO(hclam): change this to report the correct status. Should also post
     // a task to call to |webmediaplayer_|.
     ReadyStateChanged(WebKit::WebMediaPlayer::HaveMetadata);
     ReadyStateChanged(WebKit::WebMediaPlayer::HaveEnoughData);
     NetworkStateChanged(WebKit::WebMediaPlayer::Loaded);
   } else {
-    // TODO(hclam): should use pipeline_.GetError() to determine the state
+    // TODO(hclam): should use pipeline_->GetError() to determine the state
     // properly and reports error using MediaError.
     // WebKit uses FormatError to indicate an error for bogus URL or bad file.
     // Since we are at the initialization stage we can safely treat every error
     // as format error. Should post a task to call to |webmediaplayer_|.
     NetworkStateChanged(WebKit::WebMediaPlayer::FormatError);
   }
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineSeekCallback(bool success) {
   if (success)
     TimeChanged();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // WebMediaPlayerImpl implementation
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(WebKit::WebMediaPlayerClient* client,
                                        media::FilterFactoryCollection* factory)
     : network_state_(WebKit::WebMediaPlayer::Empty),
       ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_factory_(factory),
+      pipeline_thread_("PipelineThread"),
       client_(client) {
   // Saves the current message loop.
   DCHECK(!main_loop_);
   main_loop_ = MessageLoop::current();
 
+  // Create the pipeline and its thread.
+  if (!pipeline_thread_.Start()) {
+    NOTREACHED() << "Could not start PipelineThread";
+  } else {
+    pipeline_.reset(new media::PipelineImpl(pipeline_thread_.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);
 
   // Add in the default filter factories.
   filter_factory_->AddFactory(media::FFmpegDemuxer::CreateFilterFactory());
   filter_factory_->AddFactory(media::FFmpegAudioDecoder::CreateFactory());
   filter_factory_->AddFactory(media::FFmpegVideoDecoder::CreateFactory());
@@ skipping 11 matching lines @@
   }
 }
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(proxy_);
 
   // Initialize the pipeline.
   SetNetworkState(WebKit::WebMediaPlayer::Loading);
   SetReadyState(WebKit::WebMediaPlayer::HaveNothing);
-  pipeline_.Start(
+  pipeline_->Start(
       filter_factory_.get(),
       url.spec(),
       NewCallback(proxy_.get(),
                   &WebMediaPlayerImpl::Proxy::PipelineInitializationCallback));
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
   DCHECK(MessageLoop::current() == main_loop_);
 }
 
 void WebMediaPlayerImpl::play() {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): We should restore the previous playback rate rather than
   // having it at 1.0.
-  pipeline_.SetPlaybackRate(1.0f);
+  pipeline_->SetPlaybackRate(1.0f);
 }
 
 void WebMediaPlayerImpl::pause() {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  pipeline_.SetPlaybackRate(0.0f);
+  pipeline_->SetPlaybackRate(0.0f);
 }
 
 void WebMediaPlayerImpl::seek(float seconds) {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // Try to preserve as much accuracy as possible.
   float microseconds = seconds * base::Time::kMicrosecondsPerSecond;
   if (seconds != 0)
-  pipeline_.Seek(
+  pipeline_->Seek(
       base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds)),
       NewCallback(proxy_.get(),
                   &WebMediaPlayerImpl::Proxy::PipelineSeekCallback));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): add method call when it has been implemented.
   return;
 }
 
 void WebMediaPlayerImpl::setRate(float rate) {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  pipeline_.SetPlaybackRate(rate);
+  pipeline_->SetPlaybackRate(rate);
 }
 
 void WebMediaPlayerImpl::setVolume(float volume) {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  pipeline_.SetVolume(volume);
+  pipeline_->SetVolume(volume);
 }
 
 void WebMediaPlayerImpl::setVisible(bool visible) {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): add appropriate method call when pipeline has it implemented.
   return;
 }
 
 bool WebMediaPlayerImpl::setAutoBuffer(bool autoBuffer) {
   DCHECK(MessageLoop::current() == main_loop_);
 
   return false;
 }
 
 bool WebMediaPlayerImpl::totalBytesKnown() {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return pipeline_.GetTotalBytes() != 0;
+  return pipeline_->GetTotalBytes() != 0;
 }
 
 bool WebMediaPlayerImpl::hasVideo() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   size_t width, height;
-  pipeline_.GetVideoSize(&width, &height);
+  pipeline_->GetVideoSize(&width, &height);
   return width != 0 && height != 0;
 }
 
 WebKit::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   size_t width, height;
-  pipeline_.GetVideoSize(&width, &height);
+  pipeline_->GetVideoSize(&width, &height);
   return WebKit::WebSize(width, height);
 }
 
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return pipeline_.GetPlaybackRate() == 0.0f;
+  return pipeline_->GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   return false;
 }
 
 float WebMediaPlayerImpl::duration() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return static_cast<float>(pipeline_.GetDuration().InSecondsF());
+  return static_cast<float>(pipeline_->GetDuration().InSecondsF());
 }
 
 float WebMediaPlayerImpl::currentTime() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return static_cast<float>(pipeline_.GetTime().InSecondsF());
+  return static_cast<float>(pipeline_->GetTime().InSecondsF());
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
 float WebMediaPlayerImpl::maxTimeBuffered() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return static_cast<float>(pipeline_.GetBufferedTime().InSecondsF());
+  return static_cast<float>(pipeline_->GetBufferedTime().InSecondsF());
 }
 
 float WebMediaPlayerImpl::maxTimeSeekable() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(scherkus): move this logic down into the pipeline.
-  if (pipeline_.GetTotalBytes() == 0) {
+  if (pipeline_->GetTotalBytes() == 0) {
     return 0.0f;
   }
-  double total_bytes = static_cast<double>(pipeline_.GetTotalBytes());
-  double buffered_bytes = static_cast<double>(pipeline_.GetBufferedBytes());
-  double duration = static_cast<double>(pipeline_.GetDuration().InSecondsF());
+  double total_bytes = static_cast<double>(pipeline_->GetTotalBytes());
+  double buffered_bytes = static_cast<double>(pipeline_->GetBufferedBytes());
+  double duration = static_cast<double>(pipeline_->GetDuration().InSecondsF());
   return static_cast<float>(duration * (buffered_bytes / total_bytes));
 }
 
 unsigned long long WebMediaPlayerImpl::bytesLoaded() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return pipeline_.GetBufferedBytes();
+  return pipeline_->GetBufferedBytes();
 }
 
 unsigned long long WebMediaPlayerImpl::totalBytes() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
-  return pipeline_.GetTotalBytes();
+  return pipeline_->GetTotalBytes();
 }
 
 void WebMediaPlayerImpl::setSize(const WebSize& size) {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(proxy_);
 
   proxy_->SetSize(gfx::Rect(0, 0, size.width, size.height));
 }
 
 void WebMediaPlayerImpl::paint(WebCanvas* canvas,
@@ skipping 34 matching lines @@
   if (ready_state_ != state) {
     ready_state_ = state;
     GetClient()->readyStateChanged();
   }
 }
 
 void WebMediaPlayerImpl::Destroy() {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // Make sure to kill the pipeline so there's no more media threads running.
-  // TODO(hclam): stopping the pipeline is synchronous so it might block
-  // stopping for a long time.
-  pipeline_.Stop();
+  // TODO(hclam): stopping the pipeline might block for a long time.
+  pipeline_->Stop(NULL);
+  pipeline_thread_.Stop();
 
   // 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;
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue