Pipeline will execute a callback whenever an run-time error has happened.

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/base/media_format.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
@@ skipping 75 matching lines @@
 void WebMediaPlayerImpl::Proxy::PipelineInitializationCallback() {
   render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &WebMediaPlayerImpl::Proxy::PipelineInitializationTask));
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineSeekCallback() {
   render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &WebMediaPlayerImpl::Proxy::PipelineSeekTask));
 }
 
+void WebMediaPlayerImpl::Proxy::PipelineErrorCallback() {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+      &WebMediaPlayerImpl::Proxy::PipelineErrorTask));
+}
+
 void WebMediaPlayerImpl::Proxy::RepaintTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   {
     AutoLock auto_lock(lock_);
     --outstanding_repaints_;
     DCHECK_GE(outstanding_repaints_, 0);
   }
   if (webmediaplayer_) {
     webmediaplayer_->Repaint();
   }
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineInitializationTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
     webmediaplayer_->OnPipelineInitialize();
   }
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineSeekTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
     webmediaplayer_->OnPipelineSeek();
   }
 }
 
+void WebMediaPlayerImpl::Proxy::PipelineErrorTask() {
+  DCHECK(MessageLoop::current() == render_loop_);
+  if (webmediaplayer_) {
+    webmediaplayer_->OnPipelineError();
+  }
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // 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"),
       paused_(true),
       playback_rate_(0.0f),
       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_ = new media::PipelineImpl(pipeline_thread_.message_loop());
+    return;
   }
 
+  pipeline_ = 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);
 
+  // Sets the pipeline's error reporting callback.
+  pipeline_->SetPipelineErrorCallback(NewCallback(proxy_.get(),
+      &WebMediaPlayerImpl::Proxy::PipelineErrorCallback));
+
   // Add in the default filter factories.
   filter_factory_->AddFactory(media::FFmpegDemuxer::CreateFilterFactory());
   filter_factory_->AddFactory(media::FFmpegAudioDecoder::CreateFactory());
   filter_factory_->AddFactory(media::FFmpegVideoDecoder::CreateFactory());
   filter_factory_->AddFactory(media::NullAudioRenderer::CreateFilterFactory());
   filter_factory_->AddFactory(VideoRendererImpl::CreateFactory(proxy_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   Destroy();
@@ skipping 235 matching lines @@
   }
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek() {
   DCHECK(MessageLoop::current() == main_loop_);
   if (pipeline_->GetError() == media::PIPELINE_OK) {
     GetClient()->timeChanged();
   }
 }
 
+void WebMediaPlayerImpl::OnPipelineError() {
+  DCHECK(MessageLoop::current() == main_loop_);
+  switch (pipeline_->GetError()) {
+    case media::PIPELINE_OK:
+    case media::PIPELINE_STOPPING:
+      NOTREACHED() << "We shouldn't get called with these non-errors";
+      break;
+
+    case media::PIPELINE_ERROR_INITIALIZATION_FAILED:
+    case media::PIPELINE_ERROR_REQUIRED_FILTER_MISSING:
+    case media::PIPELINE_ERROR_COULD_NOT_RENDER:
+      // Format error.
+      SetNetworkState(WebMediaPlayer::FormatError);
+      break;
+
+    case media::PIPELINE_ERROR_URL_NOT_FOUND:
+    case media::PIPELINE_ERROR_NETWORK:
+    case media::PIPELINE_ERROR_DECODE:
+    case media::PIPELINE_ERROR_ABORT:
+    case media::PIPELINE_ERROR_OUT_OF_MEMORY:
+    case media::PIPELINE_ERROR_READ:
+    case media::PIPELINE_ERROR_AUDIO_HARDWARE:
+    case media::DEMUXER_ERROR_COULD_NOT_OPEN:
+    case media::DEMUXER_ERROR_COULD_NOT_PARSE:
+    case media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS:
+    case media::DEMUXER_ERROR_COULD_NOT_CREATE_THREAD:
+      // Decode error.
+      SetNetworkState(WebMediaPlayer::DecodeError);
+      break;
+  }
+}
+
 void WebMediaPlayerImpl::SetNetworkState(
     WebKit::WebMediaPlayer::NetworkState state) {
   DCHECK(MessageLoop::current() == main_loop_);
   if (network_state_ != state) {
     network_state_ = state;
     GetClient()->networkStateChanged();
   }
 }
 
 void WebMediaPlayerImpl::SetReadyState(
@@ skipping 21 matching lines @@
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue