Stopgap fix for crash in issue 53867 comment 15

media/base/pipeline_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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
@@ skipping 919 matching lines @@
   } else {
     // Destroying filters due to SetError().
     state_ = kError;
     // If our owner has requested to be notified of an error.
     if (error_callback_.get()) {
       error_callback_->Run();
     }
   }
 }
 
-void PipelineImpl::PrepareFilter(scoped_refptr<MediaFilter> filter) {
+bool PipelineImpl::PrepareFilter(scoped_refptr<MediaFilter> filter) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   // Create a dedicated thread for this filter if applicable.
   if (filter->requires_message_loop()) {
     scoped_ptr<base::Thread> thread(
         new base::Thread(filter->message_loop_name()));
     if (!thread.get() || !thread->Start()) {
       NOTREACHED() << "Could not start filter thread";
       SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
-      return;
+      return false;
     }
 
     filter->set_message_loop(thread->message_loop());
     filter_threads_.push_back(thread.release());
   }
 
   // Register ourselves as the filter's host.
   DCHECK(IsPipelineOk());
   filter->set_host(this);
   filters_.push_back(make_scoped_refptr(filter.get()));
+  return true;
 }
 
 void PipelineImpl::InitializeDataSource() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DataSource> data_source;
   while (true) {
     filter_collection_->SelectDataSource(&data_source);
     if (!data_source || data_source->IsUrlSupported(url_))
       break;
   }
 
   if (!data_source) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
-  PrepareFilter(data_source);
+  if (!PrepareFilter(data_source)) {
+    return;
+  }
+
   pipeline_init_state_->data_source_ = data_source;
   data_source->Initialize(
       url_, NewCallback(this, &PipelineImpl::OnFilterInitialize));
 }
 
 void PipelineImpl::InitializeDemuxer(
     const scoped_refptr<DataSource>& data_source) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<Demuxer> demuxer;
 
   CHECK(data_source);
 
   filter_collection_->SelectDemuxer(&demuxer);
   if (!demuxer) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
-  PrepareFilter(demuxer);
+  if (!PrepareFilter(demuxer)) {
+    return;
+  }
+
   pipeline_init_state_->demuxer_ = demuxer;
   demuxer->Initialize(data_source,
                       NewCallback(this, &PipelineImpl::OnFilterInitialize));
 }
 
 bool PipelineImpl::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       FindDemuxerStream(demuxer, mime_type::kMajorTypeAudio);
 
-  if (stream) {
-    scoped_refptr<AudioDecoder> audio_decoder;
-    filter_collection_->SelectAudioDecoder(&audio_decoder);
+  if (!stream)
+    return false;
 
-    if (audio_decoder) {
-      PrepareFilter(audio_decoder);
-      pipeline_init_state_->audio_decoder_ = audio_decoder;
-      audio_decoder->Initialize(
-          stream,
-          NewCallback(this, &PipelineImpl::OnFilterInitialize));
-      return true;
-    } else {
-      SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
-    }
+  scoped_refptr<AudioDecoder> audio_decoder;
+  filter_collection_->SelectAudioDecoder(&audio_decoder);
+
+  if (!audio_decoder) {
+    SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
+    return false;
   }
 
-  return false;
+  if (!PrepareFilter(audio_decoder))
+    return false;
+
+  pipeline_init_state_->audio_decoder_ = audio_decoder;
+  audio_decoder->Initialize(
+      stream,
+      NewCallback(this, &PipelineImpl::OnFilterInitialize));
+  return true;
 }
 
 bool PipelineImpl::InitializeVideoDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       FindDemuxerStream(demuxer, mime_type::kMajorTypeVideo);
 
-  if (stream) {
-    scoped_refptr<VideoDecoder> video_decoder;
-    filter_collection_->SelectVideoDecoder(&video_decoder);
+  if (!stream)
+    return false;
 
-    if (video_decoder) {
-      PrepareFilter(video_decoder);
-      pipeline_init_state_->video_decoder_ = video_decoder;
-      video_decoder->Initialize(
-          stream,
-          NewCallback(this, &PipelineImpl::OnFilterInitialize));
-      return true;
-    } else {
-      SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
-    }
+  scoped_refptr<VideoDecoder> video_decoder;
+  filter_collection_->SelectVideoDecoder(&video_decoder);
+
+  if (!video_decoder) {
+    SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
+    return false;
   }
-  return false;
+
+  if (!PrepareFilter(video_decoder))
+    return false;
+
+  pipeline_init_state_->video_decoder_ = video_decoder;
+  video_decoder->Initialize(
+      stream,
+      NewCallback(this, &PipelineImpl::OnFilterInitialize));
+  return true;
 }
 
 bool PipelineImpl::InitializeAudioRenderer(
     const scoped_refptr<AudioDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
-  if (decoder) {
-    filter_collection_->SelectAudioRenderer(&audio_renderer_);
+  if (!decoder)
+    return false;
 
-    if (audio_renderer_) {
-      PrepareFilter(audio_renderer_);
-      audio_renderer_->Initialize(
-          decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
-      return true;
-    } else {
-      SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
-    }
+  filter_collection_->SelectAudioRenderer(&audio_renderer_);
+  if (!audio_renderer_) {
+    SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
+    return false;
   }
-  return false;
+
+  if (!PrepareFilter(audio_renderer_))
+    return false;
+
+  audio_renderer_->Initialize(
+      decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
+  return true;
 }
 
 bool PipelineImpl::InitializeVideoRenderer(
     const scoped_refptr<VideoDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
-  if (decoder) {
-    filter_collection_->SelectVideoRenderer(&video_renderer_);
+  if (!decoder)
+    return false;
 
-    if (video_renderer_) {
-      PrepareFilter(video_renderer_);
-      video_renderer_->Initialize(
-          decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
-      return true;
-    } else {
-      SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
-    }
+  filter_collection_->SelectVideoRenderer(&video_renderer_);
+  if (!video_renderer_) {
+    SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
+    return false;
   }
-  return false;
+
+  if (!PrepareFilter(video_renderer_))
+    return false;
+
+  video_renderer_->Initialize(
+      decoder, NewCallback(this, &PipelineImpl::OnFilterInitialize));
+  return true;
 }
 
 scoped_refptr<DemuxerStream> PipelineImpl::FindDemuxerStream(
     const scoped_refptr<Demuxer>& demuxer,
     std::string major_mime_type) {
   DCHECK(demuxer);
 
   const int num_outputs = demuxer->GetNumberOfStreams();
   for (int i = 0; i < num_outputs; ++i) {
     std::string value;
@@ skipping 30 matching lines @@
           this, &PipelineImpl::OnFilterStateTransition));
     }
   } else {
     state_ = kStopped;
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media